From c4d81fe5cc5f4e65fcbaf870f3657513cddc4957 Mon Sep 17 00:00:00 2001
From: gsxdsm <gsxdsm@users.noreply.github.com>
Date: Sat, 4 Jul 2026 21:42:55 -0700
Subject: [PATCH 01/65] FN-7524: add AI-undo fallback task for reverting
 done/archived tasks
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Adds an AI-undo fallback to the revert route: when a git-based revert conflicts or is unsupported, an ordinary board task is created to perform the undo via AI instead of a forced/failed git write.

- POST /tasks/:id/revert now accepts an optional `{ mode?: "git" | "ai" | "auto" }` body (default "auto"); unknown values reject with 400.
- "git" preserves the FN-7523 git-only contract unchanged; "ai" always creates the AI-undo task; "auto" tries git first and falls back to AI only on a conflicting or unsupported (e.g. workspace) result — needsHuman (autoMerge:false) never triggers the fallback.
- New engine helpers in task-revert.ts: `createAiUndoTask`, `buildAiUndoTaskDescription`, `REVERT_OF_METADATA_KEY`, plus `AiUndoTaskResult`/`CreateAiUndoTaskDeps` types, exported from packages/engine/src/index.ts.
- The AI-undo task is created via the normal triage-column `store.createTask` path with no dependency on the source task, referencing the source task's mission, id, and landed files, and instructing an undo commit using the `revert(FN-xxxx): ...` convention.
- New core `TaskStore.findOpenRevertTaskForSource` backs an idempotency guard: a repeated call while an AI-undo task is still open returns the same `createdTaskId` with `alreadyOpen: true` instead of creating a duplicate.
- Updated docs/task-management.md's revert section to document the git path + AI-undo fallback contract.
- Added a minor changeset for the @runfusion/fusion release notes.
- Added/extended tests: packages/engine/src/__tests__/task-revert-ai-undo.test.ts (new) and packages/dashboard/src/__tests__/task-revert-route.test.ts (extended) covering mode validation, auto-fallback-on-conflict, forced "ai" mode, and the duplicate-open-task guard.

Files changed:
 .changeset/fn-7524-ai-undo-revert.md               |   7 +
 docs/task-management.md                            |  13 +-
 packages/core/src/store.ts                         |  31 +++++
 packages/dashboard/src/__tests__/task-revert-route.test.ts | 143 ++++++++++++++++++++-
 packages/dashboard/src/routes/register-task-workflow-routes.ts |  75 +++++++++--
 packages/engine/src/__tests__/task-revert-ai-undo.test.ts |  114 ++++++++++++++++
 packages/engine/src/index.ts                       |   5 +
 packages/engine/src/task-revert.ts                 | 117 ++++++++++++++++-
 8 files changed, 487 insertions(+), 18 deletions(-)

Fusion-Task-Id: FN-7524

Fusion-Task-Lineage: 64dfedcf-c286-4c46-8cf8-51ec5e668bf7

Co-authored-by: Fusion (runfusion.ai) <noreply@runfusion.ai>
---
 .changeset/fn-7524-ai-undo-revert.md          |   7 +
 docs/task-management.md                       |  13 +-
 packages/core/src/store.ts                    |  31 ++++
 .../src/__tests__/task-revert-route.test.ts   | 143 +++++++++++++++++-
 .../routes/register-task-workflow-routes.ts   |  75 +++++++--
 .../src/__tests__/task-revert-ai-undo.test.ts | 114 ++++++++++++++
 packages/engine/src/index.ts                  |   5 +
 packages/engine/src/task-revert.ts            | 117 +++++++++++++-
 8 files changed, 487 insertions(+), 18 deletions(-)
 create mode 100644 .changeset/fn-7524-ai-undo-revert.md
 create mode 100644 packages/engine/src/__tests__/task-revert-ai-undo.test.ts

diff --git a/.changeset/fn-7524-ai-undo-revert.md b/.changeset/fn-7524-ai-undo-revert.md
new file mode 100644
index 0000000000..3a78674fac
--- /dev/null
+++ b/.changeset/fn-7524-ai-undo-revert.md
@@ -0,0 +1,7 @@
+---
+"@runfusion/fusion": minor
+---
+
+summary: Add an AI-undo fallback task when reverting a done task via git conflicts or is unsupported.
+category: feature
+dev: `POST /api/tasks/:id/revert` now accepts `{ mode?: "git" | "ai" | "auto" }` (default `"auto"`). `"auto"` tries the FN-7523 git-revert path first and falls back to creating an AI-undo board task (`{ mode: "ai", createdTaskId, alreadyOpen? }`) on a conflicting or unsupported (e.g. workspace) git result; `needsHuman` (autoMerge-off) never triggers the fallback. `"ai"` always creates the AI-undo task; `"git"` keeps the FN-7523 git-only contract, which is otherwise unchanged. New engine exports: `createAiUndoTask`, `buildAiUndoTaskDescription`, `REVERT_OF_METADATA_KEY`. New core store method `TaskStore.findOpenRevertTaskForSource` backs the idempotency guard (an open undo task suppresses a duplicate; a closed one does not).
diff --git a/docs/task-management.md b/docs/task-management.md
index b6dd2dc253..fbe810479a 100644
--- a/docs/task-management.md
+++ b/docs/task-management.md
@@ -673,13 +673,18 @@ Recovery/backfill guidance:
 - If both the active row and archive snapshot were overwritten, Fusion cannot reconstruct lost attachments/comments automatically; recreate them from git history, branch/worktree contents, screenshots, or external issue trackers.
 - Record the incident in the replacement task so future audits understand why the task ID and commit history diverge.
 
-## Reverting Done/Archived tasks (git path)
+## Reverting Done/Archived tasks (git path + AI-undo fallback)
 
 - `POST /api/tasks/:id/revert` (FN-7523) reverts a **Done** or **Archived** task's landed work via git. Only `done`/`archived` tasks are revertable; the source task's column/status is never mutated as a side effect.
 - The engine resolves the task's attributable commit(s) (squash single-commit, rebase/cherry-pick trailer-filtered subset, or lineage-snapshot fallback), performs a non-committing dry-run to classify the outcome, and only writes a real commit when the dry-run is clean.
-- Response contract: `{ mode: "git", clean, revertCommitSha?, conflicts?, alreadyReverted?, unsupported?, needsHuman?, reason? }`. A clean revert lands a `revert(FN-xxxx): ...` commit carrying a `Fusion-Task-Id` trailer on the resolved base branch. A conflicting result creates no commit and leaves the tree/HEAD untouched — this is where a future AI-undo fallback (sibling task) can take over.
-- Workspace (multi-repo) tasks and `autoMerge:false` projects are out of scope for the forced git write and return `unsupported`/`needsHuman` results instead.
-- This is the git path only; no dashboard UI affordance ships with it (see sibling follow-up tasks for the card action and the AI-undo fallback).
+- The route accepts an optional request body `{ mode?: "git" | "ai" | "auto" }` (default `"auto"`; unknown values reject with 400):
+  - `"git"` — the FN-7523 git-only behavior. The result (including a conflicting/unsupported result) is returned as-is and never creates a follow-up task.
+  - `"ai"` — skip git entirely and always create the AI-undo fallback task (FN-7524).
+  - `"auto"` — try git first. A clean/alreadyReverted/needsHuman result is returned unchanged. A conflicting or unsupported (e.g. workspace-task) result falls back to creating the AI-undo task.
+- Git-path response contract (unchanged, additive only): `{ mode: "git", clean, revertCommitSha?, conflicts?, alreadyReverted?, unsupported?, needsHuman?, reason? }`. A clean revert lands a `revert(FN-xxxx): ...` commit carrying a `Fusion-Task-Id` trailer on the resolved base branch.
+- AI-undo response contract: `{ mode: "ai", createdTaskId: "FN-YYYY", alreadyOpen?: true }`. The created task is an ordinary `triage`-column board task (via the normal `store.createTask` path) that references the source task's id, mission, and landed files, and instructs undoing the source task's behavior while preserving unrelated later changes to the same files, using a `revert(FN-xxxx): ...` commit convention. It carries NO dependency on the (already done/archived) source task. A `sourceMetadata.revertOf` marker makes repeated fallback calls idempotent — while an AI-undo task for that source is still open, a further call returns the same `createdTaskId` with `alreadyOpen: true` instead of creating a duplicate; a prior undo task that itself reached `done`/`archived` does not suppress a fresh one.
+- Workspace (multi-repo) tasks return `unsupported` from the git path (routing `auto` to the AI-undo fallback); `autoMerge:false` projects return `needsHuman` and never trigger the AI-undo fallback (a human/future UI decides).
+- No dashboard UI affordance ships with this yet (see the Done/Archived card action follow-up task).
 
 ## GitHub Issue Import and PR Creation
 
diff --git a/packages/core/src/store.ts b/packages/core/src/store.ts
index 03bf74d46d..540e641f62 100644
--- a/packages/core/src/store.ts
+++ b/packages/core/src/store.ts
@@ -6839,6 +6839,37 @@ ${TASK_UPSERT_SQL_ASSIGNMENTS}
     return rows.map((row) => this.rowToTask(row));
   }
 
+  /**
+   * FNXC:TaskRevert 2026-07-04-00:00 (FN-7524 idempotency guard):
+   * Reverse lookup for `sourceMetadata.revertOf === sourceTaskId`, restricted
+   * to OPEN (non `done`/`archived`) tasks — mirrors the `nearDuplicateOf`
+   * reverse-lookup pattern above. Only an OPEN AI-undo task suppresses
+   * creating a new one: a prior undo task that itself reached `done`/`archived`
+   * must NOT block a fresh undo request (the work may need undoing again,
+   * e.g. redone then relanded). Returns the most recently created open match,
+   * or `null` when none exists.
+   */
+  async findOpenRevertTaskForSource(sourceTaskId: string): Promise<Task | null> {
+    const trimmedId = sourceTaskId.trim();
+    if (trimmedId.length === 0) {
+      return null;
+    }
+
+    const selectClause = this.getTaskSelectClause(false, "t");
+    const row = this.db.prepare(`
+      SELECT ${selectClause}
+      FROM tasks t
+      WHERE t."deletedAt" IS NULL
+        AND t."column" != 'archived'
+        AND t."column" != 'done'
+        AND json_extract(t.sourceMetadata, '$.revertOf') = ?
+      ORDER BY t.createdAt DESC
+      LIMIT 1
+    `).get(trimmedId) as TaskRow | undefined;
+
+    return row ? this.rowToTask(row) : null;
+  }
+
   /**
    * FNXC:NearDuplicateDetection 2026-06-14-12:00:
    * FN-6439 requires the store to reconcile persisted duplicate flags after a canonical becomes inactive.
diff --git a/packages/dashboard/src/__tests__/task-revert-route.test.ts b/packages/dashboard/src/__tests__/task-revert-route.test.ts
index 78241e5481..7c90e1a470 100644
--- a/packages/dashboard/src/__tests__/task-revert-route.test.ts
+++ b/packages/dashboard/src/__tests__/task-revert-route.test.ts
@@ -44,6 +44,11 @@ vi.mock("@fusion/engine", async (importOriginal) => {
   };
 });
 
+// FNXC:TaskRevert 2026-07-04-00:00 (FN-7524): `createAiUndoTask` is NOT mocked —
+// these route tests exercise the real engine helper against a fake store
+// (`createTask`/`findOpenRevertTaskForSource`), proving the route wires the
+// AI-undo fallback correctly rather than merely asserting it was "called".
+
 function makeTask(overrides: Partial<Task>): Task {
   return {
     id: "FN-100",
@@ -59,13 +64,34 @@ function makeTask(overrides: Partial<Task>): Task {
   } as Task;
 }
 
-function createMockStore(task: Task): TaskStore {
+function createMockStore(
+  task: Task,
+  opts?: { openUndoTask?: Task | null; createdUndoTask?: Task },
+): TaskStore {
+  let nextId = 800;
+  const createTask = vi.fn().mockImplementation(async (input: { description: string; source?: { sourceParentTaskId?: string; sourceMetadata?: Record<string, unknown> } }) => {
+    const created = opts?.createdUndoTask ?? ({
+      id: `FN-${nextId++}`,
+      lineageId: `FN-${nextId}`,
+      description: input.description,
+      column: "triage",
+      dependencies: [],
+      steps: [],
+      currentStep: 0,
+      sourceParentTaskId: input.source?.sourceParentTaskId,
+      sourceMetadata: input.source?.sourceMetadata,
+    } as unknown as Task);
+    return created;
+  });
+  const findOpenRevertTaskForSource = vi.fn().mockResolvedValue(opts?.openUndoTask ?? null);
   return {
     getSettings: vi.fn().mockResolvedValue({}),
     getSettingsFast: vi.fn().mockResolvedValue({ autoMerge: true }),
     getRootDir: vi.fn().mockReturnValue(makeGitRepoOnMain()),
     getTask: vi.fn().mockResolvedValue(task),
     getTaskCommitAssociationsByLineageId: vi.fn().mockResolvedValue([]),
+    createTask,
+    findOpenRevertTaskForSource,
     on: vi.fn(),
     off: vi.fn(),
   } as unknown as TaskStore;
@@ -82,6 +108,10 @@ async function REQUEST(app: express.Express, method: string, path: string) {
   return performRequest(app, method, path);
 }
 
+async function POST_JSON(app: express.Express, path: string, body: Record<string, unknown>) {
+  return performRequest(app, "POST", path, JSON.stringify(body), { "content-type": "application/json" });
+}
+
 describe("POST /tasks/:id/revert", () => {
   afterEach(() => {
     vi.clearAllMocks();
@@ -108,7 +138,7 @@ describe("POST /tasks/:id/revert", () => {
     expect(res.body).toMatchObject({ mode: "git", clean: true, alreadyReverted: true });
   });
 
-  it("returns a conflicting result without creating an AI-undo follow-up task", async () => {
+  it("mode:'git' returns a conflicting result without creating an AI-undo follow-up task (FN-7524: default mode is now 'auto', which DOES fall back to AI on conflict — explicit 'git' is required to preserve the FN-7523 git-only contract)", async () => {
     const task = makeTask({ column: "done" });
     const store = createMockStore(task);
     performTaskRevertMock.mockResolvedValue({
@@ -117,7 +147,7 @@ describe("POST /tasks/:id/revert", () => {
       conflicts: [{ file: "foo.ts", status: "UU" }],
     });
 
-    const res = await REQUEST(createApp(store), "POST", `/api/tasks/${task.id}/revert`);
+    const res = await POST_JSON(createApp(store), `/api/tasks/${task.id}/revert`, { mode: "git" });
     expect(res.status).toBe(200);
     expect(res.body).toMatchObject({
       mode: "git",
@@ -178,3 +208,110 @@ describe("POST /tasks/:id/revert", () => {
     expect(performTaskRevertMock).not.toHaveBeenCalled();
   });
 });
+
+// FN-7524 Symptom Verification: `{ mode }` request handling + the AI-undo fallback.
+describe("POST /tasks/:id/revert — FN-7524 mode + AI-undo fallback", () => {
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("rejects an invalid mode value with 400 before invoking the engine service", async () => {
+    const task = makeTask({ column: "done" });
+    const store = createMockStore(task);
+
+    const res = await POST_JSON(createApp(store), `/api/tasks/${task.id}/revert`, { mode: "bogus" });
+    expect(res.status).toBe(400);
+    expect(performTaskRevertMock).not.toHaveBeenCalled();
+    expect((store.createTask as ReturnType<typeof vi.fn>)).not.toHaveBeenCalled();
+  });
+
+  it("(a) auto + conflict: creates an AI-undo task and returns { mode: 'ai', createdTaskId }, stamped with the revertOf marker", async () => {
+    const task = makeTask({ id: "FN-901", column: "done" });
+    const store = createMockStore(task);
+    performTaskRevertMock.mockResolvedValue({
+      mode: "git",
+      clean: false,
+      conflicts: [{ file: "foo.ts", status: "UU" }],
+    });
+
+    const res = await POST_JSON(createApp(store), `/api/tasks/${task.id}/revert`, { mode: "auto" });
+    expect(res.status).toBe(200);
+    expect(res.body).toMatchObject({ mode: "ai" });
+    expect((res.body as { createdTaskId?: string }).createdTaskId).toBeTruthy();
+    expect(store.createTask as ReturnType<typeof vi.fn>).toHaveBeenCalledTimes(1);
+    const createInput = (store.createTask as ReturnType<typeof vi.fn>).mock.calls[0][0] as {
+      source?: { sourceParentTaskId?: string; sourceMetadata?: Record<string, unknown> };
+    };
+    expect(createInput.source?.sourceMetadata?.revertOf).toBe("FN-901");
+  });
+
+  it("(b) mode:'ai' forced: creates the AI-undo task without ever invoking the git path", async () => {
+    const task = makeTask({ id: "FN-902", column: "done" });
+    const store = createMockStore(task);
+
+    const res = await POST_JSON(createApp(store), `/api/tasks/${task.id}/revert`, { mode: "ai" });
+    expect(res.status).toBe(200);
+    expect(res.body).toMatchObject({ mode: "ai" });
+    expect(performTaskRevertMock).not.toHaveBeenCalled();
+    expect(store.createTask as ReturnType<typeof vi.fn>).toHaveBeenCalledTimes(1);
+  });
+
+  it("(c) duplicate guard: a second call while an AI-undo task is already open returns the SAME createdTaskId and creates no duplicate", async () => {
+    const task = makeTask({ id: "FN-903", column: "done" });
+    const existingUndo = makeTask({ id: "FN-950", column: "triage", sourceParentTaskId: "FN-903", sourceMetadata: { revertOf: "FN-903" } });
+    const store = createMockStore(task, { openUndoTask: existingUndo });
+
+    const res = await POST_JSON(createApp(store), `/api/tasks/${task.id}/revert`, { mode: "ai" });
+    expect(res.status).toBe(200);
+    expect(res.body).toMatchObject({ mode: "ai", createdTaskId: "FN-950", alreadyOpen: true });
+    expect(store.createTask as ReturnType<typeof vi.fn>).not.toHaveBeenCalled();
+  });
+
+  it("(d) auto + clean: returns the git result and does NOT create an AI-undo task", async () => {
+    const task = makeTask({ id: "FN-904", column: "done" });
+    const store = createMockStore(task);
+    performTaskRevertMock.mockResolvedValue({ mode: "git", clean: true, revertCommitSha: "abc123" });
+
+    const res = await POST_JSON(createApp(store), `/api/tasks/${task.id}/revert`, { mode: "auto" });
+    expect(res.status).toBe(200);
+    expect(res.body).toMatchObject({ mode: "git", clean: true, revertCommitSha: "abc123" });
+    expect(store.createTask as ReturnType<typeof vi.fn>).not.toHaveBeenCalled();
+  });
+
+  it("mode:'git' on a conflicting result returns the raw conflict and NEVER creates an AI-undo task", async () => {
+    const task = makeTask({ id: "FN-905", column: "done" });
+    const store = createMockStore(task);
+    performTaskRevertMock.mockResolvedValue({
+      mode: "git",
+      clean: false,
+      conflicts: [{ file: "foo.ts", status: "UU" }],
+    });
+
+    const res = await POST_JSON(createApp(store), `/api/tasks/${task.id}/revert`, { mode: "git" });
+    expect(res.status).toBe(200);
+    expect(res.body).toMatchObject({ mode: "git", clean: false });
+    expect(store.createTask as ReturnType<typeof vi.fn>).not.toHaveBeenCalled();
+  });
+
+  it("auto + unsupported (workspace) git result falls back to the AI-undo task", async () => {
+    const task = makeTask({ id: "FN-906", column: "done" });
+    const store = createMockStore(task);
+    performTaskRevertMock.mockResolvedValue({ mode: "git", unsupported: true, reason: "workspace-task-revert-unsupported" });
+
+    const res = await POST_JSON(createApp(store), `/api/tasks/${task.id}/revert`, { mode: "auto" });
+    expect(res.status).toBe(200);
+    expect(res.body).toMatchObject({ mode: "ai" });
+    expect(store.createTask as ReturnType<typeof vi.fn>).toHaveBeenCalledTimes(1);
+  });
+
+  it("auto + needsHuman (autoMerge-off) returns the git result and does NOT create an AI-undo task", async () => {
+    const task = makeTask({ id: "FN-907", column: "done" });
+    const store = createMockStore(task);
+    performTaskRevertMock.mockResolvedValue({ mode: "git", needsHuman: true, reason: "autoMerge is disabled" });
+
+    const res = await POST_JSON(createApp(store), `/api/tasks/${task.id}/revert`, { mode: "auto" });
+    expect(res.status).toBe(200);
+    expect(res.body).toMatchObject({ mode: "git", needsHuman: true });
+    expect(store.createTask as ReturnType<typeof vi.fn>).not.toHaveBeenCalled();
+  });
+});
diff --git a/packages/dashboard/src/routes/register-task-workflow-routes.ts b/packages/dashboard/src/routes/register-task-workflow-routes.ts
index 2e5596762c..feeae9fc52 100644
--- a/packages/dashboard/src/routes/register-task-workflow-routes.ts
+++ b/packages/dashboard/src/routes/register-task-workflow-routes.ts
@@ -49,7 +49,14 @@ import {
 import { GitHubClient } from "../github.js";
 import { createTrackingIssueForTask } from "../github-tracking-hook.js";
 import { parseGitHubBadgeUrl } from "./register-git-github.js";
-import { planTaskWorktreePath, promoteHeldTask, performTaskRevert, TaskRevertError } from "@fusion/engine";
+import {
+  planTaskWorktreePath,
+  promoteHeldTask,
+  performTaskRevert,
+  TaskRevertError,
+  createAiUndoTask,
+  type AiUndoTaskResult,
+} from "@fusion/engine";
 import { buildBoardWorkflowsPayload } from "./board-workflows.js";
 import { isBackwardMoveBlockedByOpenPr, PR_OPEN_BLOCKS_MOVE_BACK_MESSAGE } from "./register-pull-requests-routes.js";
 import type { RunAuditEventInput } from "@fusion/core";
@@ -1663,16 +1670,29 @@ export function registerTaskWorkflowRoutes(ctx: ApiRoutesContext, deps: TaskWork
   });
 
   /*
-  FNXC:TaskRevert 2026-07-04-00:00:
-  POST /tasks/:id/revert — intelligent git-revert for Done/Archived tasks (FN-7523, foundation
-  for FN-7501). Guard rails (enforced here AND in the engine service):
+  FNXC:TaskRevert 2026-07-04-00:00 (FN-7524 mode contract):
+  POST /tasks/:id/revert — intelligent git-revert for Done/Archived tasks (FN-7523), with an
+  AI-undo fallback (FN-7524, foundation for FN-7501). Guard rails (enforced here AND in the
+  engine service):
     - only done/archived tasks are revertable (400/409 otherwise);
-    - autoMerge-off is a needsHuman result, not a forced write;
-    - the source task's column/status is NEVER mutated as a side effect of a revert.
-  Response contract: `{ mode: "git", clean, revertCommitSha?, conflicts?, alreadyReverted?, unsupported?, needsHuman?, reason? }`.
-  On conflict, this route does NOT create the AI-undo follow-up task — that is sibling FN-7524's
-  job; the UI/caller decides what to do with the conflict result. This route also never moves the
-  source task backward through its lifecycle.
+    - autoMerge-off is a needsHuman result, not a forced write, and NEVER triggers the AI fallback
+      (leave that for a human / sibling FN-7525 to decide);
+    - the source task's column/status is NEVER mutated as a side effect of a revert (git OR AI path).
+
+  Optional request body: `{ mode?: "git" | "ai" | "auto" }` (default `"auto"`; unknown values reject
+  with 400). Semantics:
+    - `"git"`  — FN-7523 behavior only; the git result (incl. a conflict/unsupported result) is
+      returned as-is and the AI-undo path is NEVER invoked.
+    - `"ai"`   — skip git entirely; always take the AI-undo fallback.
+    - `"auto"` — attempt git first. A clean/alreadyReverted/needsHuman git result is returned
+      unchanged (NO AI task created). A conflicting or unsupported (e.g. workspace-task) git result
+      falls through to the AI-undo fallback.
+
+  Response contract is ADDITIVE over FN-7523: `{ mode: "git", ... }` (unchanged shape) OR
+  `{ mode: "ai", createdTaskId: "FN-YYYY", alreadyOpen?: true }`. The AI-undo task is created via
+  `createAiUndoTask` (engine) + `TaskStore.findOpenRevertTaskForSource` (core) for the idempotency
+  guard — a second call while an undo task is still open returns the SAME `createdTaskId` with
+  `alreadyOpen: true` rather than creating a duplicate.
   */
   router.post("/tasks/:id/revert", async (req, res) => {
     try {
@@ -1685,6 +1705,24 @@ export function registerTaskWorkflowRoutes(ctx: ApiRoutesContext, deps: TaskWork
         throw conflict(`Task ${task.id} is in column "${task.column}"; only done/archived tasks can be reverted`);
       }
 
+      const requestedMode = (req.body as { mode?: unknown } | undefined)?.mode;
+      if (requestedMode !== undefined && requestedMode !== "git" && requestedMode !== "ai" && requestedMode !== "auto") {
+        throw badRequest(`Invalid revert mode "${String(requestedMode)}"; expected "git", "ai", or "auto"`);
+      }
+      const mode: "git" | "ai" | "auto" = (requestedMode as "git" | "ai" | "auto" | undefined) ?? "auto";
+
+      const createAiUndoResult = async (): Promise<AiUndoTaskResult> =>
+        createAiUndoTask({
+          createTask: (input) => scopedStore.createTask(input),
+          findOpenRevertTaskForSource: (id) => scopedStore.findOpenRevertTaskForSource(id),
+          sourceTask: task,
+        });
+
+      if (mode === "ai") {
+        res.json(await createAiUndoResult());
+        return;
+      }
+
       const rootDir = scopedStore.getRootDir();
       const settings = await scopedStore.getSettingsFast();
       const baseBranch = task.mergeDetails?.mergeTargetBranch || await resolveIntegrationBranch(rootDir, settings);
@@ -1722,6 +1760,23 @@ export function registerTaskWorkflowRoutes(ctx: ApiRoutesContext, deps: TaskWork
         effectiveAutoMerge: settings.autoMerge,
       });
 
+      if (mode === "git") {
+        res.json(result);
+        return;
+      }
+
+      // mode === "auto": fall back to the AI-undo task ONLY on conflict or an
+      // unsupported (e.g. workspace) git result. Clean/alreadyReverted/needsHuman
+      // results are returned as-is — needsHuman (autoMerge-off) NEVER triggers AI.
+      const shouldFallBackToAi =
+        (result.mode === "git" && "clean" in result && result.clean === false) ||
+        (result.mode === "git" && "unsupported" in result && result.unsupported === true);
+
+      if (shouldFallBackToAi) {
+        res.json(await createAiUndoResult());
+        return;
+      }
+
       res.json(result);
     } catch (err: unknown) {
       if (err instanceof ApiError) {
diff --git a/packages/engine/src/__tests__/task-revert-ai-undo.test.ts b/packages/engine/src/__tests__/task-revert-ai-undo.test.ts
new file mode 100644
index 0000000000..d4eadf5048
--- /dev/null
+++ b/packages/engine/src/__tests__/task-revert-ai-undo.test.ts
@@ -0,0 +1,114 @@
+import { describe, expect, it, vi } from "vitest";
+import { createAiUndoTask, buildAiUndoTaskDescription, REVERT_OF_METADATA_KEY } from "../task-revert.js";
+import type { CreateAiUndoTaskDeps } from "../task-revert.js";
+import type { Task, TaskCreateInput } from "@fusion/core";
+
+function makeSourceTask(overrides: Partial<Task> = {}): CreateAiUndoTaskDeps["sourceTask"] {
+  return {
+    id: "FN-901",
+    title: "Add feature a",
+    description: "Add feature a to the widget renderer.",
+    prompt: undefined,
+    mergeDetails: { commitSha: "abc123", landedFiles: ["foo.ts", "bar.ts"] },
+    priority: "normal",
+    ...overrides,
+  } as CreateAiUndoTaskDeps["sourceTask"];
+}
+
+function makeExistingTask(overrides: Partial<Task> = {}): Task {
+  return {
+    id: "FN-950",
+    lineageId: "FN-950",
+    description: "existing undo task",
+    column: "triage",
+    dependencies: [],
+    steps: [],
+    currentStep: 0,
+    ...overrides,
+  } as Task;
+}
+
+describe("buildAiUndoTaskDescription (FN-7524)", () => {
+  it("references the source id, its mission, landed files, the diff pointer, preserve-unrelated instruction, and the revert() commit convention", () => {
+    const description = buildAiUndoTaskDescription({
+      task: {
+        id: "FN-901",
+        title: "Add feature a",
+        description: "Add feature a to the widget renderer.",
+        prompt: undefined,
+        mergeDetails: { commitSha: "abc", landedFiles: ["foo.ts", "bar.ts"] },
+      },
+    });
+
+    expect(description).toContain("FN-901");
+    expect(description).toContain("Add feature a to the widget renderer.");
+    expect(description).toContain("foo.ts");
+    expect(description).toContain("bar.ts");
+    expect(description).toContain("/api/tasks/FN-901/diff");
+    expect(description).toMatch(/preserv/i);
+    expect(description).toContain("revert(FN-901):");
+    expect(description).toContain("Fusion-Task-Id: FN-901");
+  });
+
+  it("prefers task.prompt over task.description for the mission text when present", () => {
+    const description = buildAiUndoTaskDescription({
+      task: {
+        id: "FN-902",
+        title: "t",
+        description: "short description",
+        prompt: "## Full generated mission\nDetailed spec content.",
+        mergeDetails: undefined,
+      },
+    });
+    expect(description).toContain("Detailed spec content.");
+    expect(description).not.toContain("short description");
+  });
+
+  it("handles a task with no recorded landed files", () => {
+    const description = buildAiUndoTaskDescription({
+      task: { id: "FN-903", title: "t", description: "d", prompt: undefined, mergeDetails: undefined },
+    });
+    expect(description).toMatch(/no landed-files list recorded/i);
+  });
+});
+
+describe("createAiUndoTask (FN-7524)", () => {
+  it("creates a dependency-free board task with the revertOf marker and returns { mode: 'ai', createdTaskId }", async () => {
+    const createTask = vi.fn(async (input: TaskCreateInput) => makeExistingTask({
+      id: "FN-960",
+      description: input.description,
+      dependencies: input.dependencies ?? [],
+      sourceParentTaskId: input.source?.sourceParentTaskId,
+      sourceMetadata: input.source?.sourceMetadata,
+    }));
+    const findOpenRevertTaskForSource = vi.fn(async () => null);
+
+    const result = await createAiUndoTask({
+      createTask,
+      findOpenRevertTaskForSource,
+      sourceTask: makeSourceTask(),
+    });
+
+    expect(result).toEqual({ mode: "ai", createdTaskId: "FN-960" });
+    expect(createTask).toHaveBeenCalledTimes(1);
+    const input = createTask.mock.calls[0][0] as TaskCreateInput;
+    expect(input.dependencies).toEqual([]);
+    expect(input.source?.sourceMetadata?.[REVERT_OF_METADATA_KEY]).toBe("FN-901");
+    expect(input.description).toContain("FN-901");
+  });
+
+  it("does not create a duplicate when an open AI-undo task already exists for the source (idempotency)", async () => {
+    const createTask = vi.fn();
+    const existing = makeExistingTask({ id: "FN-955", column: "triage" });
+    const findOpenRevertTaskForSource = vi.fn(async () => existing);
+
+    const result = await createAiUndoTask({
+      createTask,
+      findOpenRevertTaskForSource,
+      sourceTask: makeSourceTask(),
+    });
+
+    expect(result).toEqual({ mode: "ai", createdTaskId: "FN-955", alreadyOpen: true });
+    expect(createTask).not.toHaveBeenCalled();
+  });
+});
diff --git a/packages/engine/src/index.ts b/packages/engine/src/index.ts
index 44eead5ee3..9f95db5771 100644
--- a/packages/engine/src/index.ts
+++ b/packages/engine/src/index.ts
@@ -279,6 +279,11 @@ export {
   type ClassifyTaskRevertResult,
   type TaskRevertResult,
   type TaskCommitAssociationSource,
+  createAiUndoTask,
+  buildAiUndoTaskDescription,
+  REVERT_OF_METADATA_KEY,
+  type AiUndoTaskResult,
+  type CreateAiUndoTaskDeps,
 } from "./task-revert.js";
 export {
   resolveBranchGroupMergeRouting,
diff --git a/packages/engine/src/task-revert.ts b/packages/engine/src/task-revert.ts
index 74edee2bbb..1a36e101ce 100644
--- a/packages/engine/src/task-revert.ts
+++ b/packages/engine/src/task-revert.ts
@@ -22,7 +22,7 @@
  */
 import { exec } from "node:child_process";
 import { promisify } from "node:util";
-import type { Task, TaskCommitAssociation } from "@fusion/core";
+import type { Task, TaskCommitAssociation, TaskCreateInput } from "@fusion/core";
 
 const defaultExecAsync = promisify(exec);
 type ExecAsyncImpl = typeof defaultExecAsync;
@@ -522,3 +522,118 @@ export async function performTaskRevert(opts: PerformTaskRevertOptions): Promise
     throw error instanceof TaskRevertError ? error : new TaskRevertError("failed to apply revert commit", "revert-apply-failed", error);
   }
 }
+
+// ────────────────────────────────────────────────────────────────────────
+// FN-7524: AI-undo fallback
+// ────────────────────────────────────────────────────────────────────────
+
+/**
+ * FNXC:TaskRevert 2026-07-04-00:00 (AI-undo marker contract):
+ * `REVERT_OF_METADATA_KEY` is the idempotency key stamped onto an AI-undo
+ * board task's `source.sourceMetadata`. The route's dedup guard
+ * (`TaskStore.findOpenRevertTaskForSource`, core) scans OPEN (non
+ * done/archived) tasks for `sourceMetadata.revertOf === sourceTaskId` before
+ * creating a new one — a second `mode:"ai"`/conflict-fallback call for the
+ * same source task while an undo task is still open MUST return the existing
+ * task's id (`alreadyOpen: true`) instead of creating a duplicate. A prior
+ * undo task that has itself reached `done`/`archived` does NOT suppress a
+ * fresh one — the work may need undoing again (e.g. redone, then relanded).
+ * NEVER repurpose this key for another meaning.
+ */
+export const REVERT_OF_METADATA_KEY = "revertOf" as const;
+
+export type AiUndoTaskResult = { mode: "ai"; createdTaskId: string; alreadyOpen?: boolean };
+
+function formatLandedFiles(landedFiles: string[] | undefined): string {
+  if (!landedFiles || landedFiles.length === 0) {
+    return "(no landed-files list recorded on this task; inspect its merge commit(s) directly)";
+  }
+  return landedFiles.map((file) => `- ${file}`).join("\n");
+}
+
+/**
+ * FNXC:TaskRevert 2026-07-04-00:00 (AI-undo mission contract):
+ * Builds the triage-ready description for the AI-undo board task. References
+ * the source task's id, its mission (`task.prompt` when present, else
+ * `task.description` — `prompt` carries the fuller generated spec when
+ * available), its landed files (`mergeDetails.landedFiles`) plus a pointer to
+ * `GET /api/tasks/<id>/diff` for the full landed diff (reused, not
+ * recomputed), an explicit instruction to undo the BEHAVIOR/FILES the source
+ * task introduced while PRESERVING unrelated changes later tasks made to the
+ * same files, and the `revert(FN-xxxx): …` commit convention with a
+ * `Fusion-Task-Id: FN-xxxx` trailer referencing the ORIGINAL task (consistent
+ * with the git-path commit convention above `performTaskRevert`).
+ */
+export function buildAiUndoTaskDescription(params: {
+  task: Pick<Task, "id" | "title" | "description" | "prompt" | "mergeDetails">;
+}): string {
+  const { task } = params;
+  const mission = task.prompt?.trim() ? task.prompt : task.description;
+  const landedFiles = task.mergeDetails?.landedFiles;
+
+  return [
+    `Undo the work landed by task ${task.id}${task.title ? ` — "${task.title}"` : ""}.`,
+    "",
+    "## Why this task exists",
+    `A direct \`git revert\` of ${task.id} could not be applied automatically (later commits conflict with it, the task's revert is unsupported, or AI-undo mode was explicitly requested). This task undoes the BEHAVIOR/FILES ${task.id} introduced WHILE PRESERVING unrelated changes made by later tasks that also touched the same files — do not blindly restore the pre-${task.id} version of any shared file.`,
+    "",
+    `## Original mission (${task.id})`,
+    mission,
+    "",
+    `## Files landed by ${task.id}`,
+    formatLandedFiles(landedFiles),
+    `See \`GET /api/tasks/${task.id}/diff\` for the full landed diff.`,
+    "",
+    "## What to do",
+    `1. Read ${task.id}'s original mission above and its landed diff.`,
+    `2. For each file ${task.id} touched, remove or reverse ONLY the behavior/changes it introduced. If a later task also modified the same file, preserve that later task's unrelated changes.`,
+    `3. Commit the undo work using the \`revert(${task.id}): <short summary>\` commit-message convention with a \`Fusion-Task-Id: ${task.id}\` trailer, so the commit stays attributable back to ${task.id} (mirrors the direct git-revert commit convention).`,
+    "4. Verify the original behavior is gone (tests/build) and that later, unrelated changes to the same files still work as intended.",
+  ].join("\n");
+}
+
+/**
+ * FNXC:TaskRevert 2026-07-04-00:00 (dependency-free creation rule):
+ * The AI-undo task is created via the store's normal `createTask` path
+ * (lands in `triage`, gets its own generated PROMPT.md) with `dependencies: []`
+ * — it must NEVER depend on the source task. The source task is already
+ * done/archived; a dependency on it would be a permanently-satisfied no-op
+ * that misrepresents the relationship in dependency UIs.
+ */
+export interface CreateAiUndoTaskDeps {
+  createTask(input: TaskCreateInput): Promise<Task>;
+  /** Idempotency lookup — see `REVERT_OF_METADATA_KEY`. Implemented by `TaskStore.findOpenRevertTaskForSource` (core). */
+  findOpenRevertTaskForSource(sourceTaskId: string): Promise<Task | null>;
+  sourceTask: Pick<Task, "id" | "title" | "description" | "prompt" | "mergeDetails" | "priority">;
+}
+
+/**
+ * FNXC:TaskRevert 2026-07-04-00:00 (Step 1 entry point):
+ * Creates (or, if an open one already exists for this source task, returns
+ * the existing) AI-undo board task. This is the fallback the route uses when
+ * the git-revert path cannot apply cleanly / is unsupported, or when the
+ * caller explicitly requests `mode:"ai"`.
+ */
+export async function createAiUndoTask(deps: CreateAiUndoTaskDeps): Promise<AiUndoTaskResult> {
+  const { sourceTask } = deps;
+
+  // Idempotency FIRST — never create a duplicate while one is still open.
+  const existing = await deps.findOpenRevertTaskForSource(sourceTask.id);
+  if (existing) {
+    return { mode: "ai", createdTaskId: existing.id, alreadyOpen: true };
+  }
+
+  const description = buildAiUndoTaskDescription({ task: sourceTask });
+  const created = await deps.createTask({
+    title: `Undo ${sourceTask.id}: ${sourceTask.title ?? sourceTask.description.slice(0, 80)}`,
+    description,
+    dependencies: [],
+    priority: sourceTask.priority,
+    source: {
+      sourceType: "recovery",
+      sourceMetadata: { [REVERT_OF_METADATA_KEY]: sourceTask.id },
+    },
+  });
+
+  return { mode: "ai", createdTaskId: created.id };
+}

From 8c6f76c37e685985c04ee9035e4d27777a820e90 Mon Sep 17 00:00:00 2001
From: gsxdsm <gsxdsm@users.noreply.github.com>
Date: Sat, 4 Jul 2026 21:54:20 -0700
Subject: [PATCH 02/65] FN-7548: add per-sha revert commit granularity to the
 git-revert service/route

Adds an opt-in per-sha commit granularity mode to the task-revert git path, alongside its default squash behavior, and merges it cleanly with the existing FN-7524 AI-undo mode support.

- Add `TaskRevertGranularity` ("squash" | "per-sha") and thread an optional `granularity` option through `performTaskRevert`/`PerformTaskRevertOptions`.
- Factor a shared `applyRevertNoCommit` primitive (stage + no-op/conflict detection) used by both the squash and new per-sha apply paths.
- `"per-sha"` creates one attributed `revert(FN-xxxx): ...` commit per original sha (each with its own `Fusion-Task-Id` trailer and audit line), skipping no-op shas without empty commits; a mid-batch conflict rolls the whole batch back to the pre-call HEAD.
- Extend `TaskRevertResult`'s clean shape with `revertCommitShas: string[]` (all created commits) alongside the existing `revertCommitSha`.
- `POST /api/tasks/:id/revert` accepts an optional `granularity` request-body field (default `"squash"`, validated, 400 on unknown values) and forwards it to the engine service; documented alongside the existing `mode` (git/ai/auto) contract.
- Add real-git and route-level test coverage for per-sha creation, no-op skipping, default-squash behavior, and mid-batch conflict rollback.
- Update docs/task-management.md's revert section and add a changeset.

Files changed:
 .changeset/fn-7548-per-sha-revert-granularity.md   |   7 +
 docs/task-management.md                            |   3 +-
 packages/dashboard/src/__tests__/task-revert-route.test.ts        |  46 +++++-
 packages/dashboard/src/routes/register-task-workflow-routes.ts    |  51 ++++--
 packages/engine/src/__tests__/task-revert.real-git.test.ts     | 124 +++++++++++++++
 packages/engine/src/index.ts                       |   2 +
 packages/engine/src/task-revert.ts                 | 176 +++++++++++++++++----
 7 files changed, 359 insertions(+), 50 deletions(-)

Fusion-Task-Id: FN-7548

Fusion-Task-Lineage: b9548f5e-fcc2-45d4-98e0-dd7340928208

Co-authored-by: Fusion (runfusion.ai) <noreply@runfusion.ai>
---
 .../fn-7548-per-sha-revert-granularity.md     |   7 +
 docs/task-management.md                       |   3 +-
 .../src/__tests__/task-revert-route.test.ts   |  46 ++++-
 .../routes/register-task-workflow-routes.ts   |  49 +++--
 .../__tests__/task-revert.real-git.test.ts    | 124 ++++++++++++
 packages/engine/src/index.ts                  |   2 +
 packages/engine/src/task-revert.ts            | 176 ++++++++++++++----
 7 files changed, 358 insertions(+), 49 deletions(-)
 create mode 100644 .changeset/fn-7548-per-sha-revert-granularity.md

diff --git a/.changeset/fn-7548-per-sha-revert-granularity.md b/.changeset/fn-7548-per-sha-revert-granularity.md
new file mode 100644
index 0000000000..657bd6db0f
--- /dev/null
+++ b/.changeset/fn-7548-per-sha-revert-granularity.md
@@ -0,0 +1,7 @@
+---
+"@runfusion/fusion": minor
+---
+
+summary: Add per-sha revert commit granularity to the task revert API and service.
+category: feature
+dev: `performTaskRevert` and `POST /api/tasks/:id/revert` accept an optional `granularity: "squash" | "per-sha"` (default `"squash"`, unchanged FN-7523 behavior). `"per-sha"` creates one attributed `revert(FN-xxxx)` commit per original sha (each with its own `Fusion-Task-Id` trailer and audit line), skipping no-op shas without empty commits. A mid-batch conflict in either mode rolls back the whole batch to the pre-call HEAD — no partially-landed per-sha commits. The clean result now reports `revertCommitShas: string[]` (all created commits) alongside the existing `revertCommitSha` (kept for backward compatibility).
diff --git a/docs/task-management.md b/docs/task-management.md
index fbe810479a..075b23c936 100644
--- a/docs/task-management.md
+++ b/docs/task-management.md
@@ -681,7 +681,8 @@ Recovery/backfill guidance:
   - `"git"` — the FN-7523 git-only behavior. The result (including a conflicting/unsupported result) is returned as-is and never creates a follow-up task.
   - `"ai"` — skip git entirely and always create the AI-undo fallback task (FN-7524).
   - `"auto"` — try git first. A clean/alreadyReverted/needsHuman result is returned unchanged. A conflicting or unsupported (e.g. workspace-task) result falls back to creating the AI-undo task.
-- Git-path response contract (unchanged, additive only): `{ mode: "git", clean, revertCommitSha?, conflicts?, alreadyReverted?, unsupported?, needsHuman?, reason? }`. A clean revert lands a `revert(FN-xxxx): ...` commit carrying a `Fusion-Task-Id` trailer on the resolved base branch.
+- Also accepts an optional `{ granularity?: "squash" | "per-sha" }` field (FN-7548) that selects the git-path commit granularity: `"squash"` (default, unchanged) accumulates all attributable commits into one revert commit; `"per-sha"` creates one attributed revert commit per original sha (each with its own `Fusion-Task-Id` trailer and audit line), skipping no-op shas without empty commits. A mid-batch conflict in either mode rolls back the whole batch — no partially-landed per-sha commits. This field only affects the git path and is ignored when `mode` resolves to `"ai"`.
+- Git-path response contract (additive only): `{ mode: "git", clean, revertCommitSha?, revertCommitShas?, conflicts?, alreadyReverted?, unsupported?, needsHuman?, reason? }`. A clean revert lands a `revert(FN-xxxx): ...` commit carrying a `Fusion-Task-Id` trailer on the resolved base branch; `revertCommitShas` reports every commit created (all of them for `per-sha`, the single one for `squash`) alongside the existing `revertCommitSha`.
 - AI-undo response contract: `{ mode: "ai", createdTaskId: "FN-YYYY", alreadyOpen?: true }`. The created task is an ordinary `triage`-column board task (via the normal `store.createTask` path) that references the source task's id, mission, and landed files, and instructs undoing the source task's behavior while preserving unrelated later changes to the same files, using a `revert(FN-xxxx): ...` commit convention. It carries NO dependency on the (already done/archived) source task. A `sourceMetadata.revertOf` marker makes repeated fallback calls idempotent — while an AI-undo task for that source is still open, a further call returns the same `createdTaskId` with `alreadyOpen: true` instead of creating a duplicate; a prior undo task that itself reached `done`/`archived` does not suppress a fresh one.
 - Workspace (multi-repo) tasks return `unsupported` from the git path (routing `auto` to the AI-undo fallback); `autoMerge:false` projects return `needsHuman` and never trigger the AI-undo fallback (a human/future UI decides).
 - No dashboard UI affordance ships with this yet (see the Done/Archived card action follow-up task).
diff --git a/packages/dashboard/src/__tests__/task-revert-route.test.ts b/packages/dashboard/src/__tests__/task-revert-route.test.ts
index 7c90e1a470..134e87f239 100644
--- a/packages/dashboard/src/__tests__/task-revert-route.test.ts
+++ b/packages/dashboard/src/__tests__/task-revert-route.test.ts
@@ -104,8 +104,11 @@ function createApp(store: TaskStore) {
   return app;
 }
 
-async function REQUEST(app: express.Express, method: string, path: string) {
-  return performRequest(app, method, path);
+async function REQUEST(app: express.Express, method: string, path: string, body?: unknown) {
+  if (body === undefined) {
+    return performRequest(app, method, path);
+  }
+  return performRequest(app, method, path, JSON.stringify(body), { "content-type": "application/json" });
 }
 
 async function POST_JSON(app: express.Express, path: string, body: Record<string, unknown>) {
@@ -314,4 +317,43 @@ describe("POST /tasks/:id/revert — FN-7524 mode + AI-undo fallback", () => {
     expect(res.body).toMatchObject({ mode: "git", needsHuman: true });
     expect(store.createTask as ReturnType<typeof vi.fn>).not.toHaveBeenCalled();
   });
+
+  // FN-7548: the optional `granularity` request-body field ("squash" | "per-sha")
+  // is validated at the route and forwarded verbatim to `performTaskRevert`.
+  it("forwards granularity: \"per-sha\" to the engine service and returns the revertCommitShas result shape", async () => {
+    const task = makeTask({ column: "done" });
+    const store = createMockStore(task);
+    performTaskRevertMock.mockResolvedValue({
+      mode: "git",
+      clean: true,
+      revertCommitSha: "def456",
+      revertCommitShas: ["def456", "abc123"],
+    });
+
+    const res = await REQUEST(createApp(store), "POST", `/api/tasks/${task.id}/revert`, { granularity: "per-sha" });
+    expect(res.status).toBe(200);
+    expect(res.body).toMatchObject({ mode: "git", clean: true, revertCommitShas: ["def456", "abc123"] });
+    expect(performTaskRevertMock).toHaveBeenCalledTimes(1);
+    expect(performTaskRevertMock.mock.calls[0]?.[0]).toMatchObject({ granularity: "per-sha" });
+  });
+
+  it("rejects an unknown granularity value with a 400, before invoking the engine service", async () => {
+    const task = makeTask({ column: "done" });
+    const store = createMockStore(task);
+
+    const res = await REQUEST(createApp(store), "POST", `/api/tasks/${task.id}/revert`, { granularity: "bogus" });
+    expect(res.status).toBe(400);
+    expect(String((res.body as { error?: string }).error ?? "")).toMatch(/granularity/i);
+    expect(performTaskRevertMock).not.toHaveBeenCalled();
+  });
+
+  it("defaults to squash granularity when the body omits the field, preserving existing behavior", async () => {
+    const task = makeTask({ column: "done" });
+    const store = createMockStore(task);
+    performTaskRevertMock.mockResolvedValue({ mode: "git", clean: true, revertCommitSha: "abc123", revertCommitShas: ["abc123"] });
+
+    const res = await REQUEST(createApp(store), "POST", `/api/tasks/${task.id}/revert`);
+    expect(res.status).toBe(200);
+    expect(performTaskRevertMock.mock.calls[0]?.[0]).toMatchObject({ granularity: "squash" });
+  });
 });
diff --git a/packages/dashboard/src/routes/register-task-workflow-routes.ts b/packages/dashboard/src/routes/register-task-workflow-routes.ts
index feeae9fc52..339ba40530 100644
--- a/packages/dashboard/src/routes/register-task-workflow-routes.ts
+++ b/packages/dashboard/src/routes/register-task-workflow-routes.ts
@@ -1670,25 +1670,30 @@ export function registerTaskWorkflowRoutes(ctx: ApiRoutesContext, deps: TaskWork
   });
 
   /*
-  FNXC:TaskRevert 2026-07-04-00:00 (FN-7524 mode contract):
+  FNXC:TaskRevert 2026-07-04-00:00 (FN-7524 mode contract; FN-7548 granularity contract):
   POST /tasks/:id/revert — intelligent git-revert for Done/Archived tasks (FN-7523), with an
-  AI-undo fallback (FN-7524, foundation for FN-7501). Guard rails (enforced here AND in the
-  engine service):
+  AI-undo fallback (FN-7524, foundation for FN-7501) and per-sha revert-commit granularity
+  (FN-7548). Guard rails (enforced here AND in the engine service):
     - only done/archived tasks are revertable (400/409 otherwise);
     - autoMerge-off is a needsHuman result, not a forced write, and NEVER triggers the AI fallback
       (leave that for a human / sibling FN-7525 to decide);
     - the source task's column/status is NEVER mutated as a side effect of a revert (git OR AI path).
 
-  Optional request body: `{ mode?: "git" | "ai" | "auto" }` (default `"auto"`; unknown values reject
-  with 400). Semantics:
-    - `"git"`  — FN-7523 behavior only; the git result (incl. a conflict/unsupported result) is
-      returned as-is and the AI-undo path is NEVER invoked.
-    - `"ai"`   — skip git entirely; always take the AI-undo fallback.
-    - `"auto"` — attempt git first. A clean/alreadyReverted/needsHuman git result is returned
-      unchanged (NO AI task created). A conflicting or unsupported (e.g. workspace-task) git result
-      falls through to the AI-undo fallback.
+  Optional request body:
+    - `mode?: "git" | "ai" | "auto"` (default `"auto"`; unknown values reject with 400). Semantics:
+      - `"git"`  — FN-7523 behavior only; the git result (incl. a conflict/unsupported result) is
+        returned as-is and the AI-undo path is NEVER invoked.
+      - `"ai"`   — skip git entirely; always take the AI-undo fallback.
+      - `"auto"` — attempt git first. A clean/alreadyReverted/needsHuman git result is returned
+        unchanged (NO AI task created). A conflicting or unsupported (e.g. workspace-task) git result
+        falls through to the AI-undo fallback.
+    - `granularity?: "squash" | "per-sha"` (FN-7548, default `"squash"`) — commit granularity for the
+      git-path revert only; forwarded verbatim to `performTaskRevert`. `"squash"` preserves the
+      unchanged FN-7523 single-commit behavior; `"per-sha"` creates one attributed revert commit per
+      original sha (see `performTaskRevert`'s per-sha apply path). Ignored when `mode` resolves to `"ai"`.
 
-  Response contract is ADDITIVE over FN-7523: `{ mode: "git", ... }` (unchanged shape) OR
+  Response contract is ADDITIVE over FN-7523: `{ mode: "git", clean, revertCommitSha?, revertCommitShas?,
+  conflicts?, alreadyReverted?, unsupported?, needsHuman?, reason? }` OR
   `{ mode: "ai", createdTaskId: "FN-YYYY", alreadyOpen?: true }`. The AI-undo task is created via
   `createAiUndoTask` (engine) + `TaskStore.findOpenRevertTaskForSource` (core) for the idempotency
   guard — a second call while an undo task is still open returns the SAME `createdTaskId` with
@@ -1711,6 +1716,25 @@ export function registerTaskWorkflowRoutes(ctx: ApiRoutesContext, deps: TaskWork
       }
       const mode: "git" | "ai" | "auto" = (requestedMode as "git" | "ai" | "auto" | undefined) ?? "auto";
 
+      /*
+      FNXC:TaskRevert 2026-07-04-12:00 (FN-7548):
+      Optional `granularity` request-body field selects the commit granularity
+      of the revert: `"squash"` (default, unchanged FN-7523 behavior — one
+      combined revert commit) or `"per-sha"` (one attributed revert commit per
+      original sha, see `performTaskRevert`'s per-sha apply path). An absent/
+      empty value defaults to `"squash"`; any other value is a 400 naming the
+      allowed values. Only relevant to the git path — ignored when `mode`
+      resolves to `"ai"`.
+      */
+      const requestedGranularity = (req.body as { granularity?: unknown } | undefined)?.granularity;
+      let granularity: "squash" | "per-sha" = "squash";
+      if (requestedGranularity !== undefined && requestedGranularity !== null && requestedGranularity !== "") {
+        if (requestedGranularity !== "squash" && requestedGranularity !== "per-sha") {
+          throw badRequest(`granularity must be one of: "squash", "per-sha"`);
+        }
+        granularity = requestedGranularity;
+      }
+
       const createAiUndoResult = async (): Promise<AiUndoTaskResult> =>
         createAiUndoTask({
           createTask: (input) => scopedStore.createTask(input),
@@ -1758,6 +1782,7 @@ export function registerTaskWorkflowRoutes(ctx: ApiRoutesContext, deps: TaskWork
             scopedStore.getTaskCommitAssociationsByLineageId(lineageId),
         },
         effectiveAutoMerge: settings.autoMerge,
+        granularity,
       });
 
       if (mode === "git") {
diff --git a/packages/engine/src/__tests__/task-revert.real-git.test.ts b/packages/engine/src/__tests__/task-revert.real-git.test.ts
index 99c96b9fb2..b1f563b5a9 100644
--- a/packages/engine/src/__tests__/task-revert.real-git.test.ts
+++ b/packages/engine/src/__tests__/task-revert.real-git.test.ts
@@ -245,4 +245,128 @@ describeIfGit("task-revert real-git scenarios", { timeout: 30_000 }, () => {
     expect(result).toMatchObject({ mode: "git", needsHuman: true });
     expect(git(repo, "git rev-parse HEAD")).toBe(preHead);
   });
+
+  // FN-7548: per-sha revert commit granularity — one attributed revert commit
+  // per original sha instead of a single squashed commit, with the default
+  // ("squash") staying byte-for-byte unchanged.
+  function twoCommitRebaseFixture() {
+    const repo = repoFixture();
+    const rebaseBase = git(repo, "git rev-parse HEAD");
+    writeFileSync(join(repo, "foo.ts"), "line1\nfeature-a\n");
+    git(repo, "git commit -am 'feat(FN-901): part 1' -m 'Fusion-Task-Id: FN-901'");
+    const shaA = git(repo, "git rev-parse HEAD");
+    writeFileSync(join(repo, "bar.ts"), "bar-feature\n");
+    git(repo, "git add bar.ts && git commit -m 'feat(FN-901): part 2' -m 'Fusion-Task-Id: FN-901'");
+    const shaB = git(repo, "git rev-parse HEAD");
+    return { repo, rebaseBase, shaA, shaB };
+  }
+
+  it("per-sha granularity: creates one attributed revert commit per original sha", async () => {
+    const { repo, rebaseBase, shaA, shaB } = twoCommitRebaseFixture();
+
+    const task = makeTask({
+      column: "done",
+      mergeDetails: { commitSha: shaB, rebaseBaseSha: rebaseBase, mergeTargetBranch: "main" },
+    });
+    const result = await performTaskRevert({ task, worktreePath: repo, baseBranch: "main", granularity: "per-sha" });
+
+    expect(result).toMatchObject({ mode: "git", clean: true });
+    if (result.mode === "git" && result.clean && "revertCommitShas" in result) {
+      expect(result.revertCommitShas.length).toBe(2);
+      expect(result.revertCommitSha).toBe(result.revertCommitShas[0]);
+    }
+
+    const subjects = git(repo, "git log --format=%s -n 5").split("\n");
+    const revertSubjects = subjects.filter((s) => s.startsWith("revert(FN-901):"));
+    expect(revertSubjects.length).toBe(2);
+
+    // Two distinct new commits, both carrying the Fusion-Task-Id trailer and
+    // each referencing a DIFFERENT original sha in its audit line.
+    const bodyHead = git(repo, "git log -1 --format=%B HEAD");
+    const bodyHeadMinus1 = git(repo, "git log -1 --format=%B HEAD~1");
+    expect(bodyHead).toContain("Fusion-Task-Id: FN-901");
+    expect(bodyHeadMinus1).toContain("Fusion-Task-Id: FN-901");
+    expect(bodyHead).toContain(shaA.slice(0, 8));
+    expect(bodyHeadMinus1).toContain(shaB.slice(0, 8));
+
+    expect(git(repo, "git show HEAD:foo.ts")).toBe("line1");
+    expect(() => git(repo, "git show HEAD:bar.ts")).toThrow();
+    expect(git(repo, "git status --porcelain")).toBe("");
+  });
+
+  it("default stays squashed: the same two-commit task without granularity produces exactly one revert commit", async () => {
+    const { repo, rebaseBase, shaB } = twoCommitRebaseFixture();
+
+    const task = makeTask({
+      column: "done",
+      mergeDetails: { commitSha: shaB, rebaseBaseSha: rebaseBase, mergeTargetBranch: "main" },
+    });
+    const result = await performTaskRevert({ task, worktreePath: repo, baseBranch: "main" });
+
+    expect(result).toMatchObject({ mode: "git", clean: true });
+    if (result.mode === "git" && result.clean && "revertCommitShas" in result) {
+      expect(result.revertCommitShas.length).toBe(1);
+      expect(result.revertCommitSha).toBe(result.revertCommitShas[0]);
+    }
+
+    const subjects = git(repo, "git log --format=%s -n 5").split("\n");
+    const revertSubjects = subjects.filter((s) => s.startsWith("revert(FN-901):"));
+    expect(revertSubjects.length).toBe(1);
+
+    expect(git(repo, "git show HEAD:foo.ts")).toBe("line1");
+    expect(() => git(repo, "git show HEAD:bar.ts")).toThrow();
+  });
+
+  it("per-sha granularity: no-op shas are skipped without creating empty commits", async () => {
+    const { repo, rebaseBase, shaB } = twoCommitRebaseFixture();
+
+    // Pre-revert shaB manually so it is already reverted at HEAD before the real call.
+    git(repo, `git revert --no-edit ${shaB}`);
+
+    const task = makeTask({
+      column: "done",
+      mergeDetails: { commitSha: shaB, rebaseBaseSha: rebaseBase, mergeTargetBranch: "main" },
+    });
+    const result = await performTaskRevert({ task, worktreePath: repo, baseBranch: "main", granularity: "per-sha" });
+
+    expect(result).toMatchObject({ mode: "git", clean: true });
+    if (result.mode === "git" && result.clean && "revertCommitShas" in result) {
+      expect(result.revertCommitShas.length).toBe(1);
+    }
+
+    // foo.ts (shaA's change) should now be reverted; bar.ts was already gone from the manual revert.
+    expect(git(repo, "git show HEAD:foo.ts")).toBe("line1");
+    expect(() => git(repo, "git show HEAD:bar.ts")).toThrow();
+    expect(git(repo, "git status --porcelain")).toBe("");
+  });
+
+  it("per-sha granularity: a conflicting batch rolls back entirely — no partially-landed per-sha commits", async () => {
+    const { repo, rebaseBase, shaB } = twoCommitRebaseFixture();
+
+    // Task C later modifies the same region touched by shaA (foo.ts), so reverting shaA conflicts.
+    writeFileSync(join(repo, "foo.ts"), "line1\nfeature-a-modified-by-c\n");
+    git(repo, "git commit -am 'feat(FN-903): modify same region as part 1'");
+
+    const preCallHead = git(repo, "git rev-parse HEAD");
+    const preCallStatus = git(repo, "git status --porcelain");
+
+    const task = makeTask({
+      column: "done",
+      mergeDetails: { commitSha: shaB, rebaseBaseSha: rebaseBase, mergeTargetBranch: "main" },
+    });
+    const result = await performTaskRevert({ task, worktreePath: repo, baseBranch: "main", granularity: "per-sha" });
+
+    expect(result).toMatchObject({ mode: "git", clean: false });
+    if (result.mode === "git" && !result.clean && "conflicts" in result) {
+      expect(result.conflicts.length).toBeGreaterThan(0);
+    }
+
+    // No partial per-sha commits landed — tree/HEAD byte-identical to the pre-call state,
+    // proving the whole batch (including any earlier per-sha commit) is rolled back.
+    const postCallHead = git(repo, "git rev-parse HEAD");
+    const postCallStatus = git(repo, "git status --porcelain");
+    expect(postCallHead).toBe(preCallHead);
+    expect(postCallStatus).toBe(preCallStatus);
+    expect(postCallStatus).toBe("");
+  });
 });
diff --git a/packages/engine/src/index.ts b/packages/engine/src/index.ts
index 9f95db5771..520c17d92c 100644
--- a/packages/engine/src/index.ts
+++ b/packages/engine/src/index.ts
@@ -284,6 +284,8 @@ export {
   REVERT_OF_METADATA_KEY,
   type AiUndoTaskResult,
   type CreateAiUndoTaskDeps,
+  type TaskRevertGranularity,
+  type PerformTaskRevertOptions,
 } from "./task-revert.js";
 export {
   resolveBranchGroupMergeRouting,
diff --git a/packages/engine/src/task-revert.ts b/packages/engine/src/task-revert.ts
index 1a36e101ce..8481794217 100644
--- a/packages/engine/src/task-revert.ts
+++ b/packages/engine/src/task-revert.ts
@@ -352,13 +352,86 @@ export async function classifyTaskRevert(opts: ClassifyTaskRevertOptions): Promi
   return { classification: "clean" };
 }
 
+// FNXC:TaskRevert 2026-07-04-12:00 (shared per-sha apply primitive, FN-7548):
+// factors the `git revert --no-commit` + status-diff no-op detection +
+// unmerged-file conflict detection used by BOTH performTaskRevert apply paths
+// (squash and per-sha) into one place. Returns a discriminated outcome
+// instead of committing or rolling back itself — callers own the
+// commit/rollback decision (squash accumulates across shas before
+// committing once; per-sha commits after each staged sha).
+type RevertShaApplyOutcome =
+  | { kind: "staged" }
+  | { kind: "noop" }
+  | { kind: "conflict"; conflicts: TaskRevertConflict[] };
+
+async function applyRevertNoCommit(
+  execImpl: ExecAsyncImpl,
+  worktreePath: string,
+  sha: string,
+): Promise<RevertShaApplyOutcome> {
+  const statusBefore = (await runGit(execImpl, "git status --porcelain", worktreePath)).stdout;
+  try {
+    await runGit(execImpl, `git revert --no-commit --no-edit ${quoteShellArg(sha)}`, worktreePath);
+    // FNXC:TaskRevert 2026-07-04-00:00: `git revert --no-commit` on an
+    // already-reverted commit exits 0 with no staged/working-tree diff (no
+    // thrown error, no "nothing to commit" text on this call). Detect this by
+    // diffing `git status --porcelain` before/after: if unchanged, this sha is
+    // a no-op; `--quit` clears the sequencer's in-progress marker WITHOUT
+    // touching any diff staged by earlier shas in this same batch.
+    const statusAfter = (await runGit(execImpl, "git status --porcelain", worktreePath)).stdout;
+    if (statusAfter === statusBefore) {
+      await runGit(execImpl, "git revert --quit", worktreePath).catch(() => undefined);
+      return { kind: "noop" };
+    }
+    return { kind: "staged" };
+  } catch (error) {
+    const stderr =
+      typeof error === "object" && error && "stderr" in error && typeof (error as { stderr?: unknown }).stderr === "string"
+        ? (error as { stderr: string }).stderr
+        : "";
+    const stdout =
+      typeof error === "object" && error && "stdout" in error && typeof (error as { stdout?: unknown }).stdout === "string"
+        ? (error as { stdout: string }).stdout
+        : "";
+    if (/nothing to commit|no changes|empty commit/i.test(`${stdout}\n${stderr}`)) {
+      await runGit(execImpl, "git revert --quit", worktreePath).catch(() => undefined);
+      return { kind: "noop" };
+    }
+    const unmergedFiles = await getUnmergedFiles(execImpl, worktreePath);
+    return { kind: "conflict", conflicts: unmergedFiles };
+  }
+}
+
+function deriveShortSummary(originalSubject: string): string {
+  return (
+    originalSubject
+      .replace(/^(?:feat|fix|test|chore|docs|refactor|perf|build|ci|style)\([^)]*\):\s*/i, "")
+      .slice(0, 72) || "revert landed changes"
+  );
+}
+
 export type TaskRevertResult =
-  | { mode: "git"; clean: true; revertCommitSha: string }
+  | { mode: "git"; clean: true; revertCommitSha: string; revertCommitShas: string[] }
   | { mode: "git"; clean: true; alreadyReverted: true }
   | { mode: "git"; clean: false; conflicts: TaskRevertConflict[] }
   | { mode: "git"; unsupported: true; reason: string }
   | { mode: "git"; needsHuman: true; reason: string };
 
+/**
+ * FNXC:TaskRevert 2026-07-04-12:00 (granularity, FN-7548):
+ * `"squash"` (default, unchanged FN-7523 behavior) accumulates every
+ * attributable sha into ONE final revert commit. `"per-sha"` creates one
+ * attributed `revert(FN-xxxx): ...` commit PER non-no-op original sha, each
+ * with its own `Fusion-Task-Id` trailer and an audit line referencing that
+ * specific sha — giving finer-grained audit trail / rollback (an operator
+ * can drop a single per-sha revert without unwinding the whole task). A
+ * mid-batch conflict in EITHER mode rolls the whole batch back to
+ * `preRevertHead` — partially-landed per-commit reverts are never left on
+ * disk (see the shared `mutated`/`preRevertHead` rollback in the outer
+ * catch, and the inline abort+reset on conflict below).
+ */
+export type TaskRevertGranularity = "squash" | "per-sha";
+
 export interface PerformTaskRevertOptions {
   task: Pick<Task, "id" | "lineageId" | "column" | "mergeDetails" | "autoMerge" | "userPaused" | "paused">;
   worktreePath: string;
@@ -367,6 +440,8 @@ export interface PerformTaskRevertOptions {
   commitAssociationSource?: TaskCommitAssociationSource;
   /** Resolved effective project autoMerge setting (task.autoMerge overrides this when set). Defaults to true (autoMerge on) when omitted. */
   effectiveAutoMerge?: boolean;
+  /** Commit granularity for the real (committing) revert. Defaults to `"squash"` — omitting this option preserves FN-7523 behavior exactly. */
+  granularity?: TaskRevertGranularity;
 }
 
 // FNXC:TaskRevert 2026-07-04-00:00 (guard rails, enforced in BOTH the service
@@ -442,46 +517,78 @@ export async function performTaskRevert(opts: PerformTaskRevertOptions): Promise
     throw new TaskRevertError("failed to resolve HEAD before applying revert", "head-resolve-failed", error);
   }
 
+  const granularity: TaskRevertGranularity = opts.granularity ?? "squash";
   let mutated = false;
-  let anyStaged = false;
   try {
+    if (granularity === "per-sha") {
+      // FNXC:TaskRevert 2026-07-04-12:00 (per-commit apply path, FN-7548):
+      // stage-and-commit ONE sha at a time so each attributable original sha
+      // gets its own attributed revert commit. No-op shas (already reverted
+      // at HEAD) are skipped without creating an empty commit. A conflict on
+      // any sha rolls the ENTIRE batch back to preRevertHead — there is no
+      // partially-landed per-commit state.
+      const createdCommitShas: string[] = [];
+      for (const sha of resolved.shas) {
+        mutated = true;
+        const outcome = await applyRevertNoCommit(execImpl, worktreePath, sha);
+        if (outcome.kind === "conflict") {
+          await runGit(execImpl, "git revert --abort", worktreePath).catch(() => undefined);
+          await runGit(execImpl, `git reset --hard ${quoteShellArg(preRevertHead)}`, worktreePath).catch(() => undefined);
+          return { mode: "git", clean: false, conflicts: outcome.conflicts };
+        }
+        if (outcome.kind === "noop") continue;
+
+        let originalSubject = "";
+        try {
+          const { stdout } = await runGit(execImpl, `git log -1 --format=%s ${quoteShellArg(sha)}`, worktreePath);
+          originalSubject = stdout.trim();
+        } catch {
+          originalSubject = "";
+        }
+        const shortSummary = deriveShortSummary(originalSubject);
+        const subject = `revert(${task.id}): ${shortSummary}`;
+        const body1 = `Fusion-Task-Id: ${task.id}`;
+        const body2 = `Reverts ${originalSubject || sha} @ ${sha.slice(0, 8)}.`;
+
+        await runGit(
+          execImpl,
+          `git commit -m ${quoteShellArg(subject)} -m ${quoteShellArg(body1)} -m ${quoteShellArg(body2)}`,
+          worktreePath,
+        );
+        const { stdout: newHead } = await runGit(execImpl, "git rev-parse HEAD", worktreePath);
+        createdCommitShas.push(newHead.trim());
+      }
+
+      if (createdCommitShas.length === 0) {
+        // Defensive: every sha in this batch turned out to be a no-op during the
+        // apply pass even though classify saw at least one real change (branch
+        // moved between classify and apply, or a race). Nothing to commit —
+        // report already-reverted rather than attempting an empty commit.
+        return { mode: "git", clean: true, alreadyReverted: true };
+      }
+      return {
+        mode: "git",
+        clean: true,
+        revertCommitSha: createdCommitShas[0]!,
+        revertCommitShas: createdCommitShas,
+      };
+    }
+
+    // granularity === "squash" (default, byte-for-byte unchanged FN-7523 behavior):
+    // accumulate every attributable sha via `git revert --no-commit`, then create
+    // ONE final commit spanning the whole batch.
+    let anyStaged = false;
     for (const sha of resolved.shas) {
       mutated = true;
-      const statusBefore = (await runGit(execImpl, "git status --porcelain", worktreePath)).stdout;
-      try {
-        await runGit(execImpl, `git revert --no-commit --no-edit ${quoteShellArg(sha)}`, worktreePath);
-        // FNXC:TaskRevert 2026-07-04-00:00: mirror classifyTaskRevert's
-        // status-diff no-op detection here — `git revert --no-commit` on an
-        // already-reverted commit exits 0 with no staged diff (no thrown
-        // error, no "nothing to commit" text on this call). `--quit` clears
-        // the sequencer marker without disturbing diff staged by earlier
-        // shas in this batch.
-        const statusAfter = (await runGit(execImpl, "git status --porcelain", worktreePath)).stdout;
-        if (statusAfter === statusBefore) {
-          await runGit(execImpl, "git revert --quit", worktreePath).catch(() => undefined);
-          continue;
-        }
-        anyStaged = true;
-      } catch (error) {
-        const stderr =
-          typeof error === "object" && error && "stderr" in error && typeof (error as { stderr?: unknown }).stderr === "string"
-            ? (error as { stderr: string }).stderr
-            : "";
-        const stdout =
-          typeof error === "object" && error && "stdout" in error && typeof (error as { stdout?: unknown }).stdout === "string"
-            ? (error as { stdout: string }).stdout
-            : "";
-        if (/nothing to commit|no changes|empty commit/i.test(`${stdout}\n${stderr}`)) {
-          await runGit(execImpl, "git revert --quit", worktreePath).catch(() => undefined);
-          continue;
-        }
+      const outcome = await applyRevertNoCommit(execImpl, worktreePath, sha);
+      if (outcome.kind === "conflict") {
         // The dry-run already proved this is clean; a live conflict here means
         // the branch moved between classify and apply. Roll back and report conflicting.
-        const unmergedFiles = await getUnmergedFiles(execImpl, worktreePath);
         await runGit(execImpl, "git revert --abort", worktreePath).catch(() => undefined);
         await runGit(execImpl, `git reset --hard ${quoteShellArg(preRevertHead)}`, worktreePath).catch(() => undefined);
-        return { mode: "git", clean: false, conflicts: unmergedFiles };
+        return { mode: "git", clean: false, conflicts: outcome.conflicts };
       }
+      if (outcome.kind === "staged") anyStaged = true;
     }
 
     if (!anyStaged) {
@@ -500,7 +607,7 @@ export async function performTaskRevert(opts: PerformTaskRevertOptions): Promise
       originalSubject = "";
     }
 
-    const shortSummary = originalSubject.replace(/^(?:feat|fix|test|chore|docs|refactor|perf|build|ci|style)\([^)]*\):\s*/i, "").slice(0, 72) || "revert landed changes";
+    const shortSummary = deriveShortSummary(originalSubject);
     const subject = `revert(${task.id}): ${shortSummary}`;
     const referencedSha = resolved.shas[0] ?? "unknown";
     const body1 = `Fusion-Task-Id: ${task.id}`;
@@ -513,7 +620,8 @@ export async function performTaskRevert(opts: PerformTaskRevertOptions): Promise
     );
 
     const { stdout: newHead } = await runGit(execImpl, "git rev-parse HEAD", worktreePath);
-    return { mode: "git", clean: true, revertCommitSha: newHead.trim() };
+    const revertCommitSha = newHead.trim();
+    return { mode: "git", clean: true, revertCommitSha, revertCommitShas: [revertCommitSha] };
   } catch (error) {
     if (mutated) {
       await runGit(execImpl, "git revert --abort", worktreePath).catch(() => undefined);

From 6e4c207a7fdbb2d1e25dd683d4eb0166a0885b96 Mon Sep 17 00:00:00 2001
From: gsxdsm <gsxdsm@users.noreply.github.com>
Date: Sat, 4 Jul 2026 21:58:19 -0700
Subject: [PATCH 03/65] FN-7559: disambiguate release-authorization holds from
 manual plan-approval holds

Disambiguate release-authorization approval holds from manual plan-approval holds so auto-approve no longer appears broken.

- Add `Task.awaitingApprovalReason` (`"release-authorization" | null`) to distinguish the release-authorization gate from the independent manual plan-approval gate, both of which set `status: "awaiting-approval"`.
- Stamp `awaitingApprovalReason: "release-authorization"` when the release gate blocks a task, and explicitly clear it (`null`) when the manual plan-approval gate parks the task, so a stale reason never survives a replan.
- Add DB migration/persistence support for the new column in `db.ts`/`store.ts`/`types.ts`.
- TaskCard/TaskDetailModal now render a distinct status for release-authorization holds and suppress the generic manual Approve/Reject affordance for them.
- Add i18n string and docs updates (`settings-reference.md`, `workflow-steps.md`) plus a changeset.
- Extend regression tests in db, triage, TaskCard, and TaskDetailModal to cover the new reason field and disambiguated UI.

Files changed:
$(git diff --cached --stat)

Fusion-Task-Id: FN-7559
Fusion-Task-Lineage: 0b37cbf0-40a4-4165-8088-482ed365ba19
Co-authored-by: Fusion (runfusion.ai) <noreply@runfusion.ai>
---
 .../fn-7559-approval-gate-disambiguation.md   |  7 ++
 docs/settings-reference.md                    |  2 +-
 docs/workflow-steps.md                        |  2 +
 packages/core/src/__tests__/db.test.ts        | 53 ++++++++++++++
 packages/core/src/db.ts                       | 21 +++++-
 packages/core/src/store.ts                    | 21 +++++-
 packages/core/src/types.ts                    | 16 +++++
 .../dashboard/app/components/TaskCard.css     | 11 +++
 .../dashboard/app/components/TaskCard.tsx     | 13 +++-
 .../app/components/TaskDetailModal.css        | 11 +++
 .../app/components/TaskDetailModal.tsx        | 37 ++++++++--
 .../components/__tests__/TaskCard.test.tsx    | 35 +++++++++-
 ...askDetailModal.definition-actions.test.tsx | 32 +++++++++
 packages/engine/src/__tests__/triage.test.ts  | 69 ++++++++++++++++++-
 packages/engine/src/triage.ts                 | 19 ++++-
 packages/i18n/locales/en/app.json             |  2 +
 16 files changed, 336 insertions(+), 15 deletions(-)
 create mode 100644 .changeset/fn-7559-approval-gate-disambiguation.md

diff --git a/.changeset/fn-7559-approval-gate-disambiguation.md b/.changeset/fn-7559-approval-gate-disambiguation.md
new file mode 100644
index 0000000000..7ac656be79
--- /dev/null
+++ b/.changeset/fn-7559-approval-gate-disambiguation.md
@@ -0,0 +1,7 @@
+---
+"@runfusion/fusion": patch
+---
+
+summary: Tasks held for release authorization or Plan Review are now shown distinctly, so auto-approve no longer looks broken.
+category: fix
+dev: FN-7559 — auto-approve-all bypasses only the manual plan-approval gate (unchanged, FN-7526). Release-authorization holds are surfaced with a new distinct status reason (`Task.awaitingApprovalReason: "release-authorization"`) and no longer render the generic manual Approve/Reject affordance in TaskCard/TaskDetailModal; Workflow Plan Review already used distinct statuses (`needs-replan`/`plan-review-unavailable`) and is unaffected. Both gates remain independent and intact — this is UI/data disambiguation only.
diff --git a/docs/settings-reference.md b/docs/settings-reference.md
index 890fb8861f..078ab035ba 100644
--- a/docs/settings-reference.md
+++ b/docs/settings-reference.md
@@ -419,7 +419,7 @@ Security-sensitive file-browser escape hatches are project-only. `allowAbsoluteF
 | `overlapIgnorePaths` | `string[]` | `[]` | Optional project-relative file or directory paths to exclude from overlap blocking (for example `docs` or `generated/openapi.json`). Entries are trimmed, deduplicated, and must not be absolute or contain `..` traversal. |
 | `allowAbsoluteFileBrowserPaths` | `boolean` | `false` | Project-scoped Settings → General toggle for the workspace file browser. When enabled, slash-prefixed paths such as `/tmp` can be listed/read/written/downloaded through workspace file-browser routes while keeping existing file-size, binary, type, null-byte, traversal, and permission checks. Windows drive-letter paths remain blocked, and task-local file routes, memory APIs, worktree-copy validation, plugin bundle paths, and other validators are unchanged. |
 | `autoMerge` | `boolean` | `true` | Auto-finalize tasks from `in-review`. Tasks can override this per-task (including at create time in New Task modal via **Auto-merge** = Default/Enabled/Disabled); explicit overrides are tagged with `autoMergeProvenance: "user"`, while tasks left at **Default** keep following the live global setting and do not snapshot it when entering review. Legacy pre-FN-6245 in-review rows that were stamped `autoMerge: true` are marked `autoMergeProvenance: "legacy-stamp"` on startup and can be inspected/cleared with Settings → Merge → **Legacy auto-merge stamp cleanup**, `fn pr automerge-cleanup [--apply] [--json]`, or `reconcileLegacyAutoMergeStamps({ apply: true })` after operator review. For grouped branch flows, per-task `autoMerge` governs member→group-integration landing while group `autoMerge` governs group→default-branch promotion eligibility. |
-| `planApprovalMode` | `"workflow" \| "auto-approve-all" \| "require-all"` | `"auto-approve-all"` | Project-scoped override for the manual planning approval gate. Defaults to auto-approve-all (FN-7557) so new/unset projects skip the manual gate; `"workflow"` instead preserves the workflow-resolved `requirePlanApproval`; `"auto-approve-all"` moves every successfully specified task to `todo` without manual plan approval even when the selected workflow or stored workflow setting has `requirePlanApproval: true`; `"require-all"` parks every specified task at `status: "awaiting-approval"` regardless of workflow settings. Settings → Merge remains the full three-state editor; the Board Triage/intake **Auto-approve plan** switch is a binary shortcut for `"auto-approve-all"` vs `"workflow"`. This does not disable Workflow Plan Review, release authorization, or other non-plan safety gates. |
+| `planApprovalMode` | `"workflow" \| "auto-approve-all" \| "require-all"` | `"auto-approve-all"` | Project-scoped override for the manual planning approval gate. Defaults to auto-approve-all (FN-7557) so new/unset projects skip the manual gate; `"workflow"` instead preserves the workflow-resolved `requirePlanApproval`; `"auto-approve-all"` moves every successfully specified task to `todo` without manual plan approval even when the selected workflow or stored workflow setting has `requirePlanApproval: true`; `"require-all"` parks every specified task at `status: "awaiting-approval"` regardless of workflow settings. Settings → Merge remains the full three-state editor; the Board Triage/intake **Auto-approve plan** switch is a binary shortcut for `"auto-approve-all"` vs `"workflow"`. This does not disable Workflow Plan Review, release authorization, or other non-plan safety gates. **FN-7559:** release authorization and the manual gate both use `status: "awaiting-approval"`, so a release-class task that still parks under `"auto-approve-all"` is NOT a broken auto-approve — it is the intentionally-not-bypassed release-authorization gate. The task carries `awaitingApprovalReason: "release-authorization"` in that case (undefined for a genuine manual hold), and the dashboard renders a distinct "Awaiting Release Authorization" label with the Approve/Reject Plan buttons hidden, instead of the generic manual-approval affordance. |
 | `maxAutoMergeRetries` | `number` | `3` | Project-scoped positive-integer cap for auto-merge conflict-resolution retries before Fusion parks or bounces a task for human/recovery handling. Unset, non-finite, zero, or negative values fall back to `3` to preserve historical behavior. |
 | `mergeRequestContractShadowEnabled` | `boolean` | `false` | Phase-1 FN-5741 write-only shadow flag (project/global setting). When enabled, executor/self-healing/merger persist merge-request records and `completion_handoff_accepted` markers for observation only; legacy mergeQueue + lifecycle remains authoritative. |
 | `mergeStrategy` | `"direct" \| "pull-request"` | `"direct"` | Completion mode (local direct merge vs PR-first). |
diff --git a/docs/workflow-steps.md b/docs/workflow-steps.md
index e3f7e652bd..bb314fe3da 100644
--- a/docs/workflow-steps.md
+++ b/docs/workflow-steps.md
@@ -212,6 +212,8 @@ If the Plan Review reviewer is unavailable before producing a verdict, the task
 
 Workflow Plan Review is separate from manual plan approval. Project `planApprovalMode: "auto-approve-all"` bypasses only the final manual `awaiting-approval` plan gate after the plan is specified and any enabled Plan Review passes; it does not disable Plan Review, release authorization, or other explicit safety gates.
 
+**FN-7559 — telling the three holds apart:** Plan Review parks a task with its own distinct statuses (`needs-replan` for a revision verdict, `plan-review-unavailable` for a reviewer-outage retry), so it never renders identically to a plan-approval hold. The release-authorization gate and the manual plan-approval gate, however, both use `status: "awaiting-approval"` — auto-approve-all bypasses the manual gate but never the release-authorization gate, so a release-class task (or a user-authored task missing the explicit authorization marker) still parks even with auto-approve-all on. To make that unambiguous to the operator, the task carries `awaitingApprovalReason: "release-authorization"` only when the release-authorization gate is the one holding it; the dashboard renders a distinct "Awaiting Release Authorization" label and hides the Approve/Reject Plan buttons for that hold instead of showing the generic manual-approval affordance.
+
 `builtin:legacy-coding` is backed by the original monolithic `BUILTIN_CODING_WORKFLOW_IR`: `planning` → `execute` → optional quality gates → `review` → merge region.
 
 `builtin:stepwise-coding` displays as Coding (per-step review). It is backed by `BUILTIN_STEPWISE_CODING_WORKFLOW_IR`; it keeps the same lifecycle columns/traits while adding the default-on optional Plan Review before `parse-steps`, modeling per-step parse/execute/review/rework as authored graph structure, and retaining the post-foreach optional Code Review gate before its final review/merge region.
diff --git a/packages/core/src/__tests__/db.test.ts b/packages/core/src/__tests__/db.test.ts
index 2bc5842e34..efc1045b4f 100644
--- a/packages/core/src/__tests__/db.test.ts
+++ b/packages/core/src/__tests__/db.test.ts
@@ -1823,6 +1823,59 @@ describe("schema migrations", () => {
     db.close();
   });
 
+  /*
+   * FNXC:PlanApproval 2026-07-04-21:35:
+   * FN-7559: migration 138 adds the awaitingApprovalReason discriminator so
+   * a release-authorization hold (status "awaiting-approval") can be told apart
+   * from a manual plan-approval hold sharing the identical status. Additive-only,
+   * no backfill — legacy rows stay NULL, meaning "no reason recorded" (either no
+   * hold, or an ordinary manual hold).
+   */
+  it("migrates v137 databases by adding awaitingApprovalReason column with legacy rows staying NULL (no backfill)", () => {
+    tmpDir = makeTmpDir();
+    const fusionDir = join(tmpDir, ".fusion");
+    const db = new Database(fusionDir);
+
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS __meta (key TEXT PRIMARY KEY, value TEXT);
+      CREATE TABLE IF NOT EXISTS tasks (
+        id TEXT PRIMARY KEY,
+        description TEXT NOT NULL,
+        "column" TEXT NOT NULL,
+        status TEXT,
+        createdAt TEXT NOT NULL,
+        updatedAt TEXT NOT NULL,
+        executionMode TEXT DEFAULT 'standard',
+        plannerOversightLevel TEXT
+      );
+      CREATE TABLE IF NOT EXISTS config (
+        id INTEGER PRIMARY KEY CHECK (id = 1),
+        nextId INTEGER DEFAULT 1,
+        nextWorkflowStepId INTEGER DEFAULT 1,
+        settings TEXT DEFAULT '{}',
+        workflowSteps TEXT DEFAULT '[]',
+        updatedAt TEXT
+      );
+    `);
+    db.exec("INSERT INTO __meta (key, value) VALUES ('schemaVersion', '137')");
+    db.exec("INSERT INTO __meta (key, value) VALUES ('lastModified', '1000')");
+    db.exec(`INSERT INTO tasks (id, description, "column", status, createdAt, updatedAt) VALUES ('FN-1', 'legacy', 'triage', 'awaiting-approval', '2026-01-01', '2026-01-01')`);
+
+    db.init();
+
+    expect(db.getSchemaVersion()).toBe(SCHEMA_VERSION);
+
+    const cols = db.prepare("PRAGMA table_info(tasks)").all() as Array<{ name: string }>;
+    expect(cols.map((col) => col.name)).toContain("awaitingApprovalReason");
+
+    const task = db.prepare("SELECT awaitingApprovalReason FROM tasks WHERE id = 'FN-1'").get() as {
+      awaitingApprovalReason: string | null;
+    };
+    expect(task.awaitingApprovalReason).toBeNull();
+
+    db.close();
+  });
+
   it("migrates v43 databases by adding task token-usage aggregate columns with null-compatible defaults", () => {
     tmpDir = makeTmpDir();
     const fusionDir = join(tmpDir, ".fusion");
diff --git a/packages/core/src/db.ts b/packages/core/src/db.ts
index a22c9b518c..9ccc400a08 100644
--- a/packages/core/src/db.ts
+++ b/packages/core/src/db.ts
@@ -183,7 +183,7 @@ export function isFts5CorruptionError(error: unknown): boolean {
 
 // ── Schema Definition ────────────────────────────────────────────────
 
-const SCHEMA_VERSION = 137;
+const SCHEMA_VERSION = 138;
 
 const TASKS_FTS_AUTOMERGE = 8;
 const TASKS_FTS_CRISISMERGE = 16;
@@ -300,6 +300,7 @@ CREATE TABLE IF NOT EXISTS tasks (
   thinkingLevel TEXT,
   executionMode TEXT DEFAULT 'standard',
   plannerOversightLevel TEXT,
+  awaitingApprovalReason TEXT,
   tokenUsageInputTokens INTEGER,
   tokenUsageOutputTokens INTEGER,
   tokenUsageCachedTokens INTEGER,
@@ -5571,6 +5572,24 @@ export class Database {
       });
     }
 
+    if (version < 138) {
+      /*
+       * FNXC:PlanApproval 2026-07-04-21:35:
+       * FN-7559 — release-authorization and manual plan-approval both park a task
+       * with status "awaiting-approval" and rendered an identical operator-facing
+       * badge/Approve-Plan affordance, so operators with auto-approve-all enabled
+       * could not tell an intentionally-not-bypassed release-authorization hold
+       * from a (never-fired, since bypassed) manual gate — read as "auto-approve is
+       * broken". This nullable discriminator is set only by the release-authorization
+       * gate (packages/engine/src/triage.ts) so the dashboard can render a distinct,
+       * truthful label and hide the manual Approve/Reject affordance for that hold.
+       * Additive-only: NULL means an ordinary manual-approval hold (or no hold).
+       */
+      this.applyMigration(138, () => {
+        this.addColumnIfMissing("tasks", "awaitingApprovalReason", "TEXT");
+      });
+    }
+
   }
 
   /**
diff --git a/packages/core/src/store.ts b/packages/core/src/store.ts
index 540e641f62..f2244d84b7 100644
--- a/packages/core/src/store.ts
+++ b/packages/core/src/store.ts
@@ -271,6 +271,7 @@ interface TaskRow {
   thinkingLevel: string | null;
   executionMode: string | null;
   plannerOversightLevel: string | null;
+  awaitingApprovalReason: string | null;
   tokenUsageInputTokens: number | null;
   tokenUsageOutputTokens: number | null;
   tokenUsageCachedTokens: number | null;
@@ -437,6 +438,14 @@ const TASK_COLUMN_DESCRIPTORS: TaskColumnDescriptor[] = [
   defineTaskColumn("thinkingLevel", (task) => task.thinkingLevel ?? null),
   defineTaskColumn("executionMode", (task) => task.executionMode ?? null),
   defineTaskColumn("plannerOversightLevel", (task) => task.plannerOversightLevel ?? null),
+  /*
+   * FNXC:PlanApproval 2026-07-04-21:35:
+   * FN-7559 discriminator: only the release-authorization gate sets this (to
+   * "release-authorization"); the manual plan-approval gate always writes it
+   * back to null so a stale value from an earlier release-authorization hold on
+   * the same task never survives past the manual gate's own awaiting-approval.
+   */
+  defineTaskColumn("awaitingApprovalReason", (task) => task.awaitingApprovalReason ?? null),
   defineTaskColumn("tokenUsageInputTokens", (task) => task.tokenUsage?.inputTokens ?? null),
   defineTaskColumn("tokenUsageOutputTokens", (task) => task.tokenUsage?.outputTokens ?? null),
   defineTaskColumn("tokenUsageCachedTokens", (task) => task.tokenUsage?.cachedTokens ?? null),
@@ -2135,6 +2144,7 @@ export class TaskStore extends EventEmitter<TaskStoreEvents> {
       thinkingLevel: (row.thinkingLevel || undefined) as Task["thinkingLevel"],
       executionMode: (row.executionMode || undefined) as Task["executionMode"],
       plannerOversightLevel: (row.plannerOversightLevel || undefined) as Task["plannerOversightLevel"],
+      awaitingApprovalReason: (row.awaitingApprovalReason || undefined) as Task["awaitingApprovalReason"],
       createdAt: row.createdAt,
       updatedAt: row.updatedAt,
       columnMovedAt: row.columnMovedAt || undefined,
@@ -2691,7 +2701,7 @@ export class TaskStore extends EventEmitter<TaskStoreEvents> {
       "validatorModelProvider", "validatorModelId",
       "planningModelProvider", "planningModelId",
       "mergeRetries", "workflowStepRetries", "stuckKillCount", "resumeLimboCount", "graphResumeRetryCount", "resumeLimboTipSha", "resumeLimboStepSignature", "postReviewFixCount", "recoveryRetryCount", "taskDoneRetryCount", "worktreeSessionRetryCount", "completionHandoffLimboRecoveryCount", "verificationFailureCount", "mergeConflictBounceCount", "mergeAuditBounceCount", "mergeTransientRetryCount", "branchConflictRecoveryCount", "reviewerContextRetryCount", "reviewerFallbackRetryCount", "nextRecoveryAt",
-      "error", "summary", "thinkingLevel", "executionMode", "plannerOversightLevel",
+      "error", "summary", "thinkingLevel", "executionMode", "plannerOversightLevel", "awaitingApprovalReason",
       "tokenUsageInputTokens", "tokenUsageOutputTokens", "tokenUsageCachedTokens", "tokenUsageCacheWriteTokens", "tokenUsageTotalTokens", "tokenUsageFirstUsedAt", "tokenUsageLastUsedAt", "tokenUsageModelProvider", "tokenUsageModelId", "tokenUsagePerModel", "tokenBudgetSoftAlertedAt", "tokenBudgetHardAlertedAt", "tokenBudgetOverride",
       "createdAt", "updatedAt", "columnMovedAt", "firstExecutionAt", "cumulativeActiveMs", "columnDwellMs", "executionStartedAt", "executionCompletedAt",
       "dependencies", "steps", "customFields", "comments", "review", "reviewState", "workflowStepResults", "steeringComments",
@@ -2787,7 +2797,7 @@ export class TaskStore extends EventEmitter<TaskStoreEvents> {
       "validatorModelProvider", "validatorModelId",
       "planningModelProvider", "planningModelId",
       "mergeRetries", "workflowStepRetries", "stuckKillCount", "resumeLimboCount", "graphResumeRetryCount", "resumeLimboTipSha", "resumeLimboStepSignature", "postReviewFixCount", "recoveryRetryCount", "taskDoneRetryCount", "worktreeSessionRetryCount", "completionHandoffLimboRecoveryCount", "verificationFailureCount", "mergeConflictBounceCount", "mergeAuditBounceCount", "mergeTransientRetryCount", "branchConflictRecoveryCount", "reviewerContextRetryCount", "reviewerFallbackRetryCount", "nextRecoveryAt",
-      "error", "summary", "thinkingLevel", "executionMode", "plannerOversightLevel",
+      "error", "summary", "thinkingLevel", "executionMode", "plannerOversightLevel", "awaitingApprovalReason",
       "tokenUsageInputTokens", "tokenUsageOutputTokens", "tokenUsageCachedTokens", "tokenUsageCacheWriteTokens", "tokenUsageTotalTokens", "tokenUsageFirstUsedAt", "tokenUsageLastUsedAt", "tokenUsageModelProvider", "tokenUsageModelId", "tokenUsagePerModel", "tokenBudgetSoftAlertedAt", "tokenBudgetHardAlertedAt", "tokenBudgetOverride",
       "createdAt", "updatedAt", "columnMovedAt", "firstExecutionAt", "cumulativeActiveMs", "columnDwellMs", "executionStartedAt", "executionCompletedAt",
       "dependencies", "steps", "customFields", "attachments", "steeringComments",
@@ -8407,7 +8417,7 @@ ${TASK_UPSERT_SQL_ASSIGNMENTS}
 
   async updateTask(
     id: string,
-    updates: { title?: string; description?: string; priority?: TaskPriority | null; prompt?: string; worktree?: string | null; workspaceWorktrees?: import("./types.js").Task["workspaceWorktrees"]; status?: string | null; dependencies?: string[]; steps?: import("./types.js").TaskStep[]; customFields?: Record<string, unknown>; currentStep?: number; blockedBy?: string | null; overlapBlockedBy?: string | null; assignedAgentId?: string | null; pausedByAgentId?: string | null; pausedReason?: string | null; tokenBudgetSoftAlertedAt?: string | null; worktrunkFallbackAlertedAt?: string | null; worktrunkFailure?: import("./types.js").Task["worktrunkFailure"] | null; tokenBudgetHardAlertedAt?: string | null; tokenBudgetOverride?: import("./types.js").TaskTokenBudgetOverride | null; dispatchStormCount?: number | null; lastDispatchAt?: string | null; assigneeUserId?: string | null; scopeOverride?: boolean | null; scopeOverrideReason?: string | null; scopeAutoWiden?: string[] | null; nodeId?: string | null; effectiveNodeId?: string | null; effectiveNodeSource?: string | null; checkedOutBy?: string | null; checkedOutAt?: string | null; checkoutNodeId?: string | null; checkoutRunId?: string | null; checkoutLeaseRenewedAt?: string | null; checkoutLeaseEpoch?: number | null; paused?: boolean; baseBranch?: string | null; autoMerge?: boolean | null; branch?: string | null; executionStartBranch?: string | null; baseCommitSha?: string | null; size?: "S" | "M" | "L"; reviewLevel?: number; executionMode?: import("./types.js").ExecutionMode | null; plannerOversightLevel?: import("./types.js").PlannerOversightLevel | null; mergeRetries?: number; workflowStepRetries?: number; stuckKillCount?: number | null; resumeLimboCount?: number | null; graphResumeRetryCount?: number | null; resumeLimboTipSha?: string | null; resumeLimboStepSignature?: string | null; postReviewFixCount?: number | null; recoveryRetryCount?: number | null; taskDoneRetryCount?: number | null; worktreeSessionRetryCount?: number | null; completionHandoffLimboRecoveryCount?: number | null; verificationFailureCount?: number | null; mergeConflictBounceCount?: number | null; mergeAuditBounceCount?: number | null; mergeTransientRetryCount?: number | null; branchConflictRecoveryCount?: number | null; reviewerContextRetryCount?: number | null; reviewerFallbackRetryCount?: number | null; nextRecoveryAt?: string | null; enabledWorkflowSteps?: string[]; noCommitsExpected?: boolean | null; modelProvider?: string | null; modelId?: string | null; validatorModelProvider?: string | null; validatorModelId?: string | null; planningModelProvider?: string | null; planningModelId?: string | null; thinkingLevel?: string | null; error?: string | null; summary?: string | null; sessionFile?: string | null; firstExecutionAt?: string | null; cumulativeActiveMs?: number | null; executionStartedAt?: string | null; executionCompletedAt?: string | null; review?: import("./types.js").TaskReview | null; reviewState?: import("./types.js").TaskReviewState | null; workflowStepResults?: import("./types.js").WorkflowStepResult[] | null; mergeDetails?: import("./types.js").MergeDetails | null; sourceIssue?: import("./types.js").TaskSourceIssue | null; sourceMetadataPatch?: Record<string, unknown> | null; githubTracking?: import("./types.js").TaskGithubTracking | null; gitlabTracking?: (Omit<import("./types.js").TaskGitLabTracking, "item"> & { item?: import("./types.js").TaskGitLabTrackedItem | null }) | null; tokenUsage?: import("./types.js").TaskTokenUsage | null; modifiedFiles?: string[] | null; workflowTransitionNotification?: import("./types.js").Task["workflowTransitionNotification"] | null; missionId?: string | null; sliceId?: string | null },
+    updates: { title?: string; description?: string; priority?: TaskPriority | null; prompt?: string; worktree?: string | null; workspaceWorktrees?: import("./types.js").Task["workspaceWorktrees"]; status?: string | null; dependencies?: string[]; steps?: import("./types.js").TaskStep[]; customFields?: Record<string, unknown>; currentStep?: number; blockedBy?: string | null; overlapBlockedBy?: string | null; assignedAgentId?: string | null; pausedByAgentId?: string | null; pausedReason?: string | null; tokenBudgetSoftAlertedAt?: string | null; worktrunkFallbackAlertedAt?: string | null; worktrunkFailure?: import("./types.js").Task["worktrunkFailure"] | null; tokenBudgetHardAlertedAt?: string | null; tokenBudgetOverride?: import("./types.js").TaskTokenBudgetOverride | null; dispatchStormCount?: number | null; lastDispatchAt?: string | null; assigneeUserId?: string | null; scopeOverride?: boolean | null; scopeOverrideReason?: string | null; scopeAutoWiden?: string[] | null; nodeId?: string | null; effectiveNodeId?: string | null; effectiveNodeSource?: string | null; checkedOutBy?: string | null; checkedOutAt?: string | null; checkoutNodeId?: string | null; checkoutRunId?: string | null; checkoutLeaseRenewedAt?: string | null; checkoutLeaseEpoch?: number | null; paused?: boolean; baseBranch?: string | null; autoMerge?: boolean | null; branch?: string | null; executionStartBranch?: string | null; baseCommitSha?: string | null; size?: "S" | "M" | "L"; reviewLevel?: number; executionMode?: import("./types.js").ExecutionMode | null; plannerOversightLevel?: import("./types.js").PlannerOversightLevel | null; awaitingApprovalReason?: import("./types.js").Task["awaitingApprovalReason"] | null; mergeRetries?: number; workflowStepRetries?: number; stuckKillCount?: number | null; resumeLimboCount?: number | null; graphResumeRetryCount?: number | null; resumeLimboTipSha?: string | null; resumeLimboStepSignature?: string | null; postReviewFixCount?: number | null; recoveryRetryCount?: number | null; taskDoneRetryCount?: number | null; worktreeSessionRetryCount?: number | null; completionHandoffLimboRecoveryCount?: number | null; verificationFailureCount?: number | null; mergeConflictBounceCount?: number | null; mergeAuditBounceCount?: number | null; mergeTransientRetryCount?: number | null; branchConflictRecoveryCount?: number | null; reviewerContextRetryCount?: number | null; reviewerFallbackRetryCount?: number | null; nextRecoveryAt?: string | null; enabledWorkflowSteps?: string[]; noCommitsExpected?: boolean | null; modelProvider?: string | null; modelId?: string | null; validatorModelProvider?: string | null; validatorModelId?: string | null; planningModelProvider?: string | null; planningModelId?: string | null; thinkingLevel?: string | null; error?: string | null; summary?: string | null; sessionFile?: string | null; firstExecutionAt?: string | null; cumulativeActiveMs?: number | null; executionStartedAt?: string | null; executionCompletedAt?: string | null; review?: import("./types.js").TaskReview | null; reviewState?: import("./types.js").TaskReviewState | null; workflowStepResults?: import("./types.js").WorkflowStepResult[] | null; mergeDetails?: import("./types.js").MergeDetails | null; sourceIssue?: import("./types.js").TaskSourceIssue | null; sourceMetadataPatch?: Record<string, unknown> | null; githubTracking?: import("./types.js").TaskGithubTracking | null; gitlabTracking?: (Omit<import("./types.js").TaskGitLabTracking, "item"> & { item?: import("./types.js").TaskGitLabTrackedItem | null }) | null; tokenUsage?: import("./types.js").TaskTokenUsage | null; modifiedFiles?: string[] | null; workflowTransitionNotification?: import("./types.js").Task["workflowTransitionNotification"] | null; missionId?: string | null; sliceId?: string | null },
     runContext?: RunMutationContext,
   ): Promise<Task> {
     return this.withTaskLock(id, () => this.updateTaskUnlocked(id, updates, runContext));
@@ -9228,6 +9238,11 @@ ${TASK_UPSERT_SQL_ASSIGNMENTS}
       } else if (updates.plannerOversightLevel !== undefined) {
         task.plannerOversightLevel = updates.plannerOversightLevel as import("./types.js").PlannerOversightLevel;
       }
+      if (updates.awaitingApprovalReason === null) {
+        task.awaitingApprovalReason = undefined;
+      } else if (updates.awaitingApprovalReason !== undefined) {
+        task.awaitingApprovalReason = updates.awaitingApprovalReason as import("./types.js").Task["awaitingApprovalReason"];
+      }
       if (updates.error === null) {
         task.error = undefined;
       } else if (updates.error !== undefined) {
diff --git a/packages/core/src/types.ts b/packages/core/src/types.ts
index b389202104..ce51edb2a7 100644
--- a/packages/core/src/types.ts
+++ b/packages/core/src/types.ts
@@ -2462,6 +2462,22 @@ export interface Task {
    *  recovery retry. Scheduler and triage processor skip tasks whose
    *  `nextRecoveryAt` is still in the future. Cleared alongside `recoveryRetryCount`. */
   nextRecoveryAt?: string;
+  /*
+   * FNXC:PlanApproval 2026-07-04-21:35:
+   * FN-7559: release authorization (packages/engine/src/triage-release-authorization.ts)
+   * and the ordinary manual plan-approval gate (packages/core/src/plan-approval.ts,
+   * resolvePlanApprovalRequired) both park a task with status "awaiting-approval" and
+   * previously rendered an identical badge/Approve-Plan affordance in the dashboard.
+   * Project auto-approve-all (planApprovalMode: "auto-approve-all") bypasses ONLY the
+   * manual gate — release authorization is an independent safety gate it never skips —
+   * so an operator with auto-approve on could not tell a still-parked release hold from
+   * a (never-fired) manual hold and reasonably concluded auto-approve was broken.
+   * Set to "release-authorization" only by the release-authorization gate; the manual
+   * gate always writes it back to undefined/null so a stale reason from an earlier pass
+   * never survives past the manual gate's own awaiting-approval. Undefined means either
+   * no hold or an ordinary manual-approval hold.
+   */
+  awaitingApprovalReason?: "release-authorization";
   /** Thinking level for AI agent sessions — controls reasoning effort (off/minimal/low/medium/high) */
   thinkingLevel?: ThinkingLevel;
   /** Execution mode for task implementation.
diff --git a/packages/dashboard/app/components/TaskCard.css b/packages/dashboard/app/components/TaskCard.css
index 04dc029390..e667dccee8 100644
--- a/packages/dashboard/app/components/TaskCard.css
+++ b/packages/dashboard/app/components/TaskCard.css
@@ -380,6 +380,17 @@ Workflow badges need a slight token-based gap between icon and label so compact
   color: var(--triage);
 }
 
+/*
+FNXC:PlanApproval 2026-07-04-21:35:
+FN-7559: release-authorization holds share the awaiting-approval status/badge
+base styling with the manual gate but get a subtle border so the distinct
+"Awaiting Release Authorization" label reads as a genuinely different hold,
+not a restyle of the ordinary manual-approval badge.
+*/
+.card-status-badge.awaiting-release-authorization {
+  border: 1px solid color-mix(in srgb, var(--triage) 55%, transparent);
+}
+
 .card-status-badge.awaiting-input {
   background: color-mix(in srgb, var(--color-warning) 14%, transparent);
   color: var(--color-warning);
diff --git a/packages/dashboard/app/components/TaskCard.tsx b/packages/dashboard/app/components/TaskCard.tsx
index d8ca402cfe..aca0b43de0 100644
--- a/packages/dashboard/app/components/TaskCard.tsx
+++ b/packages/dashboard/app/components/TaskCard.tsx
@@ -1253,6 +1253,15 @@ function TaskCardComponent({
   const hasTaskAgeStaleness = shouldShowTaskAgeStalenessBadge(task);
   const taskAgeStalenessCopy = getTaskAgeStalenessCopy(task.ageStaleness);
   const isAwaitingApproval = task.column === "triage" && task.status === "awaiting-approval";
+  /*
+   * FNXC:PlanApproval 2026-07-04-21:35:
+   * FN-7559: release-authorization holds and manual plan-approval holds both use
+   * status "awaiting-approval" (auto-approve-all intentionally bypasses only the
+   * manual gate — see FNXC:PlanApproval in types.ts). Distinguish them for the
+   * operator via the awaitingApprovalReason discriminator instead of showing the
+   * generic manual-approval badge/label for both.
+   */
+  const isReleaseAuthorizationHold = isAwaitingApproval && task.awaitingApprovalReason === "release-authorization";
   const isAwaitingInput = task.status === "awaiting-user-input";
   const isArchived = task.column === "archived";
   const isAgentActive = !globalPaused && !queued && !isFailed && !isPaused && !isStuck && !isAwaitingApproval && !isAwaitingInput && (task.column === "in-progress" || ACTIVE_STATUSES.has(visualStatus as string));
@@ -2674,9 +2683,9 @@ function TaskCardComponent({
         )}
         {!isPaused && visualStatus && visualStatus !== "queued" && (
           <span
-            className={`card-status-badge card-status-badge--${task.column}${isAwaitingApproval ? " awaiting-approval" : ""}${isAwaitingInput ? " awaiting-input" : ""}${ACTIVE_STATUSES.has(visualStatus) ? " pulsing" : ""}${isFailed ? " failed" : ""}${isStuck ? " stuck" : ""}`}
+            className={`card-status-badge card-status-badge--${task.column}${isAwaitingApproval ? " awaiting-approval" : ""}${isReleaseAuthorizationHold ? " awaiting-release-authorization" : ""}${isAwaitingInput ? " awaiting-input" : ""}${ACTIVE_STATUSES.has(visualStatus) ? " pulsing" : ""}${isFailed ? " failed" : ""}${isStuck ? " stuck" : ""}`}
           >
-            {isStuck ? t("tasks.stuck", "Stuck") : isAwaitingApproval ? t("tasks.awaitingApproval", "Awaiting Approval") : isAwaitingInput ? t("tasks.needsInput", "Needs input") : visualStatus === "merging-fix" ? t("tasks.statusMergingFix", "Merging fixes…") : getTaskStatusLabel(visualStatus, t)}
+            {isStuck ? t("tasks.stuck", "Stuck") : isReleaseAuthorizationHold ? t("tasks.awaitingReleaseAuthorization", "Awaiting Release Authorization") : isAwaitingApproval ? t("tasks.awaitingApproval", "Awaiting Approval") : isAwaitingInput ? t("tasks.needsInput", "Needs input") : visualStatus === "merging-fix" ? t("tasks.statusMergingFix", "Merging fixes…") : getTaskStatusLabel(visualStatus, t)}
           </span>
         )}
         {/*
diff --git a/packages/dashboard/app/components/TaskDetailModal.css b/packages/dashboard/app/components/TaskDetailModal.css
index aadb3477ed..536d4b074c 100644
--- a/packages/dashboard/app/components/TaskDetailModal.css
+++ b/packages/dashboard/app/components/TaskDetailModal.css
@@ -2888,6 +2888,17 @@ The original operator prompt is now rendered as Markdown (shared PROMPT.md rende
   color: var(--text-dim);
 }
 
+/*
+FNXC:PlanApproval 2026-07-04-21:35:
+FN-7559: truthful informational label shown instead of the manual Approve/Reject
+Plan affordance when a task's awaiting-approval hold is from release authorization
+(not the manual gate) — auto-approve-all does not bypass this gate.
+*/
+.modal-hold-reason {
+  font-size: 12px;
+  color: var(--triage);
+}
+
 .modal-edit-hint kbd {
   background: var(--card);
   border: 1px solid var(--border);
diff --git a/packages/dashboard/app/components/TaskDetailModal.tsx b/packages/dashboard/app/components/TaskDetailModal.tsx
index 07c96a3545..04d56d92dd 100644
--- a/packages/dashboard/app/components/TaskDetailModal.tsx
+++ b/packages/dashboard/app/components/TaskDetailModal.tsx
@@ -2570,6 +2570,17 @@ export function TaskDetailContent({
   }, [onArchiveTask, confirm, task.id, nearDuplicateOf, addToast, requestClose]);
 
   const isTaskPaused = task.paused || task.userPaused;
+  /*
+   * FNXC:PlanApproval 2026-07-04-21:35:
+   * FN-7559: release-authorization holds and manual plan-approval holds both
+   * use status "awaiting-approval" (auto-approve-all intentionally bypasses only
+   * the manual gate — see FNXC:PlanApproval in types.ts). Gate the manual
+   * Approve/Reject Plan affordance to genuine manual holds only — clicking
+   * "Approve Plan" on a release-authorization hold would let a release-class
+   * spec bypass FN-6481's explicit-marker requirement via a plain button click.
+   */
+  const isAwaitingApproval = task.column === "triage" && task.status === "awaiting-approval";
+  const isReleaseAuthorizationHold = isAwaitingApproval && task.awaitingApprovalReason === "release-authorization";
 
   const handleTogglePause = useCallback(async () => {
     try {
@@ -5565,8 +5576,10 @@ export function TaskDetailContent({
             </>
           ) : (
             <>
-              {/* Approve/Reject Plan buttons for tasks awaiting approval — always visible */}
-              {task.column === "triage" && task.status === "awaiting-approval" && workingTask.prompt && (
+              {/* Approve/Reject Plan buttons — only for genuine manual plan-approval
+                  holds (FN-7559: a release-authorization hold shares the same
+                  status but must never be resolvable via this plain button click). */}
+              {isAwaitingApproval && !isReleaseAuthorizationHold && workingTask.prompt && (
                 <>
                   <button className="btn btn-primary btn-sm" onClick={handleApprovePlan}>
                     {t("taskDetail.plan.approveBtn", "Approve Plan")}
@@ -5577,10 +5590,26 @@ export function TaskDetailContent({
                 </>
               )}
 
+              {/* FN-7559: release-authorization holds are surfaced with a truthful,
+                  distinct reason instead of the manual Approve/Reject affordance —
+                  auto-approve-all does not (and must not) bypass this gate, and
+                  resolving it requires the explicit authorization marker in a
+                  regenerated spec, not a plain approval click. */}
+              {isReleaseAuthorizationHold && (
+                <span className="modal-hold-reason modal-hold-reason--release-authorization">
+                  {t(
+                    "taskDetail.plan.releaseAuthorizationHold",
+                    "Awaiting release authorization — add the explicit authorization marker to the spec and resubmit.",
+                  )}
+                </span>
+              )}
+
               {/* Standalone Delete button for triage-column tasks — triage tasks
                   hide the Actions dropdown (see condition below) so the user has
-                  no quick way to delete a freshly-created task otherwise. */}
-              {task.column === "triage" && task.status !== "awaiting-approval" && !canRetryTask && (
+                  no quick way to delete a freshly-created task otherwise. Release-
+                  authorization holds no longer render the Approve/Reject affordance,
+                  so Delete remains available for them too (FN-7559). */}
+              {task.column === "triage" && (!isAwaitingApproval || isReleaseAuthorizationHold) && !canRetryTask && (
                 <button
                   className="btn btn-sm btn-danger"
                   onClick={handleDelete}
diff --git a/packages/dashboard/app/components/__tests__/TaskCard.test.tsx b/packages/dashboard/app/components/__tests__/TaskCard.test.tsx
index 99eb03f826..a485b3d23b 100644
--- a/packages/dashboard/app/components/__tests__/TaskCard.test.tsx
+++ b/packages/dashboard/app/components/__tests__/TaskCard.test.tsx
@@ -1,6 +1,6 @@
 import React from "react";
 import { afterEach, describe, it, expect, vi } from "vitest";
-import { render, screen, fireEvent, waitFor, act } from "@testing-library/react";
+import { render, screen, fireEvent, waitFor, act, within } from "@testing-library/react";
 import { TaskCard, formatElapsedDurationDone, __test_areTaskCardPropsEqual } from "../TaskCard";
 import { NavigationHistoryProvider, useNavigationHistory } from "../../hooks/useNavigationHistory";
 import { useOverlayDismiss } from "../../hooks/useOverlayDismiss";
@@ -1695,6 +1695,39 @@ describe("TaskCard", () => {
     expect(container.querySelector(".card-status-badge")).toBeNull();
   });
 
+  /*
+   * FN-7559: release-authorization holds and manual plan-approval holds both
+   * use status "awaiting-approval" (auto-approve-all intentionally bypasses
+   * only the manual gate), so the card badge must render a distinct label and
+   * class for a release-authorization hold instead of the generic "Awaiting
+   * Approval" manual-gate badge.
+   */
+  it("renders a distinct badge for a release-authorization hold vs a manual approval hold", () => {
+    const { container: manualContainer, unmount: unmountManual } = render(
+      <TaskCard
+        task={makeTask({ column: "triage", status: "awaiting-approval" })}
+        onOpenDetail={noop}
+        addToast={noop}
+      />,
+    );
+    expect(within(manualContainer).getByText("Awaiting Approval")).toBeDefined();
+    const manualBadge = manualContainer.querySelector(".card-status-badge") as HTMLElement;
+    expect(manualBadge.className).not.toContain("awaiting-release-authorization");
+    unmountManual();
+
+    const { container: releaseContainer } = render(
+      <TaskCard
+        task={makeTask({ column: "triage", status: "awaiting-approval", awaitingApprovalReason: "release-authorization" } as any)}
+        onOpenDetail={noop}
+        addToast={noop}
+      />,
+    );
+    expect(within(releaseContainer).getByText("Awaiting Release Authorization")).toBeDefined();
+    expect(within(releaseContainer).queryByText("Awaiting Approval")).toBeNull();
+    const releaseBadge = releaseContainer.querySelector(".card-status-badge") as HTMLElement;
+    expect(releaseBadge.className).toContain("awaiting-release-authorization");
+  });
+
   it("renders stalled badge with visible reason when stalledReview is set", () => {
     render(
       <TaskCard
diff --git a/packages/dashboard/app/components/__tests__/TaskDetailModal.definition-actions.test.tsx b/packages/dashboard/app/components/__tests__/TaskDetailModal.definition-actions.test.tsx
index c5700d6618..acb0fa4882 100644
--- a/packages/dashboard/app/components/__tests__/TaskDetailModal.definition-actions.test.tsx
+++ b/packages/dashboard/app/components/__tests__/TaskDetailModal.definition-actions.test.tsx
@@ -445,6 +445,38 @@ describe("TaskDetailModal", () => {
       expect(screen.getByText("Reject Plan")).toBeTruthy();
     });
 
+    /*
+     * FN-7559: release-authorization holds share status "awaiting-approval" with
+     * the manual gate (auto-approve-all intentionally does not bypass release
+     * authorization), so the plain Approve/Reject affordance must never render
+     * for them — clicking Approve would let a release-class spec bypass the
+     * FN-6481 explicit-marker requirement via a button click. Instead a distinct,
+     * truthful reason is shown and no leftover empty button shell remains.
+     */
+    it("shows a distinct release-authorization reason instead of Approve/Reject Plan buttons", () => {
+      render(
+        <TaskDetailModal
+          task={makeTask({
+            column: "triage",
+            status: "awaiting-approval",
+            awaitingApprovalReason: "release-authorization",
+            prompt: "# Task Spec",
+          })}
+          initialTab="definition"
+          onClose={noop}
+          onMoveTask={noopMove}
+          onDeleteTask={noopDelete}
+          onMergeTask={noopMerge}
+          onOpenDetail={noopOpenDetail}
+          addToast={noop}
+        />,
+      );
+
+      expect(screen.queryByText("Approve Plan")).toBeNull();
+      expect(screen.queryByText("Reject Plan")).toBeNull();
+      expect(screen.getByText(/Awaiting release authorization/i)).toBeTruthy();
+    });
+
     it("does not show approval buttons when task is not in triage", () => {
       render(
         <TaskDetailModal
diff --git a/packages/engine/src/__tests__/triage.test.ts b/packages/engine/src/__tests__/triage.test.ts
index 837eb6bec4..f9e74208c7 100644
--- a/packages/engine/src/__tests__/triage.test.ts
+++ b/packages/engine/src/__tests__/triage.test.ts
@@ -2664,7 +2664,13 @@ describe("requirePlanApproval setting", () => {
       { requirePlanApproval: false, planApprovalMode: "auto-approve-all" } as Settings,
     );
 
-    expect(store.updateTask).toHaveBeenCalledWith("FN-RELEASE", expect.objectContaining({ status: "awaiting-approval" }));
+    /*
+     * FN-7559: also assert the release gate stamps awaitingApprovalReason so
+     * the dashboard can distinguish this hold from a manual-approval hold that
+     * shares the same status — this is the actual fix for "tasks wait for
+     * approval even though auto-approve is on".
+     */
+    expect(store.updateTask).toHaveBeenCalledWith("FN-RELEASE", expect.objectContaining({ status: "awaiting-approval", awaitingApprovalReason: "release-authorization" }));
     expect(store.moveTask).not.toHaveBeenCalled();
     expect(recordActivity).toHaveBeenCalledWith(expect.objectContaining({ type: "task:release-authorization-required" }));
     expect(store.logEntry).toHaveBeenCalledWith(
@@ -2674,6 +2680,60 @@ describe("requirePlanApproval setting", () => {
     );
   });
 
+  /*
+   * FNXC:PlanApproval 2026-07-04-21:35:
+   * FN-7559 — root cause + fix regression test. Confirms all three symptom cases
+   * from the task's "Symptom Verification" section in one place: (a) a
+   * release-class hold still parks with a distinct awaitingApprovalReason even
+   * under auto-approve-all, (b) the manual gate's own awaiting-approval write
+   * always clears/omits that reason (never "release-authorization"), proving the
+   * operator can always tell the two holds apart from the persisted task state
+   * alone — not just from log text.
+   */
+  it("FN-7559: release-authorization hold carries a reason distinct from the manual gate's own awaiting-approval write", async () => {
+    const releaseTask = createTriageTask({
+      id: "FN-RELEASE2",
+      title: "Release @runfusion/fusion patch",
+      status: "planning",
+      sourceType: "agent_heartbeat",
+    } as Partial<Task>);
+    const releaseStore = createMockStore({
+      getTask: vi.fn().mockResolvedValue(releaseTask),
+    } as Partial<TaskStore>);
+    const releaseProcessor = new TriageProcessor(releaseStore, rootDir);
+    await (releaseProcessor as unknown as {
+      finalizeApprovedTask(task: Task, writtenInput: string, settings: Settings): Promise<void>;
+    }).finalizeApprovedTask(
+      releaseTask,
+      "# Task: FN-RELEASE2 - Release @runfusion/fusion patch\n\n## Mission\n\nRun pnpm release --yes.\n",
+      { requirePlanApproval: false, planApprovalMode: "auto-approve-all" } as Settings,
+    );
+    const releaseUpdateCall = (releaseStore.updateTask as ReturnType<typeof vi.fn>).mock.calls.find(
+      (call: unknown[]) => (call[1] as Record<string, unknown>)?.status === "awaiting-approval",
+    );
+    expect(releaseUpdateCall?.[1]).toMatchObject({ awaitingApprovalReason: "release-authorization" });
+
+    const manualTask = createTriageTask({
+      id: "FN-MANUAL2",
+      status: "planning",
+    } as Partial<Task>);
+    const manualStore = createMockStore({
+      getTask: vi.fn().mockResolvedValue(manualTask),
+    } as Partial<TaskStore>);
+    const manualProcessor = new TriageProcessor(manualStore, rootDir);
+    await (manualProcessor as unknown as {
+      finalizeApprovedTask(task: Task, writtenInput: string, settings: Settings): Promise<void>;
+    }).finalizeApprovedTask(
+      manualTask,
+      "# Task: FN-MANUAL2 - Ordinary task\n\n## Mission\n\nDo the thing.\n",
+      { requirePlanApproval: true, planApprovalMode: "require-all" } as Settings,
+    );
+    const manualUpdateCall = (manualStore.updateTask as ReturnType<typeof vi.fn>).mock.calls.find(
+      (call: unknown[]) => (call[1] as Record<string, unknown>)?.status === "awaiting-approval",
+    );
+    expect(manualUpdateCall?.[1]).toMatchObject({ awaitingApprovalReason: null });
+  });
+
   /*
    * FNXC:PlanApproval 2026-07-04-12:30:
    * FN-7526 — auto-approve-all must NOT bypass Workflow Plan Review. A REVISE
@@ -3145,8 +3205,15 @@ Forbidden paths / non-goals:
 
     expect(recovered).toBe(true);
     expect(store.moveTask).not.toHaveBeenCalled();
+    /*
+     * FN-7559: the manual gate's own awaiting-approval write now explicitly
+     * clears awaitingApprovalReason (defense against a stale "release-authorization"
+     * reason surviving a replan) so this genuine manual hold is never mistaken
+     * for a release-authorization hold in the dashboard.
+     */
     expect(store.updateTask).toHaveBeenCalledWith("FN-001", {
       status: "awaiting-approval",
+      awaitingApprovalReason: null,
     });
     expect(store.logEntry).toHaveBeenCalledWith(
       "FN-001",
diff --git a/packages/engine/src/triage.ts b/packages/engine/src/triage.ts
index cb6d27464a..99ebc5b8c0 100644
--- a/packages/engine/src/triage.ts
+++ b/packages/engine/src/triage.ts
@@ -2499,7 +2499,14 @@ export class TriageProcessor {
         promptText: written,
       });
       if (releaseGateDecision.action === "block") {
-        const approvalUpdates: Record<string, unknown> = { status: "awaiting-approval" };
+        /*
+         * FNXC:ReleaseAuthorizationGate 2026-07-04-21:35:
+         * FN-7559: stamp awaitingApprovalReason so the dashboard can tell this
+         * release-authorization hold apart from the (independently gated, never
+         * bypassed by auto-approve-all) manual plan-approval hold, which shares
+         * the same status: "awaiting-approval". See FNXC:PlanApproval in types.ts.
+         */
+        const approvalUpdates: Record<string, unknown> = { status: "awaiting-approval", awaitingApprovalReason: "release-authorization" };
         if (shouldApplyPromptDeclaredTitle && promptDeclaredTitle) {
           approvalUpdates.title = promptDeclaredTitle;
         }
@@ -2566,7 +2573,15 @@ export class TriageProcessor {
     FN-7526 re-verified this invariant end to end: every finalizeApprovedTask caller (specifyTask, recoverApprovedTask, retryUnavailablePlanReview, tryFinalizeExplicitDuplicateMarker) already derives `settings` from mergeEffectiveSettings so planApprovalMode (never a MOVED_SETTINGS_KEYS/workflow-owned key) survives any stored workflow requirePlanApproval overlay untouched. No production defect was found; regression tests were added across every surface to lock the invariant so a future bare-settings call site (e.g. `{ requirePlanApproval }` without planApprovalMode) is caught immediately instead of silently reintroducing the reported parking behavior.
     */
     if (resolvePlanApprovalRequired(settings)) {
-      const approvalUpdates: Record<string, unknown> = { status: "awaiting-approval" };
+      /*
+       * FNXC:PlanApproval 2026-07-04-21:35:
+       * FN-7559: explicitly clear awaitingApprovalReason on the manual gate's own
+       * awaiting-approval write so a stale "release-authorization" reason left over
+       * from an earlier pass on this same task (e.g. a replan after the release
+       * gate parked it, now passing the release gate but still requiring manual
+       * approval) never survives into this genuinely-manual hold.
+       */
+      const approvalUpdates: Record<string, unknown> = { status: "awaiting-approval", awaitingApprovalReason: null };
       if (shouldApplyPromptDeclaredTitle && promptDeclaredTitle) {
         approvalUpdates.title = promptDeclaredTitle;
       }
diff --git a/packages/i18n/locales/en/app.json b/packages/i18n/locales/en/app.json
index 8fe2cc183b..2324b4d85b 100644
--- a/packages/i18n/locales/en/app.json
+++ b/packages/i18n/locales/en/app.json
@@ -7629,6 +7629,7 @@
       "rejected": "Plan rejected — {{id}} returned to Planning for replanning",
       "rejectMessage": "Reject this plan? The specification will be discarded and regenerated.",
       "rejectTitle": "Reject Plan",
+      "releaseAuthorizationHold": "Awaiting release authorization — add the explicit authorization marker to the spec and resubmit.",
       "replanning": "Replanning {{id}}…"
     },
     "pr": {
@@ -8059,6 +8060,7 @@
     "attachedFile": "Attached {{fileName}} to {{taskId}}",
     "attachFileFailed": "Failed to attach {{fileName}}: {{error}}",
     "awaitingApproval": "Awaiting Approval",
+    "awaitingReleaseAuthorization": "Awaiting Release Authorization",
     "baseBranch": "Base",
     "blockedByTooltip": "Blocked by {{taskId}} (file overlap)",
     "branch": "Branch",

From 1d69dec0872c3d2d1ca0baea4dfd2d39b02a8af7 Mon Sep 17 00:00:00 2001
From: gsxdsm <gsxdsm@users.noreply.github.com>
Date: Sat, 4 Jul 2026 22:01:04 -0700
Subject: [PATCH 04/65] FN-7562: fix mobile oversight menu auto-focus opening a
 second native select popup

Fixes the mobile oversight overflow menu rendering two overlapping menus by narrowing auto-focus to actionable button menuitems.

- Change the menu-open auto-focus effect to query `button.detail-oversight-menu-item` instead of matching any `.detail-oversight-menu-item` element, since the native level `<select>` also carried that class and was matched first.
- Programmatically focusing the native `<select>` triggered its OS option picker, which rendered as a second overlapping menu on top of the custom `role="menu"` popover.
- Add regression tests covering: auto-focus landing on the first button menuitem when nudge/stop/explain are available, no fallback focus on the select when oversight is off (level-only state), and confirming the desktop inline select is unaffected.
- Update dashboard-guide.md docs to describe the fixed auto-focus behavior.

Files changed:
 docs/dashboard-guide.md                                                    |  2 +-
 packages/dashboard/app/components/TaskDetailModal.tsx                      |  3 +-
 .../app/components/__tests__/TaskDetailModal.oversight-mobile.test.tsx     | 96 ++++++++++++++++++++++
 3 files changed, 99 insertions(+), 2 deletions(-)

Fusion-Task-Id: FN-7562

Fusion-Task-Lineage: f39068f1-811f-4663-ade1-ff020a389ae5

Co-authored-by: Fusion (runfusion.ai) <noreply@runfusion.ai>
---
 docs/dashboard-guide.md                       |  2 +-
 .../app/components/TaskDetailModal.tsx        |  3 +-
 .../TaskDetailModal.oversight-mobile.test.tsx | 96 +++++++++++++++++++
 3 files changed, 99 insertions(+), 2 deletions(-)

diff --git a/docs/dashboard-guide.md b/docs/dashboard-guide.md
index f0b36d9e02..55afafc73b 100644
--- a/docs/dashboard-guide.md
+++ b/docs/dashboard-guide.md
@@ -201,7 +201,7 @@ Features:
 <!-- FNXC:PlannerOversight 2026-07-04-20:30: FN-7546 clarifies the cluster above — operators reported the buttons were unlabeled and looked inert, with only a hover title explaining why. Adds a visible group label and an always-visible disabled-reason line, and makes Explain always openable since it never mutates anything. -->
 - The FN-7517 controls above carry a visible, non-interactive **`"Overseer controls"` group label** (`data-testid="detail-oversight-controls-label"`) so Nudge/Stop/Explain read as an identifiable cluster rather than unlabeled chips; the label is gated by the same `(hasTaskOversightOverride || workflowOversightResolved) && !oversightIsOff` condition as the buttons, so it never renders an empty shell when oversight is Off/unresolved. When **Nudge** is disabled, an always-visible helper line (`data-testid="detail-overseer-nudge-disabled-reason"`) states the reason in-DOM (mirroring the existing hover `title`) instead of relying on a mouse-hover tooltip alone. **Explain** is read-only and non-mutating, so it is never disabled purely because the overseer is inactive — clicking it always opens/closes the panel, which shows the overseer's live state when watching or an informative "not currently watching this task" message otherwise. Nudge's mutating enablement rule (`canNudgeOverseer`, including the human-control suppression cases) and Stop's confirmation dialog are unchanged.
 <!-- FNXC:PlannerOversight 2026-07-04-19:00: FN-7545 collapses the above controls into a mobile overflow menu below the 768px breakpoint. -->
-- On mobile (viewport ≤ 768px), the level-select/nudge/stop/explain controls above collapse behind a single compact **"Oversight" overflow-menu button** (`data-testid="detail-oversight-menu-trigger"`, `MoreVertical` icon, `aria-haspopup="menu"`) that opens a `role="menu"` popover (mirroring the existing move-action dropdown pattern) listing the same controls as full-width, comfortably tappable `role="menuitem"` entries with the SAME testids and enablement/visibility rules as the desktop inline controls. The trigger itself is withheld entirely when none of those controls would render (no empty-shell overflow button for the oversight-off + overseer-inactive default). Desktop (>768px) keeps the inline cluster unchanged.
+- On mobile (viewport ≤ 768px), the level-select/nudge/stop/explain controls above collapse behind a single compact **"Oversight" overflow-menu button** (`data-testid="detail-oversight-menu-trigger"`, `MoreVertical` icon, `aria-haspopup="menu"`) that opens a `role="menu"` popover (mirroring the existing move-action dropdown pattern) listing the same controls as full-width, comfortably tappable `role="menuitem"` entries with the SAME testids and enablement/visibility rules as the desktop inline controls. The trigger itself is withheld entirely when none of those controls would render (no empty-shell overflow button for the oversight-off + overseer-inactive default). Desktop (>768px) keeps the inline cluster unchanged. Opening the menu presents exactly one surface: menu-open auto-focus lands on the first actionable button menuitem, never the native level `<select>`, so the OS option picker never auto-opens on top of the custom popover (FN-7562).
 <!-- FNXC:PlannerOversight 2026-07-04-18:00: FN-7519 adds a read-only Intervention Timeline immediately below the FN-7517 controls above. -->
 - Below the quick oversight controls, the task detail modal renders an **Intervention Timeline** (`data-testid="planner-intervention-timeline"`) listing every recorded planner-overseer intervention for the task, newest-first: watched stage, reason, action taken, outcome (with a `.status-dot` indicator using semantic outcome tokens), an attempt count/limit badge (only when both are present), and source links (agent log / review comment / failed check / merge error / PR state / generic URL). It renders a calm "No planner interventions yet" empty state rather than an empty shell when there are none, and is hidden entirely (no leftover container) when oversight is off or unresolved for the task. Entries are read via `GET /tasks/:id/overseer/interventions`, which assembles them from the existing run-audit store under the `overseer:intervention` mutation type (`recordPlannerIntervention`/`getPlannerInterventionTimeline` in `@fusion/core`). This is a pure read surface — FN-7520 wires the actual intervention-producing call-sites.
 - 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.
diff --git a/packages/dashboard/app/components/TaskDetailModal.tsx b/packages/dashboard/app/components/TaskDetailModal.tsx
index 04d56d92dd..962f524ea7 100644
--- a/packages/dashboard/app/components/TaskDetailModal.tsx
+++ b/packages/dashboard/app/components/TaskDetailModal.tsx
@@ -3353,12 +3353,13 @@ export function TaskDetailContent({
     firstMenuItem?.focus();
   }, [showMoveMenu]);
 
+  // FNXC:PlannerOversight 2026-07-04-00:00: FN-7562 — auto-focus the first actionable button menuitem, never the native oversight-level <select>; focusing the <select> surfaced its OS picker as a second menu overlapping the custom oversight popover on mobile.
   useEffect(() => {
     if (!showOversightMenu) {
       return;
     }
 
-    const firstMenuItem = oversightMenuRef.current?.querySelector<HTMLButtonElement | HTMLSelectElement>(".detail-oversight-menu-item");
+    const firstMenuItem = oversightMenuRef.current?.querySelector<HTMLButtonElement>("button.detail-oversight-menu-item");
     firstMenuItem?.focus();
   }, [showOversightMenu]);
 
diff --git a/packages/dashboard/app/components/__tests__/TaskDetailModal.oversight-mobile.test.tsx b/packages/dashboard/app/components/__tests__/TaskDetailModal.oversight-mobile.test.tsx
index 8b2c8d36b9..ad14f00d29 100644
--- a/packages/dashboard/app/components/__tests__/TaskDetailModal.oversight-mobile.test.tsx
+++ b/packages/dashboard/app/components/__tests__/TaskDetailModal.oversight-mobile.test.tsx
@@ -384,6 +384,102 @@ describe("TaskDetailModal oversight controls — mobile overflow menu", () => {
     expect(trigger).toHaveAttribute("aria-expanded", "false");
   });
 
+  /*
+  FNXC:PlannerOversight 2026-07-04-00:00:
+  FN-7562 regression coverage — the menu-open auto-focus effect used to
+  select `.detail-oversight-menu-item` generically, which matched the native
+  `<select>` FIRST (it carries that class too) and focused it. Focusing a
+  native `<select>` programmatically surfaces its OS option picker, which
+  rendered as a second menu overlapping the custom `role="menu"` popover.
+  These tests assert the fixed invariant: auto-focus lands on an actionable
+  button menuitem (never the select), and only one `role="menu"` surface is
+  ever present, across both the active-overseer state and the oversight-off
+  (level-only) state.
+  */
+  it("auto-focuses the first button menuitem (never the native select) when nudge/stop/explain are available", async () => {
+    render(
+      <TaskDetailModal
+        task={makeTask({ id: "FN-213", column: "in-progress", plannerOversightLevel: "autonomous", plannerOverseerState: activeSnapshot })}
+        onClose={noop}
+        onMoveTask={noopMove}
+        onDeleteTask={noopDelete}
+        onMergeTask={noopMerge}
+        onOpenDetail={noopOpenDetail}
+        addToast={noop}
+      />,
+    );
+
+    const trigger = await screen.findByTestId("detail-oversight-menu-trigger");
+    fireEvent.click(trigger);
+
+    const select = await screen.findByTestId("detail-oversight-level-select");
+    const nudgeBtn = await screen.findByTestId("detail-overseer-nudge");
+
+    await waitFor(() => {
+      expect(document.activeElement).toBe(nudgeBtn);
+    });
+    expect(document.activeElement).not.toBe(select);
+
+    // Exactly one menu surface renders — the custom popover — and the native
+    // select stays a closed control (jsdom/browsers do not spawn a second
+    // top-level popup unless the element is actually focused).
+    expect(screen.getAllByRole("menu")).toHaveLength(1);
+  });
+
+  it("does not fall back to focusing the native select when oversight is off and only the level control renders", async () => {
+    render(
+      <TaskDetailModal
+        task={makeTask({ id: "FN-214", column: "todo", plannerOversightLevel: "off" })}
+        onClose={noop}
+        onMoveTask={noopMove}
+        onDeleteTask={noopDelete}
+        onMergeTask={noopMerge}
+        onOpenDetail={noopOpenDetail}
+        addToast={noop}
+      />,
+    );
+
+    const trigger = await screen.findByTestId("detail-oversight-menu-trigger");
+    fireEvent.click(trigger);
+
+    const select = await screen.findByTestId("detail-oversight-level-select");
+    // No button menuitem exists in this state (nudge/stop/explain are all
+    // absent), so the auto-focus effect must not fall back to the 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();
+
+    await waitFor(() => {
+      expect(document.activeElement).not.toBe(select);
+    });
+    expect(screen.getAllByRole("menu")).toHaveLength(1);
+  });
+
+  it("desktop inline oversight select is unaffected by the mobile auto-focus fix", async () => {
+    setViewportWidth(DESKTOP_WIDTH);
+
+    render(
+      <TaskDetailModal
+        task={makeTask({ id: "FN-215", column: "in-progress", plannerOversightLevel: "autonomous", plannerOverseerState: activeSnapshot })}
+        onClose={noop}
+        onMoveTask={noopMove}
+        onDeleteTask={noopDelete}
+        onMergeTask={noopMerge}
+        onOpenDetail={noopOpenDetail}
+        addToast={noop}
+      />,
+    );
+
+    // Desktop renders the inline native select directly (no overflow trigger,
+    // no custom popover) — confirm that surface is untouched by this fix.
+    expect(screen.queryByTestId("detail-oversight-menu-trigger")).not.toBeInTheDocument();
+    const select = await screen.findByTestId("detail-oversight-level-select");
+    expect(select).toBeInTheDocument();
+    expect(screen.queryByRole("menu")).not.toBeInTheDocument();
+
+    setViewportWidth(MOBILE_WIDTH);
+  });
+
   it("click-outside closes the menu", async () => {
     render(
       <>

From 9d4a45b0f9fba53ddb08691d0827dc096daa52be Mon Sep 17 00:00:00 2001
From: gsxdsm <gsxdsm@users.noreply.github.com>
Date: Sat, 4 Jul 2026 22:02:59 -0700
Subject: [PATCH 05/65] FN-7561: fix mobile terminal excess inter-character
 spacing after font settle

Root-cause fix for xterm text rendering with wide inter-character gaps on mobile after fonts settle post-load.
- Added forceTerminalFontRemeasure() in terminalPreferences.ts to work around xterm's OptionsService setter being a no-op when reassigning an already-current fontFamily/fontSize
- Applied the remeasure helper at every post-waitForTerminalFontMetrics() settle site in TerminalModal.tsx and SessionTerminal.tsx
- Added regression tests covering the remeasure invariant across SessionTerminal, TerminalModal, and terminalPreferences
- Documented root cause and fix in docs/solutions/ui-bugs/xterm-options-noop-remeasure-after-font-settle.md
- Added changeset for @runfusion/fusion (patch)

Files changed:
 .changeset/fn-7561-mobile-terminal-spacing.md      |   7 +
 docs/solutions/ui-bugs/xterm-options-noop-remeasure-after-font-settle.md | 120 ++++++++++
 packages/dashboard/app/components/SessionTerminal.tsx   |  11 +-
 packages/dashboard/app/components/TerminalModal.tsx     |  11 +-
 packages/dashboard/app/components/__tests__/SessionTerminal.test.tsx  | 108 ++++++++-
 packages/dashboard/app/components/__tests__/TerminalModal.test.tsx    | 257 ++++++++++++++++++++-
 packages/dashboard/app/utils/__tests__/terminalPreferences.test.ts    |  55 +++++
 packages/dashboard/app/utils/terminalPreferences.ts     |  38 +++
 8 files changed, 601 insertions(+), 6 deletions(-)

Fusion-Task-Id: FN-7561

Fusion-Task-Lineage: ad9da396-abf4-46ea-8c60-f2ed40fa4b01

Co-authored-by: Fusion (runfusion.ai) <noreply@runfusion.ai>
---
 .changeset/fn-7561-mobile-terminal-spacing.md |   7 +
 ...ptions-noop-remeasure-after-font-settle.md | 120 ++++++++
 .../app/components/SessionTerminal.tsx        |  11 +-
 .../app/components/TerminalModal.tsx          |  11 +-
 .../__tests__/SessionTerminal.test.tsx        | 108 +++++++-
 .../__tests__/TerminalModal.test.tsx          | 257 +++++++++++++++++-
 .../__tests__/terminalPreferences.test.ts     |  55 ++++
 .../app/utils/terminalPreferences.ts          |  38 +++
 8 files changed, 601 insertions(+), 6 deletions(-)
 create mode 100644 .changeset/fn-7561-mobile-terminal-spacing.md
 create mode 100644 docs/solutions/ui-bugs/xterm-options-noop-remeasure-after-font-settle.md

diff --git a/.changeset/fn-7561-mobile-terminal-spacing.md b/.changeset/fn-7561-mobile-terminal-spacing.md
new file mode 100644
index 0000000000..020bb8c7c0
--- /dev/null
+++ b/.changeset/fn-7561-mobile-terminal-spacing.md
@@ -0,0 +1,7 @@
+---
+"@runfusion/fusion": patch
+---
+
+summary: Fix mobile terminal text still rendering with excess inter-character gaps after font-load settle.
+category: fix
+dev: Root cause: xterm's OptionsService setter is a no-op when reassigning an already-current fontFamily/fontSize, so post-settle reapply never forced CharSizeService/DomRenderer to remeasure. Added `forceTerminalFontRemeasure()` in `terminalPreferences.ts`, used by both `TerminalModal.tsx` and `SessionTerminal.tsx` at every post-`waitForTerminalFontMetrics()` settle site.
diff --git a/docs/solutions/ui-bugs/xterm-options-noop-remeasure-after-font-settle.md b/docs/solutions/ui-bugs/xterm-options-noop-remeasure-after-font-settle.md
new file mode 100644
index 0000000000..dbf4337082
--- /dev/null
+++ b/docs/solutions/ui-bugs/xterm-options-noop-remeasure-after-font-settle.md
@@ -0,0 +1,120 @@
+---
+title: "xterm OptionsService no-op reassignment silently skips post-load remeasure"
+date: 2026-07-04
+category: ui-bugs
+module: packages/dashboard/app/components/TerminalModal
+problem_type: ui_bug
+component: frontend_terminal
+applies_when: "Code reapplies an xterm.js Terminal option (fontFamily, fontSize, etc.) to a value that may already equal the terminal's current option value, expecting that reassignment to force an internal recompute (character measurement, renderer dimensions, letter-spacing compensation)."
+symptoms:
+  - "Mobile terminal text still renders with excessive inter-character spacing on the very first layout even after text-size-adjust is disabled and a document.fonts settle/remeasure step was already added"
+  - "The spacing only 'repairs itself' after an unrelated event: toggling the virtual keyboard, rotating the device, reconnecting the session, or manually changing the font size and changing it back"
+  - "Existing --keyboard-overlap/--vv-height/--vv-width/text-size-adjust: none assertions and a mocked resize(80, 24) all pass while the real-device symptom persists"
+root_cause: xterm_optionsservice_setter_is_a_strict_noop_on_identical_values_so_reassigning_the_same_resolved_font_after_an_async_settle_never_fires_onoptionchange_and_never_forces_charsizeservice_domrenderer_remeasure
+resolution_type: code_fix
+severity: high
+related_components:
+  - packages/dashboard/app/components/TerminalModal.tsx
+  - packages/dashboard/app/components/SessionTerminal.tsx
+  - packages/dashboard/app/utils/terminalPreferences.ts
+  - packages/dashboard/app/components/__tests__/TerminalModal.test.tsx
+  - packages/dashboard/app/components/__tests__/SessionTerminal.test.tsx
+  - packages/dashboard/app/utils/__tests__/terminalPreferences.test.ts
+  - FN-7456
+  - FN-7460
+  - FN-7561
+tags:
+  - xterm
+  - font-loading
+  - options-service
+  - mobile-safari
+  - remeasure
+---
+
+# xterm OptionsService no-op reassignment silently skips post-load remeasure
+
+## Problem
+
+FN-7561 is the third recurrence of "mobile terminal renders with excessive inter-character spacing" after this exact subsystem was touched twice before:
+
+- FN-7456 added the iOS keyboard/viewport baseline and a symbols-free measured font stack (see `xterm-symbols-nerd-font-unicode-range.md`).
+- FN-7460 added `-webkit-text-size-adjust: none` / `text-size-adjust: none` on `.terminal-xterm, .terminal-xterm *` after a real iPhone Safari report showed spacing surviving FN-7456, plus 10px/12px coverage.
+
+Despite both fixes, the real-device symptom persisted. Both prior fixes treated the browser's DOM text-size-adjust/font-boosting behavior as the entire mechanism. It was not.
+
+### The actual mechanism
+
+xterm.js measures character/cell metrics via `CharSizeService`, then `DomRenderer._setDefaultSpacing()` bakes a compensating `letter-spacing` onto `.xterm-rows`:
+
+```ts
+// @xterm/xterm src/browser/renderer/dom/DomRenderer.ts
+private _setDefaultSpacing(): void {
+  // measure same char as in CharSizeService to get the base deviation
+  const spacing = this.dimensions.css.cell.width - this._widthCache.get('W', false, false);
+  this._rowContainer.style.letterSpacing = `${spacing}px`;
+  this._rowFactory.defaultSpacing = spacing;
+}
+```
+
+This recompute only runs from `_handleOptionsChanged()` (wired to `optionsService.onOptionChange`) or from `handleCharSizeChanged()`. Both app terminal surfaces (`TerminalModal.tsx`, `SessionTerminal.tsx`) reapply xterm font options after `waitForTerminalFontMetrics()` (added by FN-7456) settles, expecting that reassignment to force this recompute against the font that only just finished loading. But real xterm's `OptionsService` setter is a strict no-op on an unchanged value:
+
+```ts
+// @xterm/xterm src/common/services/OptionsService.ts
+const setter = (propName: string, value: any): void => {
+  value = this._sanitizeAndValidateOption(propName, value);
+  // Don't fire an option change event if they didn't change
+  if (this.rawOptions[propName] !== value) {
+    this.rawOptions[propName] = value;
+    this._onOptionChange.fire(propName);
+  }
+};
+```
+
+In the common case (the user never touched terminal preferences), the resolved `fontFamily`/`fontSize` after settle are *identical* to what was already applied a few lines earlier at xterm construction/effect setup. Reassigning the same value is therefore a total no-op: no `onOptionChange` fires, `CharSizeService` never remeasures, and `DomRenderer._setDefaultSpacing()` never recomputes the letter-spacing compensation against the now-loaded web font. The stale pre-load cell metrics (measured against a fallback system font before the custom font finished loading) persist as visible excess gaps on the very first mobile layout — exactly matching the report that the terminal "only repairs itself after keyboard toggle/orientation/reconnect": those events happen to force a genuine value change elsewhere in the pipeline (e.g. `handleResize`/`handleDevicePixelRatioChange`), incidentally triggering the missing remeasure.
+
+Both `TerminalModal.tsx` and `SessionTerminal.tsx` had this bug in **two** places each: the initial xterm-init settle path and the live-preferences-apply settle path.
+
+## Why FN-7456/FN-7460 missed this
+
+Both fixes (and their regression tests) only ever asserted the *final* font/size value and CSS text-size-adjust state, never whether a genuine value *transition* occurred inside xterm's internal option pipeline. A plain mock `options: { fontSize: 14 }` object cannot model xterm's no-op-on-unchanged-value contract, so no test could distinguish "the code reassigned the resolved value" (looks correct) from "xterm's internal measurement pipeline actually recomputed" (the real requirement).
+
+## Solution
+
+Force a genuine (distinct-value) transition through xterm's option setter every time font metrics settle, regardless of whether the resolved value already equals the terminal's current option value:
+
+```ts
+// packages/dashboard/app/utils/terminalPreferences.ts
+const TERMINAL_FONT_REMEASURE_SENTINEL_FONT_FAMILY = "monospace";
+
+export function forceTerminalFontRemeasure(
+  terminal: { options: { fontFamily?: string } },
+  fontFamily: string,
+): void {
+  const sentinel =
+    fontFamily === TERMINAL_FONT_REMEASURE_SENTINEL_FONT_FAMILY
+      ? `${TERMINAL_FONT_REMEASURE_SENTINEL_FONT_FAMILY}, monospace`
+      : TERMINAL_FONT_REMEASURE_SENTINEL_FONT_FAMILY;
+  terminal.options.fontFamily = sentinel;
+  terminal.options.fontFamily = fontFamily;
+}
+```
+
+Both assignments run synchronously with no yield in between, so no intermediate frame paints — the terminal never visibly flashes the sentinel font. Both `TerminalModal.tsx` and `SessionTerminal.tsx` now call `forceTerminalFontRemeasure(terminal, resolvedFontFamily)` (instead of a plain `terminal.options.fontFamily = resolvedFontFamily`) at every post-settle site, immediately before reapplying `fontSize` and refitting/resizing/refreshing.
+
+Do not:
+
+- Add a hardcoded `letterSpacing`, fixed cell width, or fixed column count to mask the symptom.
+- Skip the reassignment when the resolved value already matches the current option value — that equality is exactly what causes the bug.
+- Remove or weaken the FN-7456/FN-7460 `text-size-adjust`/font-stack/keyboard-overlap coverage; this fix is additive to those invariants, not a replacement.
+
+## Regression coverage
+
+jsdom cannot exercise real xterm.js internals, so the regression coverage models xterm's documented no-op-on-unchanged-value contract directly on the test double, and asserts the *transition*, not just the final value:
+
+- Wrap the mocked `Terminal.options` object in a real getter/setter pair with the same equality check as `@xterm/xterm`'s `OptionsService` setter, and track a counter that only increments on a genuine (distinct-value) `fontFamily`/`fontSize` transition.
+- Simulate the real recurrence: xterm opens before `document.fonts.load()`/`document.fonts.ready` resolve (deferred promises), the resolved font/size are already applied and unchanged once they settle.
+- Assert the transition counter goes from 0 to a positive count once `waitForTerminalFontMetrics()` settles — this fails pre-fix (a plain reassignment to the same value is a no-op) and passes post-fix (`forceTerminalFontRemeasure` always forces at least one genuine transition).
+- Add a focused unit test for `forceTerminalFontRemeasure()` itself in `terminalPreferences.test.ts`, covering both "resolved value unchanged" and "resolved value genuinely different" cases.
+- Cover both `TerminalModal` (mobile viewport, keyboard-open and keyboard-closed initial render) and `SessionTerminal` (embedded attach surface) — both surfaces independently reapply font options after settle and both had the bug.
+- Run: `pnpm --filter @fusion/dashboard exec vitest run app/components/__tests__/TerminalModal.test.tsx app/components/__tests__/SessionTerminal.test.tsx app/components/__tests__/SessionTerminal.mobile.test.tsx app/__tests__/terminal-input.test.ts app/utils/__tests__/terminalPreferences.test.ts --silent=passed-only --reporter=dot`.
+- Real mobile Safari/Chrome verification remains the strongest signal for this class of bug; if unavailable, record that as an explicit gap rather than treating desktop WebKit/jsdom as proof (see `docs/ios-acceptance.md`).
diff --git a/packages/dashboard/app/components/SessionTerminal.tsx b/packages/dashboard/app/components/SessionTerminal.tsx
index 49d4068085..2acf5783c9 100644
--- a/packages/dashboard/app/components/SessionTerminal.tsx
+++ b/packages/dashboard/app/components/SessionTerminal.tsx
@@ -10,6 +10,7 @@ import { useMobileKeyboard } from "../hooks/useMobileKeyboard";
 import { isMobileViewport, MOBILE_MEDIA_QUERY } from "../hooks/useViewportMode";
 import {
   TERMINAL_PREFERENCES_KEY,
+  forceTerminalFontRemeasure,
   readTerminalPreferences,
   resolveTerminalFontFamily,
   resolveTerminalGlyphFontFamily,
@@ -321,6 +322,9 @@ export function SessionTerminal({
 
     FNXC:Terminal 2026-06-30-22:47:
     Async font-metric waits can resolve out of order when a second terminal preference change lands first. Reapply only if the currently mounted xterm options still match the preference snapshot that scheduled this wait, preserving the latest small-font cell metrics instead of resurrecting stale spacing.
+
+    FNXC:Terminal 2026-07-04-09:40:
+    FN-7561 recurrence #3: when the snapshot already matches (preferences unchanged, the common case), reassigning `fontFamily` to the SAME value is a no-op against real xterm's OptionsService — CharSizeService/DomRenderer never remeasure the web font that only just finished loading. Use `forceTerminalFontRemeasure` so a genuine value transition always occurs on settle.
     */
     void waitForTerminalFontMetrics(terminalPreferences.fontSize, resolvedFontFamily).then(
       (fontMetricsSettled) => {
@@ -332,7 +336,7 @@ export function SessionTerminal({
         ) {
           return;
         }
-        terminal.options.fontFamily = resolvedFontFamily;
+        forceTerminalFontRemeasure(terminal, resolvedFontFamily);
         terminal.options.fontSize = terminalPreferences.fontSize;
         try {
           (fitAddonRef.current as { fit?: () => void } | null)?.fit?.();
@@ -500,8 +504,11 @@ export function SessionTerminal({
           /*
           FNXC:Terminal 2026-06-18-07:15:
           SessionTerminal shares TerminalModal's real-iOS DOM/canvas measurement path and the same user-selectable font presets. FN-6638 ruled out stack ordering with the 66.76px-identical diagnostic, so this attach surface must also reapply font options and refit after best-effort FontFaceSet settlement even when iOS rejects the multi-family shorthand; WebGL desktop remains safe because the same invalidation path refreshes renderer metrics without changing renderer selection.
+
+          FNXC:Terminal 2026-07-04-09:40:
+          FN-7561 recurrence #3: reassigning fontFamily to the SAME already-resolved value is a no-op against real xterm's OptionsService (no onOptionChange fires), so CharSizeService/DomRenderer never remeasure the web font that only just finished loading after xterm's initial pre-load measurement. Force a genuine value transition via `forceTerminalFontRemeasure`.
           */
-          term.options.fontFamily = resolvedFontFamily;
+          forceTerminalFontRemeasure(term, resolvedFontFamily);
           term.options.fontSize = terminalPreferences.fontSize;
           (fitAddon as unknown as { fit: () => void }).fit();
           sendResize(term.cols, term.rows);
diff --git a/packages/dashboard/app/components/TerminalModal.tsx b/packages/dashboard/app/components/TerminalModal.tsx
index a9643efb1d..e6d3fb98b4 100644
--- a/packages/dashboard/app/components/TerminalModal.tsx
+++ b/packages/dashboard/app/components/TerminalModal.tsx
@@ -41,6 +41,7 @@ import {
   MIN_TERMINAL_FONT_SIZE,
   TERMINAL_FONT_FAMILY_PRESETS,
   clampTerminalFontSize,
+  forceTerminalFontRemeasure,
   readTerminalPreferences,
   resolveTerminalFontFamily,
   resolveTerminalGlyphFontFamily,
@@ -1250,8 +1251,11 @@ export function TerminalModal({ isOpen, onClose, initialCommand, initialCommandG
         /*
         FNXC:Terminal 2026-06-18-07:23:
         FN-6638 recurrence #4 showed the previous symbols-last stack-order fix was inert: the supplied diagnostic measured AGENTS.md at the same 66.76px for symbols-first, symbols-last, and system-mono stacks while real iOS Safari still widened ASCII cells. xterm measures cell geometry at open() time, so after best-effort FontFaceSet settlement we must always reapply the active preset's font options, fit, resize, and refresh; that invalidates stale DOM/canvas metrics on real iOS when the full shorthand is rejected and keeps desktop WebGL using the same renderer-neutral metric refresh.
+
+        FNXC:Terminal 2026-07-04-09:35:
+        FN-7561 recurrence #3: reassigning `fontFamily` to the SAME already-resolved value (the common case, since preferences are unchanged) is a no-op against real xterm's OptionsService — no `onOptionChange` fires, so CharSizeService/DomRenderer never remeasure the web font that only just finished loading. Force a genuine value transition via `forceTerminalFontRemeasure` so the character/cell metrics and `_setDefaultSpacing()` letter-spacing compensation are recomputed against the settled font on every settle, not just when the preference itself changed.
         */
-        terminal.options.fontFamily = resolvedFontFamilyRef.current;
+        forceTerminalFontRemeasure(terminal, resolvedFontFamilyRef.current);
         terminal.options.fontSize = fontSizeRef.current;
         fitAddon.fit();
         resizeRef.current?.(terminal.cols, terminal.rows);
@@ -1776,6 +1780,9 @@ export function TerminalModal({ isOpen, onClose, initialCommand, initialCommandG
     /*
     FNXC:Terminal 2026-06-30-13:18:
     The mobile screenshot recurrence happens at the visible 10px setting with the soft keyboard already open. A live font-size preference change must wait for the symbols-free measured stack to settle, then reapply xterm font options, refit, resize, and refresh; otherwise canvas/DOM metrics can keep the old wider cells until an unfold/orientation event forces a later measurement.
+
+    FNXC:Terminal 2026-07-04-09:35:
+    FN-7561 recurrence #3: the two equality checks below only guard against a STALE out-of-order settle (a newer preference change landed first); when the values already match the current snapshot (the common initial-load case: preferences did not actually change) a plain reassignment is a no-op against real xterm's OptionsService, so CharSizeService/DomRenderer never remeasure the font that just finished loading. Use `forceTerminalFontRemeasure` so a genuine value transition always occurs on settle, regardless of whether the resolved value already equals the terminal's current option value.
     */
     void waitForTerminalFontMetrics(terminalPreferences.fontSize, resolvedFontFamily).then(
       (fontMetricsSettled) => {
@@ -1788,7 +1795,7 @@ export function TerminalModal({ isOpen, onClose, initialCommand, initialCommandG
         ) {
           return;
         }
-        xtermRef.current.options.fontFamily = resolvedFontFamily;
+        forceTerminalFontRemeasure(xtermRef.current, resolvedFontFamily);
         xtermRef.current.options.fontSize = terminalPreferences.fontSize;
         scheduleRefit();
       },
diff --git a/packages/dashboard/app/components/__tests__/SessionTerminal.test.tsx b/packages/dashboard/app/components/__tests__/SessionTerminal.test.tsx
index 4aaa157941..616330e24e 100644
--- a/packages/dashboard/app/components/__tests__/SessionTerminal.test.tsx
+++ b/packages/dashboard/app/components/__tests__/SessionTerminal.test.tsx
@@ -4,6 +4,48 @@ import { act, render, screen, fireEvent, waitFor } from "@testing-library/react"
 // ── Mock xterm + addon dynamic imports (jsdom has no canvas/WebGL) ──────────
 const mockFitAddon = { fit: vi.fn() };
 let sessionKeyEventHandler: ((event: KeyboardEvent) => boolean) | null = null;
+
+/*
+FNXC:Terminal 2026-07-04-09:45:
+Real xterm.js's OptionsService setter is a strict no-op (no onOptionChange
+fires, so CharSizeService/DomRenderer never remeasure) whenever a caller
+reassigns an option to a value that already equals the option's current value.
+The previous plain `{ ...options }` spread on construction could not model this
+no-op-on-unchanged-value behavior, letting FN-7561's recurrence (reassigning
+the SAME resolved font after an async web-font settle never forces a genuine
+remeasure) go uncaught. Track a `fontRemeasureCount` that only increments on a
+genuine (distinct-value) fontFamily/fontSize transition.
+*/
+let fontRemeasureCount = 0;
+function resetFontRemeasureCount(): void {
+  fontRemeasureCount = 0;
+}
+function getFontRemeasureCount(): number {
+  return fontRemeasureCount;
+}
+function wrapMockTerminalOptions(initial: Record<string, unknown>): Record<string, unknown> {
+  const store: Record<string, unknown> = { ...initial };
+  const options: Record<string, unknown> = {};
+  for (const key of Object.keys(store)) {
+    Object.defineProperty(options, key, {
+      enumerable: true,
+      configurable: true,
+      get(): unknown {
+        return store[key];
+      },
+      set(value: unknown): void {
+        if (store[key] !== value) {
+          store[key] = value;
+          if (key === "fontFamily" || key === "fontSize") {
+            fontRemeasureCount += 1;
+          }
+        }
+      },
+    });
+  }
+  return options;
+}
+
 const mockTerm = {
   loadAddon: vi.fn(),
   open: vi.fn(),
@@ -21,7 +63,12 @@ const mockTerm = {
   cols: 80,
   rows: 24,
 };
-vi.mock("@xterm/xterm", () => ({ Terminal: vi.fn(function Terminal(options) { mockTerm.options = { ...options }; return mockTerm; }) }));
+vi.mock("@xterm/xterm", () => ({
+  Terminal: vi.fn(function Terminal(options) {
+    mockTerm.options = wrapMockTerminalOptions(options as Record<string, unknown>);
+    return mockTerm;
+  }),
+}));
 vi.mock("@xterm/addon-fit", () => ({ FitAddon: vi.fn(function FitAddon() { return mockFitAddon; }) }));
 vi.mock("@xterm/addon-unicode11", () => ({ Unicode11Addon: vi.fn(function Unicode11Addon() { return {}; }) }));
 vi.mock("@xterm/addon-webgl", () => ({
@@ -103,6 +150,7 @@ beforeEach(() => {
   mockTerm.refresh.mockClear();
   mockTerm.dispose.mockClear();
   mockTerm.options = {};
+  resetFontRemeasureCount();
   Object.defineProperty(document, "fonts", {
     value: undefined,
     configurable: true,
@@ -314,6 +362,64 @@ describe("SessionTerminal", () => {
     });
   });
 
+  /*
+  FNXC:Terminal 2026-07-04-09:50:
+  FN-7561 recurrence #3 root cause: reassigning `terminal.options.fontFamily`/`fontSize`
+  to the SAME already-resolved value (the common case, since preferences are
+  unchanged) is a no-op against real xterm's OptionsService — no `onOptionChange`
+  fires, so CharSizeService/DomRenderer never remeasure the web font that only
+  just finished loading after xterm's initial pre-load measurement. This proves
+  SessionTerminal forces a genuine value transition on settle too, not just
+  TerminalModal.
+  */
+  it("forces a genuine xterm character-metric remeasure after the mobile web font settles later than xterm's initial measurement", async () => {
+    let resolveLoad: (() => void) | undefined;
+    let resolveReady: (() => void) | undefined;
+    const load = vi.fn(
+      () =>
+        new Promise<void>((resolve) => {
+          resolveLoad = resolve;
+        }),
+    );
+    Object.defineProperty(document, "fonts", {
+      value: {
+        load,
+        ready: new Promise<void>((resolve) => {
+          resolveReady = resolve;
+        }),
+      },
+      configurable: true,
+    });
+
+    render(<SessionTerminal sessionId="s1" />);
+
+    await waitFor(() => {
+      expect(FakeWS.instances.length).toBe(1);
+      expect(load).toHaveBeenCalled();
+    });
+    expectMeasurementSafeFontStack(mockTerm.options.fontFamily as string);
+
+    // Isolate exactly what happens once the deferred font-load settles; the
+    // resolved fontFamily/fontSize never actually changed (the user never
+    // touched terminal preferences), so this must be a forced remeasure, not
+    // an incidental preference-driven one.
+    resetFontRemeasureCount();
+
+    await act(async () => {
+      resolveLoad?.();
+      resolveReady?.();
+      await Promise.resolve();
+      await Promise.resolve();
+    });
+
+    await waitFor(() => {
+      expect(getFontRemeasureCount()).toBeGreaterThan(0);
+    });
+
+    expectMeasurementSafeFontStack(mockTerm.options.fontFamily as string);
+    expect(mockTerm.options.fontFamily).toBe(resolveTerminalFontFamily("nerd-font"));
+  });
+
   it("applies validated terminal preferences at xterm init", async () => {
     const { Terminal } = await import("@xterm/xterm");
     window.localStorage.setItem(
diff --git a/packages/dashboard/app/components/__tests__/TerminalModal.test.tsx b/packages/dashboard/app/components/__tests__/TerminalModal.test.tsx
index d913d1428c..321091101e 100644
--- a/packages/dashboard/app/components/__tests__/TerminalModal.test.tsx
+++ b/packages/dashboard/app/components/__tests__/TerminalModal.test.tsx
@@ -65,6 +65,55 @@ const mockFitAddonFit = vi.fn();
 let terminalKeyEventHandler: ((event: KeyboardEvent) => boolean) | null = null;
 let terminalDataHandler: ((data: string) => void) | null = null;
 
+/*
+FNXC:Terminal 2026-07-04-09:15:
+Real xterm.js's OptionsService setter is a strict no-op (no onOptionChange fires,
+so CharSizeService/DomRenderer never remeasure) whenever a caller reassigns an
+option to a value that already equals the option's current value — see
+`@xterm/xterm` `common/services/OptionsService.ts` `setter()`. The plain object
+literal previously used for `mockTerminalInstance.options` could not model this
+no-op-on-unchanged-value behavior, which is why prior FN-7456/FN-7460 coverage
+could pass while the real recurrence (reassigning the SAME resolved font after
+an async web-font settle never forces a genuine remeasure) stayed uncaught.
+Track a `fontRemeasureCount` that only increments on a genuine (distinct-value)
+fontFamily/fontSize transition so tests can assert xterm's measurement pipeline
+was actually forced to recompute, not merely reassigned to an identical value.
+*/
+let fontRemeasureCount = 0;
+function resetFontRemeasureCount(): void {
+  fontRemeasureCount = 0;
+}
+function getFontRemeasureCount(): number {
+  return fontRemeasureCount;
+}
+function createMockTerminalOptions(): Record<string, unknown> {
+  const store: Record<string, unknown> = {
+    fontSize: 14,
+    fontFamily: undefined,
+    cursorStyle: undefined,
+    cursorBlink: undefined,
+  };
+  const options: Record<string, unknown> = {};
+  for (const key of Object.keys(store)) {
+    Object.defineProperty(options, key, {
+      enumerable: true,
+      configurable: true,
+      get(): unknown {
+        return store[key];
+      },
+      set(value: unknown): void {
+        if (store[key] !== value) {
+          store[key] = value;
+          if (key === "fontFamily" || key === "fontSize") {
+            fontRemeasureCount += 1;
+          }
+        }
+      },
+    });
+  }
+  return options;
+}
+
 const mockTerminalInstance = {
   loadAddon: vi.fn(),
   open: vi.fn(),
@@ -83,7 +132,7 @@ const mockTerminalInstance = {
   clear: vi.fn(),
   focus: vi.fn(),
   refresh: vi.fn(),
-  options: { fontSize: 14 },
+  options: createMockTerminalOptions(),
   cols: 80,
   rows: 24,
 };
@@ -236,6 +285,7 @@ describe("TerminalModal", () => {
     mockTerminalInstance.options.fontSize = 14;
     mockTerminalInstance.options.cursorStyle = "block";
     mockTerminalInstance.options.cursorBlink = true;
+    resetFontRemeasureCount();
     mockCreateTerminalSession.mockResolvedValue({
       sessionId: "test-session-123",
       shell: "/bin/bash",
@@ -6796,3 +6846,208 @@ describe("TerminalModal — project-context propagation (FN-1765)", () => {
     });
   });
 });
+
+/*
+FNXC:Terminal 2026-07-04-09:20:
+FN-7561 root cause: after FN-7456/FN-7460 disabled `text-size-adjust` and waited
+for `document.fonts.ready`, both the initial xterm-init settle path and the live
+preferences-apply settle path reapply `terminal.options.fontFamily`/`fontSize`
+by assigning the ALREADY-RESOLVED value back onto the option. Real xterm's
+OptionsService setter is a no-op when the new value strictly equals the current
+value (no `onOptionChange` fires), so CharSizeService's canvas/DOM character
+measurement and DomRenderer's `_setDefaultSpacing()` letter-spacing compensation
+are never actually recomputed against the web font that only finished loading
+AFTER xterm's initial (pre-load, fallback-font) measurement. The stale
+pre-load cell metrics + compensation persist as visible excess inter-character
+gaps until an unrelated event (resize/orientation/DPR change) happens to force
+a genuine value change. This suite proves the app now forces a genuine
+value-changing remeasure every time font metrics settle, not just a same-value
+reassignment.
+*/
+describe("TerminalModal — FN-7561 mobile inter-character spacing (xterm no-op remeasure)", () => {
+  const mockOnClose = vi.fn();
+  const mockSendInput = vi.fn();
+  const mockResize = vi.fn();
+  const mockReconnect = vi.fn();
+
+  const createMockTerminalState = (overrides = {}) => ({
+    connectionStatus: "connected" as const,
+    sendInput: mockSendInput,
+    resize: mockResize,
+    onData: vi.fn(() => vi.fn()),
+    onExit: vi.fn(() => vi.fn()),
+    onConnect: vi.fn(() => vi.fn()),
+    onScrollback: vi.fn(() => vi.fn()),
+    reconnect: mockReconnect,
+    onSessionInvalid: vi.fn(() => vi.fn()),
+    ...overrides,
+  });
+
+  let previousInnerWidth: number;
+  let previousOntouchstart: unknown;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    resetFontRemeasureCount();
+    vi.spyOn(window, "matchMedia").mockImplementation((query: string) => ({
+      matches: false,
+      media: query,
+      onchange: null,
+      addListener: vi.fn(),
+      removeListener: vi.fn(),
+      addEventListener: vi.fn(),
+      removeEventListener: vi.fn(),
+      dispatchEvent: vi.fn(),
+    }));
+    previousInnerWidth = window.innerWidth;
+    previousOntouchstart = window.ontouchstart;
+    // Real reported device: a narrow touch-primary mobile viewport.
+    Object.defineProperty(window, "innerWidth", { value: 390, configurable: true });
+    Object.defineProperty(window, "ontouchstart", { value: null, configurable: true });
+    mockTerminalInstance.options.fontFamily = XTERM_FONT_FAMILY;
+    mockTerminalInstance.options.fontSize = 12;
+    mockTerminalInstance.options.cursorStyle = "block";
+    mockTerminalInstance.options.cursorBlink = true;
+    resetFontRemeasureCount();
+    mockUseTerminal.mockReturnValue(createMockTerminalState());
+    mockUseTerminalSessions.mockReturnValue(defaultSessionState);
+    mockUseWorkspaces.mockReturnValue({
+      projectName: "kb",
+      workspaces: [],
+      loading: false,
+      error: null,
+    });
+    mockCreateTerminalSession.mockResolvedValue({
+      sessionId: "test-session-123",
+      shell: "/bin/bash",
+      cwd: "/project",
+    });
+  });
+
+  afterEach(() => {
+    Object.defineProperty(window, "innerWidth", { value: previousInnerWidth, configurable: true });
+    if (previousOntouchstart === undefined) {
+      delete (window as unknown as { ontouchstart?: unknown }).ontouchstart;
+    } else {
+      Object.defineProperty(window, "ontouchstart", { value: previousOntouchstart, configurable: true });
+    }
+    vi.useRealTimers();
+    vi.restoreAllMocks();
+  });
+
+  it("forces a genuine xterm character-metric remeasure after the mobile web font settles later than xterm's initial measurement", async () => {
+    // Model the font not being ready yet at xterm construction (the real
+    // recurrence: the custom web font loads asynchronously, AFTER xterm's
+    // initial fallback-font character measurement), then settling shortly
+    // after. `waitForTerminalFontMetrics` awaits exactly this `load`/`ready`
+    // pair before reapplying font options.
+    let resolveLoad: (() => void) | undefined;
+    let resolveReady: (() => void) | undefined;
+    const load = vi.fn(
+      () =>
+        new Promise<void>((resolve) => {
+          resolveLoad = resolve;
+        }),
+    );
+    Object.defineProperty(document, "fonts", {
+      value: {
+        load,
+        ready: new Promise<void>((resolve) => {
+          resolveReady = resolve;
+        }),
+      },
+      configurable: true,
+    });
+
+    render(<TerminalModal isOpen={true} onClose={mockOnClose} />);
+
+    await waitFor(() => expect(mockTerminalInstance.open).toHaveBeenCalled());
+    expectMeasurementSafeFontStack(mockTerminalInstance.options.fontFamily as string);
+
+    // Nothing else has changed the resolved font/size at this point, so any
+    // remeasure count observed so far merely reflects the initial synchronous
+    // application done during xterm construction/effect setup — reset it and
+    // isolate exactly what happens once the deferred font-load settles.
+    resetFontRemeasureCount();
+
+    await act(async () => {
+      resolveLoad?.();
+      resolveReady?.();
+      await Promise.resolve();
+      await Promise.resolve();
+    });
+
+    // The resolved fontFamily/fontSize the app wants after settle is identical
+    // to what was already applied before the font finished loading (the user
+    // never touched terminal preferences). A naive "reassign the resolved
+    // value" is therefore a no-op against real xterm's OptionsService
+    // (identical-value assignments never fire onOptionChange), so
+    // CharSizeService/DomRenderer would silently keep stale pre-load cell
+    // metrics forever. The fix must force at least one genuine (distinct
+    // value) fontFamily/fontSize transition here so xterm actually
+    // remeasures against the now-loaded font — this is the invariant
+    // FN-7456/FN-7460's `text-size-adjust`/`--keyboard-overlap`/`--vv-height`
+    // assertions never covered.
+    await waitFor(() => {
+      expect(getFontRemeasureCount()).toBeGreaterThan(0);
+    });
+
+    // The terminal must still land on the correct, symbols-free, resolved
+    // font after the forced remeasure settles.
+    expectMeasurementSafeFontStack(mockTerminalInstance.options.fontFamily as string);
+    expect(mockTerminalInstance.options.fontFamily).toBe(XTERM_FONT_FAMILY);
+  });
+
+  it("also forces the remeasure when the mobile keyboard is already open at initial render", async () => {
+    const mockVV = {
+      width: 375,
+      height: 300,
+      offsetTop: 0,
+      offsetLeft: 0,
+      addEventListener: vi.fn(),
+      removeEventListener: vi.fn(),
+    };
+    Object.defineProperty(window, "visualViewport", {
+      value: mockVV,
+      writable: true,
+      configurable: true,
+    });
+    Object.defineProperty(window, "innerHeight", { value: 300, writable: true, configurable: true });
+
+    let resolveLoad: (() => void) | undefined;
+    let resolveReady: (() => void) | undefined;
+    Object.defineProperty(document, "fonts", {
+      value: {
+        load: vi.fn(
+          () =>
+            new Promise<void>((resolve) => {
+              resolveLoad = resolve;
+            }),
+        ),
+        ready: new Promise<void>((resolve) => {
+          resolveReady = resolve;
+        }),
+      },
+      configurable: true,
+    });
+
+    render(<TerminalModal isOpen={true} onClose={mockOnClose} />);
+
+    await waitFor(() => expect(mockTerminalInstance.open).toHaveBeenCalled());
+    resetFontRemeasureCount();
+
+    await act(async () => {
+      resolveLoad?.();
+      resolveReady?.();
+      await Promise.resolve();
+      await Promise.resolve();
+    });
+
+    await waitFor(() => {
+      expect(getFontRemeasureCount()).toBeGreaterThan(0);
+    });
+    expectMeasurementSafeFontStack(mockTerminalInstance.options.fontFamily as string);
+
+    Object.defineProperty(window, "visualViewport", { value: undefined, writable: true, configurable: true });
+  });
+});
diff --git a/packages/dashboard/app/utils/__tests__/terminalPreferences.test.ts b/packages/dashboard/app/utils/__tests__/terminalPreferences.test.ts
index 31a0f83a05..70431c3b95 100644
--- a/packages/dashboard/app/utils/__tests__/terminalPreferences.test.ts
+++ b/packages/dashboard/app/utils/__tests__/terminalPreferences.test.ts
@@ -4,6 +4,7 @@ import {
   LEGACY_TERMINAL_FONT_SIZE_KEY,
   TERMINAL_PREFERENCES_KEY,
   XTERM_FONT_FAMILY,
+  forceTerminalFontRemeasure,
   readTerminalPreferences,
   waitForTerminalFontMetrics,
   writeTerminalPreferences,
@@ -114,4 +115,58 @@ describe("terminalPreferences", () => {
     expect(load).not.toHaveBeenCalledWith("12px \"Fusion Terminal Nerd Font Symbols\"");
     expect(readyAwaited).toBe(true);
   });
+
+  /*
+  FNXC:Terminal 2026-07-04-09:55:
+  FN-7561 root cause: xterm's real OptionsService setter is a no-op when a
+  caller reassigns an option to its already-current value, so simply
+  reassigning the resolved fontFamily after a web font settles never forces
+  xterm's internal CharSizeService/DomRenderer remeasure. Model that exact
+  no-op-on-unchanged-value contract and assert `forceTerminalFontRemeasure`
+  always produces at least one genuine (distinct-value) transition, even when
+  the resolved value already equals the terminal's current option value.
+  */
+  describe("forceTerminalFontRemeasure", () => {
+    function createXtermLikeOptions(initialFontFamily: string) {
+      let current = initialFontFamily;
+      let changeCount = 0;
+      const terminal = {
+        options: {
+          get fontFamily(): string {
+            return current;
+          },
+          set fontFamily(value: string) {
+            if (value !== current) {
+              current = value;
+              changeCount += 1;
+            }
+          },
+        },
+      };
+      return { terminal, getChangeCount: () => changeCount };
+    }
+
+    it("forces a genuine value transition even when the resolved value already matches the current option", () => {
+      const { terminal, getChangeCount } = createXtermLikeOptions(XTERM_FONT_FAMILY);
+
+      // A naive reassignment to the identical value would be a no-op against
+      // real xterm and is what let FN-7561 recur; assert the baseline first.
+      terminal.options.fontFamily = XTERM_FONT_FAMILY;
+      expect(getChangeCount()).toBe(0);
+
+      forceTerminalFontRemeasure(terminal, XTERM_FONT_FAMILY);
+
+      expect(getChangeCount()).toBeGreaterThan(0);
+      expect(terminal.options.fontFamily).toBe(XTERM_FONT_FAMILY);
+    });
+
+    it("lands on a genuinely different resolved value too", () => {
+      const { terminal, getChangeCount } = createXtermLikeOptions(XTERM_FONT_FAMILY);
+
+      forceTerminalFontRemeasure(terminal, "system-mono, monospace");
+
+      expect(getChangeCount()).toBeGreaterThan(0);
+      expect(terminal.options.fontFamily).toBe("system-mono, monospace");
+    });
+  });
 });
diff --git a/packages/dashboard/app/utils/terminalPreferences.ts b/packages/dashboard/app/utils/terminalPreferences.ts
index dc6c62b3f7..a97d5a2ba8 100644
--- a/packages/dashboard/app/utils/terminalPreferences.ts
+++ b/packages/dashboard/app/utils/terminalPreferences.ts
@@ -193,6 +193,44 @@ export async function waitForTerminalFontMetrics(
   return true;
 }
 
+/*
+FNXC:Terminal 2026-07-04-09:30:
+FN-7561 (recurrence #3 of mobile inter-character spacing, after FN-7456's DOM
+glyph-fallback fix and FN-7460's `text-size-adjust: none`) root cause: real
+xterm.js's `OptionsService` setter is a strict no-op when a caller reassigns an
+option to a value that already strictly-equals its current value (no
+`onOptionChange` fires — see `@xterm/xterm` `common/services/OptionsService.ts`).
+Both terminal surfaces reapply `terminal.options.fontFamily`/`fontSize` with the
+SAME already-resolved value once `waitForTerminalFontMetrics()` settles, which is
+the common case (the user never touched terminal preferences). That reassignment
+never fires `onOptionChange`, so xterm's `CharSizeService` (canvas/DOM character
+measurement) and `DomRenderer._setDefaultSpacing()` (the letter-spacing
+compensation baked onto `.xterm-rows`) never recompute against the web font that
+finished loading AFTER xterm's initial pre-load (fallback-font) measurement. The
+stale pre-load cell metrics + compensation persist as visible excess
+inter-character gaps on the very first mobile layout until an unrelated event
+(resize/orientation/DPR change) happens to produce a genuine value change and
+incidentally force a real remeasure — exactly the "only repairs itself after
+keyboard toggle/orientation/reconnect" symptom reported for this recurrence.
+Force a genuine (distinct-value) transition through a sentinel font family
+before landing back on the resolved value so xterm's internal remeasure
+pipeline always runs at least once against the now-settled font, regardless of
+whether the resolved value already matches the terminal's current option value.
+*/
+const TERMINAL_FONT_REMEASURE_SENTINEL_FONT_FAMILY = "monospace";
+
+export function forceTerminalFontRemeasure(
+  terminal: { options: { fontFamily?: string } },
+  fontFamily: string,
+): void {
+  const sentinel =
+    fontFamily === TERMINAL_FONT_REMEASURE_SENTINEL_FONT_FAMILY
+      ? `${TERMINAL_FONT_REMEASURE_SENTINEL_FONT_FAMILY}, monospace`
+      : TERMINAL_FONT_REMEASURE_SENTINEL_FONT_FAMILY;
+  terminal.options.fontFamily = sentinel;
+  terminal.options.fontFamily = fontFamily;
+}
+
 function isObject(value: unknown): value is Record<string, unknown> {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }

From c08498efc62b1c855117d44333bc603c7dd7bbf3 Mon Sep 17 00:00:00 2001
From: gsxdsm <gsxdsm@users.noreply.github.com>
Date: Sat, 4 Jul 2026 22:05:49 -0700
Subject: [PATCH 06/65] FN-7563: explain the planner-overseer
 awaiting-confirmation badge

Replace the raw kebab-case planner-overseer badge state and bare tooltip with a human-readable label and an explanatory tooltip built from the existing runtime snapshot.

- Add packages/dashboard/app/components/plannerOverseerBadge.ts: pure, type-only helper exposing plannerOverseerStateLabel() and plannerOverseerBadgeTooltip(), composing the tooltip from reason/watchedStage/signal/pendingConfirmation with graceful fallbacks
- Re-export PlannerOverseerState and PlannerOverseerRuntimeSnapshot as type-only from packages/core/src/types.ts so the dashboard's @fusion/core vite alias can resolve them
- Update TaskCard.tsx to render the new label/tooltip instead of the raw state string
- Add unit tests for the new badge helper and extend TaskCard tests for the updated label/tooltip behavior
- Add a patch changeset documenting the operator-facing fix

Files changed:
 .changeset/fn-7563-overseer-badge-explanation.md   |   7 ++
 packages/core/src/types.ts                         |   7 ++
 packages/dashboard/app/components/TaskCard.tsx     |   7 +-
 .../app/components/__tests__/TaskCard.test.tsx     |  72 ++++++++++++++
 .../__tests__/plannerOverseerBadge.test.ts         | 103 ++++++++++++++++++++
 .../app/components/plannerOverseerBadge.ts         | 104 +++++++++++++++++++++
 6 files changed, 296 insertions(+), 4 deletions(-)

Fusion-Task-Id: FN-7563

Fusion-Task-Lineage: 64ed011b-5486-4272-abd1-a6123c60785f

Co-authored-by: Fusion (runfusion.ai) <noreply@runfusion.ai>
---
 .../fn-7563-overseer-badge-explanation.md     |   7 ++
 packages/core/src/types.ts                    |   7 ++
 .../dashboard/app/components/TaskCard.tsx     |   7 +-
 .../components/__tests__/TaskCard.test.tsx    |  72 ++++++++++++
 .../__tests__/plannerOverseerBadge.test.ts    | 103 +++++++++++++++++
 .../app/components/plannerOverseerBadge.ts    | 104 ++++++++++++++++++
 6 files changed, 296 insertions(+), 4 deletions(-)
 create mode 100644 .changeset/fn-7563-overseer-badge-explanation.md
 create mode 100644 packages/dashboard/app/components/__tests__/plannerOverseerBadge.test.ts
 create mode 100644 packages/dashboard/app/components/plannerOverseerBadge.ts

diff --git a/.changeset/fn-7563-overseer-badge-explanation.md b/.changeset/fn-7563-overseer-badge-explanation.md
new file mode 100644
index 0000000000..31b019ecfe
--- /dev/null
+++ b/.changeset/fn-7563-overseer-badge-explanation.md
@@ -0,0 +1,7 @@
+---
+"@runfusion/fusion": patch
+---
+
+summary: Planner-overseer task badge now shows a readable label and explains what it is waiting on.
+category: fix
+dev: TaskCard badge renders plannerOverseerStateLabel + plannerOverseerBadgeTooltip built from the existing PlannerOverseerRuntimeSnapshot (reason/watchedStage/signal/pendingConfirmation); presentation-only, no engine changes.
diff --git a/packages/core/src/types.ts b/packages/core/src/types.ts
index ce51edb2a7..2b5a47a26f 100644
--- a/packages/core/src/types.ts
+++ b/packages/core/src/types.ts
@@ -1,5 +1,12 @@
 import type { InReviewStallSignal } from "./in-review-stall.js";
 import type { PlannerOverseerRuntimeSnapshot } from "./planner-overseer-state.js";
+// FNXC:PlannerOversight 2026-07-04-18:00: FN-7563 needs `PlannerOverseerState`/
+// `PlannerOverseerRuntimeSnapshot` as TYPE-ONLY imports in the dashboard's pure
+// `plannerOverseerBadge.ts` helper. The dashboard's vite alias for "@fusion/core"
+// resolves only to this file (types.ts), not the package barrel, so the types must
+// be re-exported here (type-only — no engine/runtime code crosses into the browser
+// bundle) rather than requiring dashboard code to import the source module path.
+export type { PlannerOverseerState, PlannerOverseerRuntimeSnapshot } from "./planner-overseer-state.js";
 import type { ModelPricing } from "./model-pricing.js";
 import type { InReviewStalledSignal } from "./in-review-stalled.js";
 import type { StalePausedReviewSignal } from "./stale-paused-review.js";
diff --git a/packages/dashboard/app/components/TaskCard.tsx b/packages/dashboard/app/components/TaskCard.tsx
index aca0b43de0..03d0e9be82 100644
--- a/packages/dashboard/app/components/TaskCard.tsx
+++ b/packages/dashboard/app/components/TaskCard.tsx
@@ -28,6 +28,7 @@ import { ProviderIcon } from "./ProviderIcon";
 import { PluginSlot } from "./PluginSlot";
 import { useBadgeWebSocket } from "../hooks/useBadgeWebSocket";
 import { useCoarsePointer } from "../hooks/useCoarsePointer";
+import { plannerOverseerBadgeTooltip, plannerOverseerStateLabel } from "./plannerOverseerBadge";
 import { getFreshBatchData } from "../hooks/useBatchBadgeFetch";
 import { useTaskDiffStats } from "../hooks/useTaskDiffStats";
 import { useAgentsMapCache } from "../hooks/useAgentsMapCache";
@@ -2774,13 +2775,11 @@ function TaskCardComponent({
         {task.plannerOverseerState && task.plannerOverseerState.state !== "idle" && (
           <span
             className="card-status-badge card-planner-overseer-state"
-            title={t("tasks.plannerOverseerStateTitle", "Planner overseer: {{state}}", {
-              state: task.plannerOverseerState.state,
-            })}
+            title={plannerOverseerBadgeTooltip(task.plannerOverseerState, t)}
             data-testid="planner-overseer-state-badge"
             data-planner-overseer-state={task.plannerOverseerState.state}
           >
-            {task.plannerOverseerState.state}
+            {plannerOverseerStateLabel(task.plannerOverseerState.state, t)}
           </span>
         )}
         {showStalledReview && stalledReview && (
diff --git a/packages/dashboard/app/components/__tests__/TaskCard.test.tsx b/packages/dashboard/app/components/__tests__/TaskCard.test.tsx
index a485b3d23b..01e6b965cd 100644
--- a/packages/dashboard/app/components/__tests__/TaskCard.test.tsx
+++ b/packages/dashboard/app/components/__tests__/TaskCard.test.tsx
@@ -295,6 +295,78 @@ describe("TaskCard", () => {
     expect(screen.getByTestId("planner-overseer-state-badge")).toBeInTheDocument();
   });
 
+  // FN-7563: the badge used to print the raw kebab-case state (e.g.
+  // "awaiting-confirmation") with a bare "Planner overseer: awaiting-confirmation"
+  // tooltip. This reproduces the reported in-review symptom and asserts the badge
+  // is now human-readable and self-explanatory.
+  it("explains an in-review awaiting-confirmation badge with a readable label and a reason-bearing tooltip", () => {
+    const task = makeTask({
+      column: "in-review",
+      plannerOverseerState: {
+        state: "awaiting-confirmation",
+        oversightLevel: "autonomous",
+        watchedStage: "executor",
+        signal: "stalled",
+        attemptCount: 2,
+        attemptLimit: 3,
+        pendingConfirmation: true,
+        observedAt: 1700000000000,
+        reason: "Retry limit reached; waiting for an operator decision",
+      },
+    });
+
+    render(<TaskCard task={task} onOpenDetail={noop} addToast={noop} />);
+
+    const badge = screen.getByTestId("planner-overseer-state-badge");
+    expect(badge.textContent).not.toBe("awaiting-confirmation");
+    expect(badge.textContent).toBe("Awaiting confirmation");
+
+    const title = badge.getAttribute("title") ?? "";
+    expect(title).not.toBe("Planner overseer: awaiting-confirmation");
+    expect(title).toContain("Retry limit reached; waiting for an operator decision");
+    expect(title).toMatch(/human decision/i);
+    expect(title).not.toMatch(/undefined/);
+  });
+
+  it("renders readable labels for in-progress watching and recovering overseer states", () => {
+    const watchingTask = makeTask({
+      column: "in-progress",
+      plannerOverseerState: {
+        state: "watching",
+        oversightLevel: "autonomous",
+        watchedStage: "executor",
+        signal: "progressing",
+        attemptCount: 0,
+        attemptLimit: 3,
+        pendingConfirmation: false,
+        observedAt: 1700000000000,
+      },
+    });
+    const { unmount } = render(<TaskCard task={watchingTask} onOpenDetail={noop} addToast={noop} />);
+    let badge = screen.getByTestId("planner-overseer-state-badge");
+    expect(badge.textContent).toBe("Overseer watching");
+    expect(badge.getAttribute("title")).not.toMatch(/undefined/);
+    unmount();
+
+    const recoveringTask = makeTask({
+      column: "in-progress",
+      plannerOverseerState: {
+        state: "recovering",
+        oversightLevel: "autonomous",
+        attemptCount: 1,
+        attemptLimit: 3,
+        pendingConfirmation: false,
+        observedAt: 1700000000000,
+      },
+    });
+    render(<TaskCard task={recoveringTask} onOpenDetail={noop} addToast={noop} />);
+    badge = screen.getByTestId("planner-overseer-state-badge");
+    expect(badge.textContent).toBe("Overseer recovering");
+    const title = badge.getAttribute("title") ?? "";
+    expect(title).not.toMatch(/undefined/);
+    expect(title.length).toBeGreaterThan(0);
+  });
+
   it("shows an Answer-questions button when awaiting user input and opens the workflow tab", async () => {
     const onOpenDetailWithTab = vi.fn();
     render(
diff --git a/packages/dashboard/app/components/__tests__/plannerOverseerBadge.test.ts b/packages/dashboard/app/components/__tests__/plannerOverseerBadge.test.ts
new file mode 100644
index 0000000000..43deee4999
--- /dev/null
+++ b/packages/dashboard/app/components/__tests__/plannerOverseerBadge.test.ts
@@ -0,0 +1,103 @@
+import { describe, it, expect } from "vitest";
+import { plannerOverseerBadgeTooltip, plannerOverseerStateLabel } from "../plannerOverseerBadge";
+import type { PlannerOverseerRuntimeSnapshot, PlannerOverseerState } from "@fusion/core";
+
+const NON_IDLE_STATES: PlannerOverseerState[] = [
+  "watching",
+  "steering",
+  "recovering",
+  "awaiting-confirmation",
+];
+
+function makeSnapshot(
+  overrides: Partial<PlannerOverseerRuntimeSnapshot> = {},
+): Pick<PlannerOverseerRuntimeSnapshot, "state" | "reason" | "watchedStage" | "signal" | "pendingConfirmation"> {
+  return {
+    state: "watching",
+    reason: undefined,
+    watchedStage: undefined,
+    signal: undefined,
+    pendingConfirmation: undefined,
+    ...overrides,
+  };
+}
+
+describe("plannerOverseerStateLabel", () => {
+  for (const state of NON_IDLE_STATES) {
+    it(`renders a human-readable label for "${state}" (no raw kebab-case)`, () => {
+      const label = plannerOverseerStateLabel(state);
+      expect(label).not.toBe(state);
+      expect(label).not.toMatch(/-/);
+    });
+  }
+
+  it("renders a distinct readable label for awaiting-confirmation", () => {
+    expect(plannerOverseerStateLabel("awaiting-confirmation")).toBe("Awaiting confirmation");
+  });
+});
+
+describe("plannerOverseerBadgeTooltip", () => {
+  it("uses the verbatim reason when present", () => {
+    const tooltip = plannerOverseerBadgeTooltip(
+      makeSnapshot({ state: "steering", reason: "Executor is stalled on step 3" }),
+    );
+    expect(tooltip).toContain("Executor is stalled on step 3");
+  });
+
+  it("falls back gracefully (no literal undefined) when reason is absent", () => {
+    const tooltip = plannerOverseerBadgeTooltip(makeSnapshot({ state: "watching", reason: undefined }));
+    expect(tooltip).not.toMatch(/undefined/);
+    expect(tooltip.length).toBeGreaterThan(0);
+  });
+
+  it("appends watched stage and signal when both present", () => {
+    const tooltip = plannerOverseerBadgeTooltip(
+      makeSnapshot({ state: "recovering", watchedStage: "executor", signal: "progressing" }),
+    );
+    expect(tooltip).toContain("executor");
+    expect(tooltip).toContain("progressing");
+    expect(tooltip).not.toMatch(/undefined/);
+  });
+
+  it("appends watched stage without a signal clause when signal is absent", () => {
+    const tooltip = plannerOverseerBadgeTooltip(makeSnapshot({ state: "steering", watchedStage: "executor" }));
+    expect(tooltip).toContain("executor");
+    expect(tooltip).not.toMatch(/undefined/);
+  });
+
+  it("omits stage/signal wording entirely when both are absent", () => {
+    const tooltip = plannerOverseerBadgeTooltip(makeSnapshot({ state: "steering", reason: "Applying a targeted fix" }));
+    expect(tooltip).not.toMatch(/undefined/);
+  });
+
+  it("explains a pending human decision for awaiting-confirmation regardless of the pendingConfirmation flag value", () => {
+    const tooltip = plannerOverseerBadgeTooltip(
+      makeSnapshot({ state: "awaiting-confirmation", reason: "Retry limit reached", pendingConfirmation: true }),
+    );
+    expect(tooltip).toMatch(/human decision/i);
+  });
+
+  it("explains a pending human decision when pendingConfirmation is true even outside the awaiting-confirmation state", () => {
+    const tooltip = plannerOverseerBadgeTooltip(
+      makeSnapshot({ state: "watching", reason: "Observing", pendingConfirmation: true }),
+    );
+    expect(tooltip).toMatch(/human decision/i);
+  });
+
+  it("does not mention a pending decision when pendingConfirmation is false and state is not awaiting-confirmation", () => {
+    const tooltip = plannerOverseerBadgeTooltip(
+      makeSnapshot({ state: "watching", reason: "Observing", pendingConfirmation: false }),
+    );
+    expect(tooltip).not.toMatch(/human decision/i);
+  });
+
+  it("never emits the raw kebab-case state string when reason is absent (uses the readable label instead)", () => {
+    // Only "awaiting-confirmation" is kebab-case; the others contain no hyphen
+    // so a substring check would be trivially true. Assert the hyphenated raw
+    // form specifically never leaks into the tooltip.
+    const tooltip = plannerOverseerBadgeTooltip(
+      makeSnapshot({ state: "awaiting-confirmation", reason: undefined }),
+    );
+    expect(tooltip).not.toContain("awaiting-confirmation");
+  });
+});
diff --git a/packages/dashboard/app/components/plannerOverseerBadge.ts b/packages/dashboard/app/components/plannerOverseerBadge.ts
new file mode 100644
index 0000000000..7b9ab45dfd
--- /dev/null
+++ b/packages/dashboard/app/components/plannerOverseerBadge.ts
@@ -0,0 +1,104 @@
+import type { TFunction } from "i18next";
+import type { PlannerOverseerState, PlannerOverseerRuntimeSnapshot } from "@fusion/core";
+
+/**
+ * FNXC:PlannerOversight 2026-07-04-18:05:
+ * FN-7563: the `TaskCard` planner-overseer badge previously printed the raw
+ * kebab-case runtime state (e.g. `awaiting-confirmation`) with a bare
+ * `Planner overseer: awaiting-confirmation` tooltip — an operator on an
+ * `in-review` task had no explanation of what was being confirmed or why.
+ * This module is the single source of truth for (a) a human-readable label
+ * per non-idle `PlannerOverseerState`, and (b) an explanatory tooltip string
+ * composed from the transient `PlannerOverseerRuntimeSnapshot` fields the
+ * engine already populates (`reason`, `watchedStage`, `signal`,
+ * `pendingConfirmation`). It is presentation-only: a pure function of the
+ * snapshot it is given. It must NOT re-derive, cache, or mutate overseer
+ * state — the snapshot itself remains owned by FN-7511/FN-7512/FN-7531.
+ *
+ * Deliberately free of React/engine imports (only TYPE imports from
+ * `@fusion/core`) so it stays trivially unit-testable and safe under the
+ * dashboard's `@fusion/core` -> `packages/core/src/types.ts` vite alias.
+ */
+
+/** Human-readable label for a non-idle planner-overseer state. Falls back to the raw state for future/unknown enum values so a new state never silently disappears. */
+export function plannerOverseerStateLabel(
+  state: PlannerOverseerState,
+  t?: TFunction<"app">,
+): string {
+  const translate: (key: string, fallback: string, opts?: Record<string, unknown>) => string =
+    t ?? ((_key, fallback) => fallback);
+  switch (state) {
+    case "watching":
+      return translate("tasks.plannerOverseerState.watching", "Overseer watching");
+    case "steering":
+      return translate("tasks.plannerOverseerState.steering", "Overseer steering");
+    case "recovering":
+      return translate("tasks.plannerOverseerState.recovering", "Overseer recovering");
+    case "awaiting-confirmation":
+      return translate("tasks.plannerOverseerState.awaitingConfirmation", "Awaiting confirmation");
+    case "idle":
+      return translate("tasks.plannerOverseerState.idle", "Overseer idle");
+    default:
+      return state;
+  }
+}
+
+/**
+ * Composes the badge tooltip: leads with the human-readable `reason` when
+ * present (verbatim, mirroring the `taskDetail.oversight.explainReason`
+ * wording), appends the watched stage/signal when known, and — for
+ * `awaiting-confirmation` — appends a sentence stating a human decision is
+ * pending. Never emits the literal `undefined`; every optional field has a
+ * graceful fallback clause instead.
+ */
+export function plannerOverseerBadgeTooltip(
+  snapshot: Pick<PlannerOverseerRuntimeSnapshot, "state" | "reason" | "watchedStage" | "signal" | "pendingConfirmation">,
+  t?: TFunction<"app">,
+): string {
+  const translate: (key: string, fallback: string, opts?: Record<string, unknown>) => string =
+    t ??
+    ((_key, fallback, opts) => {
+      if (!opts) return fallback;
+      return Object.entries(opts).reduce(
+        (acc, [key, value]) => acc.replaceAll(`{{${key}}}`, String(value)),
+        fallback,
+      );
+    });
+
+  const parts: string[] = [];
+
+  if (snapshot.reason) {
+    parts.push(snapshot.reason);
+  } else {
+    parts.push(
+      translate("tasks.plannerOverseerStateTooltip.stateOnly", "Planner overseer: {{label}}", {
+        label: plannerOverseerStateLabel(snapshot.state, t),
+      }),
+    );
+  }
+
+  if (snapshot.watchedStage) {
+    parts.push(
+      snapshot.signal
+        ? translate(
+            "tasks.plannerOverseerStateTooltip.watchingStageSignal",
+            "Watching {{stage}} ({{signal}}).",
+            { stage: snapshot.watchedStage, signal: snapshot.signal },
+          )
+        : translate("tasks.plannerOverseerStateTooltip.watchingStage", "Watching {{stage}}.", {
+            stage: snapshot.watchedStage,
+          }),
+    );
+  }
+
+  if (snapshot.state === "awaiting-confirmation" || snapshot.pendingConfirmation) {
+    parts.push(
+      translate(
+        "tasks.plannerOverseerStateTooltip.pendingConfirmation",
+        "A human decision is required before the overseer can continue.",
+      ),
+    );
+  }
+
+  return parts.join(" ");
+}

From 2ed06f9f142d9f117410661b99fe9eebaf730777 Mon Sep 17 00:00:00 2001
From: gsxdsm <gsxdsm@users.noreply.github.com>
Date: Sat, 4 Jul 2026 22:23:05 -0700
Subject: [PATCH 07/65] FN-7547: support reverting multi-repo workspace tasks
 via git

Adds all-or-nothing git-revert support for multi-repo workspace tasks and wires it into the existing revert route/AI-undo/per-sha machinery.

- Add `resolveWorkspaceTaskRevertCommits` and `revertWorkspaceTask` to `packages/engine/src/task-revert.ts`, dry-run classifying every sub-repo first and only committing per-repo revert commits when every sub-repo is clean/already-reverted; any conflicting sub-repo rolls back every already-committed sub-repo.
- Extract shared `applyAndCommitRevert" apply/commit machinery (built on the existing `applyRevertNoCommit` primitive) so the workspace path reuses the same commit-message/trailer contract as the single-repo path.
- Add a defensive `isWorkspaceTask` guard to `performTaskRevert` so workspace tasks can never be silently reverted through the single-repo path.
- Wire `POST /api/tasks/:id/revert` (register-task-workflow-routes.ts) to dispatch workspace tasks to `revertWorkspaceTask`, preserving the existing `mode` (git/ai/auto) and AI-undo-fallback contract for workspace conflicts.
- Export the new workspace revert types/functions from `packages/engine/src/index.ts`.
- Add route-dispatch and real-git workspace revert test coverage; update docs and add a changeset.

Files changed:
 .changeset/fn-7547-workspace-task-revert.md        |   7 +
 docs/task-management.md                            |   8 +-
 packages/dashboard/src/__tests__/task-revert-route.test.ts        | 102 +++++
 packages/dashboard/src/routes/register-task-workflow-routes.ts    |  76 +++-
 packages/engine/src/__tests__/task-revert.workspace.real-git.test.ts | 272 +++++++++++++
 packages/engine/src/index.ts                       |   6 +
 packages/engine/src/task-revert.ts                 | 448 ++++++++++++++++++++-
 7 files changed, 897 insertions(+), 22 deletions(-)

Fusion-Task-Id: FN-7547

Fusion-Task-Lineage: b1b5eeda-06fd-43c1-8163-74b62c77b000

Co-authored-by: Fusion (runfusion.ai) <noreply@runfusion.ai>
---
 .changeset/fn-7547-workspace-task-revert.md   |   7 +
 docs/task-management.md                       |   8 +-
 .../src/__tests__/task-revert-route.test.ts   | 102 ++++
 .../routes/register-task-workflow-routes.ts   |  76 ++-
 .../task-revert.workspace.real-git.test.ts    | 272 +++++++++++
 packages/engine/src/index.ts                  |   6 +
 packages/engine/src/task-revert.ts            | 448 +++++++++++++++++-
 7 files changed, 897 insertions(+), 22 deletions(-)
 create mode 100644 .changeset/fn-7547-workspace-task-revert.md
 create mode 100644 packages/engine/src/__tests__/task-revert.workspace.real-git.test.ts

diff --git a/.changeset/fn-7547-workspace-task-revert.md b/.changeset/fn-7547-workspace-task-revert.md
new file mode 100644
index 0000000000..1404ce5d4c
--- /dev/null
+++ b/.changeset/fn-7547-workspace-task-revert.md
@@ -0,0 +1,7 @@
+---
+"@runfusion/fusion": minor
+---
+
+summary: Support reverting multi-repo workspace tasks via git, all-or-nothing across sub-repos.
+category: feature
+dev: Extends `packages/engine/src/task-revert.ts` with `resolveWorkspaceTaskRevertCommits`/`revertWorkspaceTask` and wires `POST /api/tasks/:id/revert` to dispatch workspace tasks (`isWorkspaceTask`) to the new path; returns `{ mode: "git", clean, workspace: { repos: [...] }, conflicts? }`. Single-repo `performTaskRevert` path is unchanged.
diff --git a/docs/task-management.md b/docs/task-management.md
index 075b23c936..4aad65d790 100644
--- a/docs/task-management.md
+++ b/docs/task-management.md
@@ -680,13 +680,15 @@ Recovery/backfill guidance:
 - The route accepts an optional request body `{ mode?: "git" | "ai" | "auto" }` (default `"auto"`; unknown values reject with 400):
   - `"git"` — the FN-7523 git-only behavior. The result (including a conflicting/unsupported result) is returned as-is and never creates a follow-up task.
   - `"ai"` — skip git entirely and always create the AI-undo fallback task (FN-7524).
-  - `"auto"` — try git first. A clean/alreadyReverted/needsHuman result is returned unchanged. A conflicting or unsupported (e.g. workspace-task) result falls back to creating the AI-undo task.
-- Also accepts an optional `{ granularity?: "squash" | "per-sha" }` field (FN-7548) that selects the git-path commit granularity: `"squash"` (default, unchanged) accumulates all attributable commits into one revert commit; `"per-sha"` creates one attributed revert commit per original sha (each with its own `Fusion-Task-Id` trailer and audit line), skipping no-op shas without empty commits. A mid-batch conflict in either mode rolls back the whole batch — no partially-landed per-sha commits. This field only affects the git path and is ignored when `mode` resolves to `"ai"`.
+  - `"auto"` — try git first. A clean/alreadyReverted/needsHuman result is returned unchanged. A conflicting or unsupported result falls back to creating the AI-undo task.
+- Also accepts an optional `{ granularity?: "squash" | "per-sha" }` field (FN-7548) that selects the git-path commit granularity: `"squash"` (default, unchanged) accumulates all attributable commits into one revert commit; `"per-sha"` creates one attributed revert commit per original sha (each with its own `Fusion-Task-Id` trailer and audit line), skipping no-op shas without empty commits. A mid-batch conflict in either mode rolls back the whole batch — no partially-landed per-sha commits. This field only affects the single-repo git path and is ignored when `mode` resolves to `"ai"` or the task is a workspace task.
 - Git-path response contract (additive only): `{ mode: "git", clean, revertCommitSha?, revertCommitShas?, conflicts?, alreadyReverted?, unsupported?, needsHuman?, reason? }`. A clean revert lands a `revert(FN-xxxx): ...` commit carrying a `Fusion-Task-Id` trailer on the resolved base branch; `revertCommitShas` reports every commit created (all of them for `per-sha`, the single one for `squash`) alongside the existing `revertCommitSha`.
 - AI-undo response contract: `{ mode: "ai", createdTaskId: "FN-YYYY", alreadyOpen?: true }`. The created task is an ordinary `triage`-column board task (via the normal `store.createTask` path) that references the source task's id, mission, and landed files, and instructs undoing the source task's behavior while preserving unrelated later changes to the same files, using a `revert(FN-xxxx): ...` commit convention. It carries NO dependency on the (already done/archived) source task. A `sourceMetadata.revertOf` marker makes repeated fallback calls idempotent — while an AI-undo task for that source is still open, a further call returns the same `createdTaskId` with `alreadyOpen: true` instead of creating a duplicate; a prior undo task that itself reached `done`/`archived` does not suppress a fresh one.
-- Workspace (multi-repo) tasks return `unsupported` from the git path (routing `auto` to the AI-undo fallback); `autoMerge:false` projects return `needsHuman` and never trigger the AI-undo fallback (a human/future UI decides).
+- **Workspace (multi-repo) tasks (FN-7547):** tasks with `workspaceWorktrees` populated (`isWorkspaceTask`) are revertable too — the route dispatches to a dedicated workspace path that reasons about every sub-repo's integration branch as ONE all-or-nothing unit. It resolves each sub-repo's attributable commit(s), dry-run classifies every sub-repo first, and only commits a `revert(FN-xxxx): ...` commit on EACH sub-repo when every sub-repo classifies clean/already-reverted; if any sub-repo conflicts, no sub-repo is committed and every touched sub-repo worktree is rolled back to its pre-call state. Response contract for workspace tasks: `{ mode: "git", clean, workspace: { repos: [{ repo, classification, revertCommitSha?, conflicts?, alreadyReverted? }] }, conflicts?: {repo, file, ...}[] }`. A conflicting workspace result still falls back to the AI-undo task under `"auto"` mode, same as a single-repo conflicting result.
+- `autoMerge:false` projects return `needsHuman` and never trigger the AI-undo fallback (a human/future UI decides).
 - No dashboard UI affordance ships with this yet (see the Done/Archived card action follow-up task).
 
+
 ## GitHub Issue Import and PR Creation
 
 GitLab enablement, instance/API URL, and access-token configuration are available in Settings for GitLab.com and self-managed GitLab (`gitlabEnabled`, `gitlabInstanceUrl`, optional `gitlabApiBaseUrl`, `gitlabAuthToken`, `gitlabAuthTokenType`). Fusion accepts personal, project, and group access tokens for GitLab HTTP API import tasks; read-only project issue, group issue, and merge request imports require `read_api` or `api`, while later write actions such as comments and auto-close require `api`.
diff --git a/packages/dashboard/src/__tests__/task-revert-route.test.ts b/packages/dashboard/src/__tests__/task-revert-route.test.ts
index 134e87f239..9684e863db 100644
--- a/packages/dashboard/src/__tests__/task-revert-route.test.ts
+++ b/packages/dashboard/src/__tests__/task-revert-route.test.ts
@@ -35,12 +35,14 @@ function makeGitRepoOnMain(): string {
 }
 
 const performTaskRevertMock = vi.fn();
+const revertWorkspaceTaskMock = vi.fn();
 
 vi.mock("@fusion/engine", async (importOriginal) => {
   const actual = await importOriginal<typeof import("@fusion/engine")>();
   return {
     ...actual,
     performTaskRevert: (...args: unknown[]) => performTaskRevertMock(...args),
+    revertWorkspaceTask: (...args: unknown[]) => revertWorkspaceTaskMock(...args),
   };
 });
 
@@ -64,6 +66,22 @@ function makeTask(overrides: Partial<Task>): Task {
   } as Task;
 }
 
+// FNXC:TaskRevert 2026-07-04-00:00 (FN-7547 — workspace dispatch coverage):
+// Workspace tasks (`workspaceWorktrees` populated) must route to
+// `revertWorkspaceTask` instead of `performTaskRevert` — real per-repo git
+// behavior (attribution/classification/all-or-nothing rollback) is proven in
+// packages/engine/src/__tests__/task-revert.workspace.real-git.test.ts; this
+// suite only asserts the route dispatch and per-repo response shape.
+function makeWorkspaceTask(overrides: Partial<Task>): Task {
+  return makeTask({
+    workspaceWorktrees: {
+      "repo-a": { worktreePath: "/tmp/repo-a", branch: "fusion/FN-100", landedSha: "aaa111" },
+      "repo-b": { worktreePath: "/tmp/repo-b", branch: "fusion/FN-100", landedSha: "bbb222" },
+    },
+    ...overrides,
+  });
+}
+
 function createMockStore(
   task: Task,
   opts?: { openUndoTask?: Task | null; createdUndoTask?: Task },
@@ -210,6 +228,90 @@ describe("POST /tasks/:id/revert", () => {
     expect((res.body as { details?: { code?: string } }).details?.code ?? (res.body as { error?: string }).error).toBeTruthy();
     expect(performTaskRevertMock).not.toHaveBeenCalled();
   });
+
+  it("dispatches a done workspace task to revertWorkspaceTask and returns the per-repo breakdown (clean)", async () => {
+    const task = makeWorkspaceTask({ column: "done" });
+    const store = createMockStore(task);
+    revertWorkspaceTaskMock.mockResolvedValue({
+      mode: "git",
+      clean: true,
+      workspace: {
+        repos: [
+          { repo: "repo-a", classification: "clean", revertCommitSha: "rev-a" },
+          { repo: "repo-b", classification: "clean", revertCommitSha: "rev-b" },
+        ],
+      },
+    });
+
+    const res = await REQUEST(createApp(store), "POST", `/api/tasks/${task.id}/revert`);
+    expect(res.status).toBe(200);
+    expect(res.body).toMatchObject({
+      mode: "git",
+      clean: true,
+      workspace: { repos: [{ repo: "repo-a" }, { repo: "repo-b" }] },
+    });
+    expect(revertWorkspaceTaskMock).toHaveBeenCalledTimes(1);
+    expect(performTaskRevertMock).not.toHaveBeenCalled();
+  });
+
+  it("mode:'git' dispatches a workspace task conflict to the per-repo conflict shape without creating an AI-undo task or calling performTaskRevert", async () => {
+    const task = makeWorkspaceTask({ column: "archived" });
+    const store = createMockStore(task);
+    revertWorkspaceTaskMock.mockResolvedValue({
+      mode: "git",
+      clean: false,
+      workspace: {
+        repos: [
+          { repo: "repo-a", classification: "clean", revertCommitSha: "rev-a" },
+          { repo: "repo-b", classification: "conflicting", conflicts: [{ file: "b.ts", status: "UU" }] },
+        ],
+      },
+      conflicts: [{ repo: "repo-b", file: "b.ts", status: "UU" }],
+    });
+
+    const res = await POST_JSON(createApp(store), `/api/tasks/${task.id}/revert`, { mode: "git" });
+    expect(res.status).toBe(200);
+    expect(res.body).toMatchObject({
+      mode: "git",
+      clean: false,
+      conflicts: [{ repo: "repo-b", file: "b.ts" }],
+    });
+    expect(performTaskRevertMock).not.toHaveBeenCalled();
+  });
+
+  // FN-7547 + FN-7524: default mode is "auto", which falls back to the AI-undo
+  // task on a conflicting WORKSPACE result too, same as the single-repo contract.
+  it("auto (default) mode falls back to the AI-undo task on a conflicting workspace result", async () => {
+    const task = makeWorkspaceTask({ id: "FN-950", column: "archived" });
+    const store = createMockStore(task);
+    revertWorkspaceTaskMock.mockResolvedValue({
+      mode: "git",
+      clean: false,
+      workspace: {
+        repos: [
+          { repo: "repo-a", classification: "clean", revertCommitSha: "rev-a" },
+          { repo: "repo-b", classification: "conflicting", conflicts: [{ file: "b.ts", status: "UU" }] },
+        ],
+      },
+      conflicts: [{ repo: "repo-b", file: "b.ts", status: "UU" }],
+    });
+
+    const res = await REQUEST(createApp(store), "POST", `/api/tasks/${task.id}/revert`);
+    expect(res.status).toBe(200);
+    expect(res.body).toMatchObject({ mode: "ai" });
+    expect((res.body as { createdTaskId?: string }).createdTaskId).toBeTruthy();
+    expect(performTaskRevertMock).not.toHaveBeenCalled();
+  });
+
+  it("rejects a non-done/archived workspace task with a 4xx guard before invoking the workspace service", async () => {
+    const task = makeWorkspaceTask({ column: "in-progress" });
+    const store = createMockStore(task);
+
+    const res = await REQUEST(createApp(store), "POST", `/api/tasks/${task.id}/revert`);
+    expect(res.status).toBeGreaterThanOrEqual(400);
+    expect(res.status).toBeLessThan(500);
+    expect(revertWorkspaceTaskMock).not.toHaveBeenCalled();
+  });
 });
 
 // FN-7524 Symptom Verification: `{ mode }` request handling + the AI-undo fallback.
diff --git a/packages/dashboard/src/routes/register-task-workflow-routes.ts b/packages/dashboard/src/routes/register-task-workflow-routes.ts
index 339ba40530..da1ade20c0 100644
--- a/packages/dashboard/src/routes/register-task-workflow-routes.ts
+++ b/packages/dashboard/src/routes/register-task-workflow-routes.ts
@@ -53,13 +53,14 @@ import {
   planTaskWorktreePath,
   promoteHeldTask,
   performTaskRevert,
+  revertWorkspaceTask,
   TaskRevertError,
   createAiUndoTask,
   type AiUndoTaskResult,
 } from "@fusion/engine";
 import { buildBoardWorkflowsPayload } from "./board-workflows.js";
 import { isBackwardMoveBlockedByOpenPr, PR_OPEN_BLOCKS_MOVE_BACK_MESSAGE } from "./register-pull-requests-routes.js";
-import type { RunAuditEventInput } from "@fusion/core";
+import { isWorkspaceTask, type RunAuditEventInput } from "@fusion/core";
 import { ApiError, badRequest, conflict, notFound } from "../api-error.js";
 import type { ApiRoutesContext } from "./types.js";
 import { deriveAutoTaskBranch, derivePerTaskBranch, getBranchSelectionMode, resolveBranchSelection } from "./branch-selection.js";
@@ -1670,10 +1671,11 @@ export function registerTaskWorkflowRoutes(ctx: ApiRoutesContext, deps: TaskWork
   });
 
   /*
-  FNXC:TaskRevert 2026-07-04-00:00 (FN-7524 mode contract; FN-7548 granularity contract):
+  FNXC:TaskRevert 2026-07-04-00:00 (FN-7524 mode contract; FN-7547 workspace dispatch; FN-7548 granularity contract):
   POST /tasks/:id/revert — intelligent git-revert for Done/Archived tasks (FN-7523), with an
-  AI-undo fallback (FN-7524, foundation for FN-7501) and per-sha revert-commit granularity
-  (FN-7548). Guard rails (enforced here AND in the engine service):
+  AI-undo fallback (FN-7524, foundation for FN-7501), workspace (multi-repo) task support
+  (FN-7547), and per-sha revert-commit granularity (FN-7548). Guard rails (enforced here AND in
+  the engine service):
     - only done/archived tasks are revertable (400/409 otherwise);
     - autoMerge-off is a needsHuman result, not a forced write, and NEVER triggers the AI fallback
       (leave that for a human / sibling FN-7525 to decide);
@@ -1685,15 +1687,18 @@ export function registerTaskWorkflowRoutes(ctx: ApiRoutesContext, deps: TaskWork
         returned as-is and the AI-undo path is NEVER invoked.
       - `"ai"`   — skip git entirely; always take the AI-undo fallback.
       - `"auto"` — attempt git first. A clean/alreadyReverted/needsHuman git result is returned
-        unchanged (NO AI task created). A conflicting or unsupported (e.g. workspace-task) git result
-        falls through to the AI-undo fallback.
+        unchanged (NO AI task created). A conflicting or unsupported git result falls through to
+        the AI-undo fallback.
     - `granularity?: "squash" | "per-sha"` (FN-7548, default `"squash"`) — commit granularity for the
-      git-path revert only; forwarded verbatim to `performTaskRevert`. `"squash"` preserves the
-      unchanged FN-7523 single-commit behavior; `"per-sha"` creates one attributed revert commit per
-      original sha (see `performTaskRevert`'s per-sha apply path). Ignored when `mode` resolves to `"ai"`.
+      single-repo git-path revert only; forwarded verbatim to `performTaskRevert`. `"squash"`
+      preserves the unchanged FN-7523 single-commit behavior; `"per-sha"` creates one attributed
+      revert commit per original sha (see `performTaskRevert`'s per-sha apply path). Ignored when
+      `mode` resolves to `"ai"` or the task is a workspace task.
 
   Response contract is ADDITIVE over FN-7523: `{ mode: "git", clean, revertCommitSha?, revertCommitShas?,
-  conflicts?, alreadyReverted?, unsupported?, needsHuman?, reason? }` OR
+  conflicts?, alreadyReverted?, unsupported?, needsHuman?, reason? }` OR, for workspace tasks (FN-7547),
+  `{ mode: "git", clean, workspace: { repos: [{ repo, classification, revertCommitSha?, conflicts?,
+  alreadyReverted? }] }, conflicts?: {repo, file, ...}[] }` OR
   `{ mode: "ai", createdTaskId: "FN-YYYY", alreadyOpen?: true }`. The AI-undo task is created via
   `createAiUndoTask` (engine) + `TaskStore.findOpenRevertTaskForSource` (core) for the idempotency
   guard — a second call while an undo task is still open returns the SAME `createdTaskId` with
@@ -1723,8 +1728,8 @@ export function registerTaskWorkflowRoutes(ctx: ApiRoutesContext, deps: TaskWork
       combined revert commit) or `"per-sha"` (one attributed revert commit per
       original sha, see `performTaskRevert`'s per-sha apply path). An absent/
       empty value defaults to `"squash"`; any other value is a 400 naming the
-      allowed values. Only relevant to the git path — ignored when `mode`
-      resolves to `"ai"`.
+      allowed values. Only relevant to the single-repo git path — ignored when
+      `mode` resolves to `"ai"` or the task is a workspace task.
       */
       const requestedGranularity = (req.body as { granularity?: unknown } | undefined)?.granularity;
       let granularity: "squash" | "per-sha" = "squash";
@@ -1749,6 +1754,47 @@ export function registerTaskWorkflowRoutes(ctx: ApiRoutesContext, deps: TaskWork
 
       const rootDir = scopedStore.getRootDir();
       const settings = await scopedStore.getSettingsFast();
+
+      /*
+      FNXC:TaskRevert 2026-07-04-00:00 (FN-7547 — workspace dispatch):
+      Workspace tasks (`isWorkspaceTask(task)`) land commits across MULTIPLE
+      sub-repo integration branches under `rootDir` (each sub-repo lives at
+      `join(rootDir, repoRel)`, mirroring `landWorkspaceTask`) — there is no
+      single `baseBranch`/`rootDir`-is-a-git-repo assumption to check here.
+      Route straight to `revertWorkspaceTask`, which resolves + branch-checks
+      + dry-run classifies + commits EACH sub-repo itself, enforcing the
+      whole-task all-or-nothing contract. The single-repo path below is
+      UNCHANGED. `granularity` does not apply to the workspace path.
+      */
+      if (isWorkspaceTask(task)) {
+        const workspaceResult = await revertWorkspaceTask({
+          task,
+          workspaceRootDir: rootDir,
+          settings,
+          commitAssociationSource: {
+            getTaskCommitAssociationsByLineageId: (lineageId: string) =>
+              scopedStore.getTaskCommitAssociationsByLineageId(lineageId),
+          },
+          effectiveAutoMerge: settings.autoMerge,
+        });
+
+        if (mode === "git") {
+          res.json(workspaceResult);
+          return;
+        }
+
+        // mode === "auto": fall back to the AI-undo task on a conflicting workspace
+        // result, same as the single-repo conflicting-result contract below.
+        const workspaceShouldFallBackToAi = workspaceResult.mode === "git" && "clean" in workspaceResult && workspaceResult.clean === false;
+        if (workspaceShouldFallBackToAi) {
+          res.json(await createAiUndoResult());
+          return;
+        }
+
+        res.json(workspaceResult);
+        return;
+      }
+
       const baseBranch = task.mergeDetails?.mergeTargetBranch || await resolveIntegrationBranch(rootDir, settings);
 
       /*
@@ -1791,8 +1837,8 @@ export function registerTaskWorkflowRoutes(ctx: ApiRoutesContext, deps: TaskWork
       }
 
       // mode === "auto": fall back to the AI-undo task ONLY on conflict or an
-      // unsupported (e.g. workspace) git result. Clean/alreadyReverted/needsHuman
-      // results are returned as-is — needsHuman (autoMerge-off) NEVER triggers AI.
+      // unsupported git result. Clean/alreadyReverted/needsHuman results are
+      // returned as-is — needsHuman (autoMerge-off) NEVER triggers AI.
       const shouldFallBackToAi =
         (result.mode === "git" && "clean" in result && result.clean === false) ||
         (result.mode === "git" && "unsupported" in result && result.unsupported === true);
@@ -1808,7 +1854,7 @@ export function registerTaskWorkflowRoutes(ctx: ApiRoutesContext, deps: TaskWork
         throw err;
       }
       if (err instanceof TaskRevertError) {
-        const status = err.code === "dirty-working-tree" ? 409 : 500;
+        const status = err.code === "dirty-working-tree" || err.code === "branch-mismatch" ? 409 : 500;
         throw new ApiError(status, err.message, { code: err.code });
       }
       rethrowAsApiError(err);
diff --git a/packages/engine/src/__tests__/task-revert.workspace.real-git.test.ts b/packages/engine/src/__tests__/task-revert.workspace.real-git.test.ts
new file mode 100644
index 0000000000..b523534698
--- /dev/null
+++ b/packages/engine/src/__tests__/task-revert.workspace.real-git.test.ts
@@ -0,0 +1,272 @@
+import { execSync, spawnSync } from "node:child_process";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import {
+  resolveWorkspaceTaskRevertCommits,
+  revertWorkspaceTask,
+} from "../task-revert.js";
+import type { Task } from "@fusion/core";
+
+const hasGit = spawnSync("git", ["--version"], { stdio: "pipe" }).status === 0;
+const describeIfGit = hasGit ? describe : describe.skip;
+
+function git(repo: string, command: string): string {
+  return execSync(command, { cwd: repo, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+}
+
+function makeTask(overrides: Partial<Task>): Task {
+  return {
+    id: "FN-A",
+    lineageId: "FN-A",
+    description: "",
+    column: "done",
+    dependencies: [],
+    steps: [],
+    currentStep: 0,
+    ...overrides,
+  } as Task;
+}
+
+/*
+FNXC:TaskRevert 2026-07-04-00:00 (FN-7547):
+Real multi-repo git fixture coverage for the workspace revert path — this is
+the Symptom Verification regression suite. Mirrors the scratch-repo fixture
+pattern from workspace-merger-idempotency.test.ts and the single-repo
+task-revert.real-git.test.ts, but with TWO sub-repos under a shared workspace
+root so the all-or-nothing multi-repo classification/rollback contract can be
+exercised for real.
+*/
+describeIfGit("task-revert workspace real-git scenarios", { timeout: 30_000 }, () => {
+  const dirs: string[] = [];
+  afterEach(() => {
+    for (const dir of dirs.splice(0)) rmSync(dir, { recursive: true, force: true });
+  });
+
+  function subRepoFixture(workspaceRoot: string, repoRel: string, initialFile: string, initialContent: string): string {
+    const repoRootDir = join(workspaceRoot, repoRel);
+    git(workspaceRoot, `mkdir -p ${repoRel}`);
+    git(repoRootDir, "git init -b main");
+    git(repoRootDir, 'git config user.email "test@example.com"');
+    git(repoRootDir, 'git config user.name "Test User"');
+    git(repoRootDir, "git config commit.gpgsign false");
+    writeFileSync(join(repoRootDir, initialFile), initialContent);
+    git(repoRootDir, `git add ${initialFile} && git commit -m 'init'`);
+    return repoRootDir;
+  }
+
+  function workspaceFixture() {
+    const workspaceRoot = mkdtempSync(join(tmpdir(), "fn-7547-wsrevert-"));
+    dirs.push(workspaceRoot);
+    const repoA = subRepoFixture(workspaceRoot, "repo-a", "a.ts", "line1\n");
+    const repoB = subRepoFixture(workspaceRoot, "repo-b", "b.ts", "line1\n");
+    return { workspaceRoot, repoA, repoB };
+  }
+
+  function landTaskCommit(repoRootDir: string, file: string, content: string, commitSubject: string): string {
+    writeFileSync(join(repoRootDir, file), content);
+    git(repoRootDir, `git commit -am ${JSON.stringify(commitSubject)}`);
+    return git(repoRootDir, "git rev-parse HEAD");
+  }
+
+  function makeWorkspaceTask(shaA: string, shaB: string, overrides: Partial<Task> = {}): Task {
+    return makeTask({
+      column: "done",
+      workspaceWorktrees: {
+        "repo-a": { worktreePath: "repo-a", branch: "fusion/FN-A", landedSha: shaA },
+        "repo-b": { worktreePath: "repo-b", branch: "fusion/FN-A", landedSha: shaB },
+      },
+      mergeDetails: { commitSha: shaA, workspaceLandedShas: { "repo-a": shaA, "repo-b": shaB } },
+      ...overrides,
+    });
+  }
+
+  it("attribution: resolves the correct per-repo squash commit for each sub-repo", async () => {
+    const { workspaceRoot, repoA, repoB } = workspaceFixture();
+    const shaA = landTaskCommit(repoA, "a.ts", "line1\nfeature-a\n", "feat(FN-A): add feature in repo-a");
+    const shaB = landTaskCommit(repoB, "b.ts", "line1\nfeature-a\n", "feat(FN-A): add feature in repo-b");
+
+    const task = makeWorkspaceTask(shaA, shaB);
+    const attribution = await resolveWorkspaceTaskRevertCommits(task, { workspaceRootDir: workspaceRoot });
+
+    expect(Object.keys(attribution).sort()).toEqual(["repo-a", "repo-b"]);
+    expect(attribution["repo-a"]).toEqual({ commits: [shaA], source: "squash" });
+    expect(attribution["repo-b"]).toEqual({ commits: [shaB], source: "squash" });
+  });
+
+  it("attribution: falls back to lineage association when a repo's landed sha is absent", async () => {
+    const { workspaceRoot, repoA, repoB } = workspaceFixture();
+    const shaA = landTaskCommit(repoA, "a.ts", "line1\nfeature-a\n", "feat(FN-A): add feature in repo-a");
+    const shaBUnrecorded = landTaskCommit(repoB, "b.ts", "line1\nfeature-a\n", "feat(FN-A): add feature in repo-b");
+
+    const task = makeTask({
+      column: "done",
+      workspaceWorktrees: {
+        "repo-a": { worktreePath: "repo-a", branch: "fusion/FN-A", landedSha: shaA },
+        "repo-b": { worktreePath: "repo-b", branch: "fusion/FN-A" },
+      },
+      mergeDetails: { commitSha: shaA, workspaceLandedShas: { "repo-a": shaA } },
+    });
+
+    const attribution = await resolveWorkspaceTaskRevertCommits(task, {
+      workspaceRootDir: workspaceRoot,
+      commitAssociationSource: {
+        getTaskCommitAssociationsByLineageId: async () => [
+          {
+            id: "assoc-1",
+            taskLineageId: "FN-A",
+            taskIdSnapshot: "FN-A",
+            commitSha: shaBUnrecorded,
+            commitSubject: "feat(FN-A): add feature in repo-b",
+            authoredAt: new Date().toISOString(),
+            matchedBy: "canonical-lineage-trailer",
+            confidence: "canonical",
+            createdAt: new Date().toISOString(),
+            updatedAt: new Date().toISOString(),
+          },
+        ],
+      },
+    });
+
+    expect(attribution["repo-a"]).toEqual({ commits: [shaA], source: "squash" });
+    expect(attribution["repo-b"]).toEqual({ commits: [shaBUnrecorded], source: "lineage" });
+  });
+
+  it("clean all-or-nothing: reverts both sub-repos with a Fusion-Task-Id-trailered commit on each (Symptom Verification)", async () => {
+    const { workspaceRoot, repoA, repoB } = workspaceFixture();
+    const shaA = landTaskCommit(repoA, "a.ts", "line1\nfeature-a\n", "feat(FN-A): add feature in repo-a");
+    const shaB = landTaskCommit(repoB, "b.ts", "line1\nfeature-a\n", "feat(FN-A): add feature in repo-b");
+
+    const task = makeWorkspaceTask(shaA, shaB);
+    const result = await revertWorkspaceTask({ task, workspaceRootDir: workspaceRoot, settings: {} });
+
+    expect(result.mode).toBe("git");
+    expect(result.clean).toBe(true);
+    if (result.mode === "git" && result.clean) {
+      expect(result.workspace.repos).toHaveLength(2);
+      const byRepo = Object.fromEntries(result.workspace.repos.map((r) => [r.repo, r]));
+      expect(byRepo["repo-a"].classification).toBe("clean");
+      expect(byRepo["repo-a"].revertCommitSha).toBeTruthy();
+      expect(byRepo["repo-b"].classification).toBe("clean");
+      expect(byRepo["repo-b"].revertCommitSha).toBeTruthy();
+    }
+
+    for (const repoRootDir of [repoA, repoB]) {
+      const subject = git(repoRootDir, "git log -1 --format=%s");
+      expect(subject).toMatch(/^revert\(FN-A\):/);
+      const body = git(repoRootDir, "git log -1 --format=%B");
+      expect(body).toContain("Fusion-Task-Id: FN-A");
+      expect(git(repoRootDir, "git status --porcelain")).toBe("");
+    }
+    expect(git(repoA, "git show HEAD:a.ts")).toBe("line1");
+    expect(git(repoB, "git show HEAD:b.ts")).toBe("line1");
+  });
+
+  it("partial-conflict rollback: a later task touching repo-b only leaves BOTH repos byte-identical to pre-call (Symptom Verification)", async () => {
+    const { workspaceRoot, repoA, repoB } = workspaceFixture();
+    const shaA = landTaskCommit(repoA, "a.ts", "line1\nfeature-a\n", "feat(FN-A): add feature in repo-a");
+    const shaB = landTaskCommit(repoB, "b.ts", "line1\nfeature-a\n", "feat(FN-A): add feature in repo-b");
+
+    // Task B later modifies the exact same region touched by task A in repo-b only.
+    landTaskCommit(repoB, "b.ts", "line1\nfeature-a-modified-by-b\n", "feat(FN-B): modify same region in repo-b");
+
+    const preCallHeadA = git(repoA, "git rev-parse HEAD");
+    const preCallStatusA = git(repoA, "git status --porcelain");
+    const preCallHeadB = git(repoB, "git rev-parse HEAD");
+    const preCallStatusB = git(repoB, "git status --porcelain");
+
+    const task = makeWorkspaceTask(shaA, shaB);
+    const result = await revertWorkspaceTask({ task, workspaceRootDir: workspaceRoot, settings: {} });
+
+    expect(result.mode).toBe("git");
+    expect(result.clean).toBe(false);
+    if (result.mode === "git" && !result.clean && "conflicts" in result) {
+      expect(result.conflicts.some((c) => c.repo === "repo-b")).toBe(true);
+    }
+
+    // NO commit created in EITHER repo — all-or-nothing rollback held.
+    expect(git(repoA, "git rev-parse HEAD")).toBe(preCallHeadA);
+    expect(git(repoA, "git status --porcelain")).toBe(preCallStatusA);
+    expect(git(repoB, "git rev-parse HEAD")).toBe(preCallHeadB);
+    expect(git(repoB, "git status --porcelain")).toBe(preCallStatusB);
+    // repo-a is NOT left reverted.
+    expect(git(repoA, "git show HEAD:a.ts")).toBe("line1\nfeature-a");
+  });
+
+  it("already-reverted: reverting a clean task twice reports alreadyReverted for both repos with no second commit", async () => {
+    const { workspaceRoot, repoA, repoB } = workspaceFixture();
+    const shaA = landTaskCommit(repoA, "a.ts", "line1\nfeature-a\n", "feat(FN-A): add feature in repo-a");
+    const shaB = landTaskCommit(repoB, "b.ts", "line1\nfeature-a\n", "feat(FN-A): add feature in repo-b");
+
+    const task = makeWorkspaceTask(shaA, shaB);
+    const first = await revertWorkspaceTask({ task, workspaceRootDir: workspaceRoot, settings: {} });
+    expect(first.clean).toBe(true);
+
+    const headAAfterFirst = git(repoA, "git rev-parse HEAD");
+    const headBAfterFirst = git(repoB, "git rev-parse HEAD");
+
+    const second = await revertWorkspaceTask({ task, workspaceRootDir: workspaceRoot, settings: {} });
+    expect(second.mode).toBe("git");
+    expect(second.clean).toBe(true);
+    if (second.mode === "git" && second.clean) {
+      for (const repo of second.workspace.repos) {
+        expect(repo.alreadyReverted).toBe(true);
+      }
+    }
+
+    expect(git(repoA, "git rev-parse HEAD")).toBe(headAAfterFirst);
+    expect(git(repoB, "git rev-parse HEAD")).toBe(headBAfterFirst);
+  });
+
+  it("dirty-tree refusal: refuses without mutating either repo when one sub-repo has a stray uncommitted change", async () => {
+    const { workspaceRoot, repoA, repoB } = workspaceFixture();
+    const shaA = landTaskCommit(repoA, "a.ts", "line1\nfeature-a\n", "feat(FN-A): add feature in repo-a");
+    const shaB = landTaskCommit(repoB, "b.ts", "line1\nfeature-a\n", "feat(FN-A): add feature in repo-b");
+
+    writeFileSync(join(repoB, "b.ts"), "line1\nfeature-a\nSTRAY UNCOMMITTED CHANGE\n");
+
+    const preCallHeadA = git(repoA, "git rev-parse HEAD");
+    const preCallHeadB = git(repoB, "git rev-parse HEAD");
+
+    const task = makeWorkspaceTask(shaA, shaB);
+    await expect(revertWorkspaceTask({ task, workspaceRootDir: workspaceRoot, settings: {} })).rejects.toMatchObject({
+      code: "dirty-working-tree",
+    });
+
+    expect(git(repoA, "git rev-parse HEAD")).toBe(preCallHeadA);
+    expect(git(repoA, "git status --porcelain")).toBe("");
+    expect(git(repoB, "git rev-parse HEAD")).toBe(preCallHeadB);
+    expect(git(repoB, "git show HEAD:b.ts")).toBe("line1\nfeature-a");
+  });
+
+  it("guard rails: refuses a non-done/archived workspace task and never mutates the source task lifecycle", async () => {
+    const { workspaceRoot, repoA, repoB } = workspaceFixture();
+    const shaA = landTaskCommit(repoA, "a.ts", "line1\nfeature-a\n", "feat(FN-A): add feature in repo-a");
+    const shaB = landTaskCommit(repoB, "b.ts", "line1\nfeature-a\n", "feat(FN-A): add feature in repo-b");
+
+    const task = makeWorkspaceTask(shaA, shaB, { column: "in-progress" });
+    const result = await revertWorkspaceTask({ task, workspaceRootDir: workspaceRoot, settings: {} });
+
+    expect(result).toMatchObject({ mode: "git", needsHuman: true });
+    expect(task.column).toBe("in-progress");
+  });
+
+  it("guard rails: autoMerge:false refuses with needsHuman instead of force-writing", async () => {
+    const { workspaceRoot, repoA, repoB } = workspaceFixture();
+    const shaA = landTaskCommit(repoA, "a.ts", "line1\nfeature-a\n", "feat(FN-A): add feature in repo-a");
+    const shaB = landTaskCommit(repoB, "b.ts", "line1\nfeature-a\n", "feat(FN-A): add feature in repo-b");
+
+    const task = makeWorkspaceTask(shaA, shaB);
+    const result = await revertWorkspaceTask({
+      task,
+      workspaceRootDir: workspaceRoot,
+      settings: {},
+      effectiveAutoMerge: false,
+    });
+
+    expect(result).toMatchObject({ mode: "git", needsHuman: true });
+    expect(git(repoA, "git status --porcelain")).toBe("");
+    expect(git(repoB, "git status --porcelain")).toBe("");
+  });
+});
diff --git a/packages/engine/src/index.ts b/packages/engine/src/index.ts
index 520c17d92c..07df194aa3 100644
--- a/packages/engine/src/index.ts
+++ b/packages/engine/src/index.ts
@@ -270,6 +270,8 @@ export {
   resolveTaskRevertCommits,
   classifyTaskRevert,
   performTaskRevert,
+  resolveWorkspaceTaskRevertCommits,
+  revertWorkspaceTask,
   TaskRevertError,
   type TaskRevertCommitSource,
   type ResolvedTaskRevertCommits,
@@ -286,6 +288,10 @@ export {
   type CreateAiUndoTaskDeps,
   type TaskRevertGranularity,
   type PerformTaskRevertOptions,
+  type WorkspaceRepoRevertCommits,
+  type WorkspaceRepoRevertResult,
+  type WorkspaceTaskRevertResult,
+  type RevertWorkspaceTaskOptions,
 } from "./task-revert.js";
 export {
   resolveBranchGroupMergeRouting,
diff --git a/packages/engine/src/task-revert.ts b/packages/engine/src/task-revert.ts
index 8481794217..e1c64537f6 100644
--- a/packages/engine/src/task-revert.ts
+++ b/packages/engine/src/task-revert.ts
@@ -11,8 +11,24 @@
  *
  * This is the git path ONLY. Conflicting reverts are handed back to the
  * caller/UI unresolved — the AI-undo fallback is sibling task FN-7524, and the
- * UI affordance is sibling task FN-7525. Multi-repo workspace-task revert is
- * out of scope here (see `resolveTaskRevertCommits`'s workspace guard).
+ * UI affordance is sibling task FN-7525.
+ *
+ * FNXC:TaskRevert 2026-07-04-00:00 (FN-7547 — workspace/multi-repo support):
+ * Workspace tasks (`task.workspaceWorktrees` populated, see `isWorkspaceTask`)
+ * land squash commits across MULTIPLE sub-repo integration branches. This
+ * module reasons about the WHOLE task's revert as one ALL-OR-NOTHING unit:
+ * `resolveWorkspaceTaskRevertCommits` resolves per-repo attribution,
+ * `revertWorkspaceTask` dry-run classifies EVERY sub-repo first and only
+ * commits a revert on ANY sub-repo when EVERY acquired sub-repo classifies
+ * clean/already-reverted. If any sub-repo conflicts, NO sub-repo is committed
+ * and every touched sub-repo worktree is rolled back byte-identical to its
+ * pre-call state — see `revertWorkspaceTask`'s doc comment for the full
+ * contract. The single-repo path below (`resolveTaskRevertCommits` /
+ * `classifyTaskRevert` / `performTaskRevert`) is UNCHANGED and continues to
+ * serve non-workspace tasks; `revertWorkspaceTask` reuses its dry-run
+ * (`classifyTaskRevert`) and apply/commit (`applyAndCommitRevert`) machinery
+ * per sub-repo rather than duplicating it. `granularity` (FN-7548, below)
+ * only applies to the single-repo path.
  *
  * Safety invariant (the core contract of this module): the working tree and
  * index are NEVER left dirty on any failure path. `classifyTaskRevert` always
@@ -21,8 +37,11 @@
  * `finally` block, regardless of how the dry-run terminates.
  */
 import { exec } from "node:child_process";
+import { join } from "node:path";
 import { promisify } from "node:util";
-import type { Task, TaskCommitAssociation, TaskCreateInput } from "@fusion/core";
+import { isWorkspaceTask, type Task, type TaskCommitAssociation, type TaskCreateInput } from "@fusion/core";
+import { collectOwnTaskCommitsForRange } from "./branch-attribution.js";
+import { resolveIntegrationBranch, type IntegrationBranchSettings } from "./integration-branch.js";
 
 const defaultExecAsync = promisify(exec);
 type ExecAsyncImpl = typeof defaultExecAsync;
@@ -433,7 +452,7 @@ export type TaskRevertResult =
 export type TaskRevertGranularity = "squash" | "per-sha";
 
 export interface PerformTaskRevertOptions {
-  task: Pick<Task, "id" | "lineageId" | "column" | "mergeDetails" | "autoMerge" | "userPaused" | "paused">;
+  task: Pick<Task, "id" | "lineageId" | "column" | "mergeDetails" | "autoMerge" | "userPaused" | "paused" | "workspaceWorktrees">;
   worktreePath: string;
   baseBranch: string;
   execAsyncImpl?: ExecAsyncImpl;
@@ -477,6 +496,16 @@ export async function performTaskRevert(opts: PerformTaskRevertOptions): Promise
   const { task, worktreePath, baseBranch: _baseBranch } = opts;
   const execImpl = opts.execAsyncImpl ?? defaultExecAsync;
 
+  // FNXC:TaskRevert 2026-07-04-00:00 (FN-7547 dispatch guard): this function
+  // is the single-repo entry point ONLY. Workspace tasks (`isWorkspaceTask`)
+  // must be routed by the caller to `revertWorkspaceTask` instead — refuse
+  // explicitly here (rather than silently reverting one arbitrary sub-repo)
+  // so a caller that forgets to check `isWorkspaceTask` first gets a clear
+  // signal instead of a half-coherent single-repo revert.
+  if (isWorkspaceTask(task)) {
+    return { mode: "git", unsupported: true, reason: "workspace-task-revert-unsupported-by-single-repo-path; use revertWorkspaceTask" };
+  }
+
   if (!REVERTABLE_COLUMNS.has(task.column)) {
     return { mode: "git", needsHuman: true, reason: `task is in column "${task.column}"; only done/archived tasks are revertable` };
   }
@@ -631,6 +660,417 @@ export async function performTaskRevert(opts: PerformTaskRevertOptions): Promise
   }
 }
 
+// ---------------------------------------------------------------------------
+// FN-7547: workspace/multi-repo task revert support.
+// ---------------------------------------------------------------------------
+
+/**
+ * FNXC:TaskRevert 2026-07-04-00:00 (extracted for FN-7547 reuse):
+ * The squash-granularity apply+commit phase, factored out so the workspace
+ * multi-repo path (`revertWorkspaceTask`) can run the IDENTICAL single-repo
+ * apply/commit machinery once per sub-repo, keeping the commit message/trailer
+ * contract and the live-conflict-during-apply rollback identical between the
+ * single-repo and workspace paths. Built on the same `applyRevertNoCommit`
+ * shared primitive `performTaskRevert`'s squash branch uses above — it is NOT
+ * a second reimplementation. Callers MUST have already run `classifyTaskRevert`
+ * and confirmed "clean" for these `commits` — this function does not
+ * re-classify; it assumes the dry-run already proved the revert applies
+ * cleanly and only guards against the branch moving between classify and
+ * apply (a live conflict here rolls back THIS repo/worktree only — the caller
+ * is responsible for any cross-repo rollback in the workspace all-or-nothing
+ * contract). `granularity` (FN-7548) does not apply to the workspace path;
+ * this always produces one commit per sub-repo.
+ */
+async function applyAndCommitRevert(opts: {
+  worktreePath: string;
+  /** Attributable commit SHAs, newest first. */
+  commits: string[];
+  taskId: string;
+  execAsyncImpl?: ExecAsyncImpl;
+}): Promise<
+  | { applied: true; revertCommitSha: string }
+  | { applied: false; alreadyReverted: true }
+  | { applied: false; conflicts: TaskRevertConflict[] }
+> {
+  const { worktreePath, commits, taskId } = opts;
+  const execImpl = opts.execAsyncImpl ?? defaultExecAsync;
+
+  let preRevertHead: string;
+  try {
+    const { stdout } = await runGit(execImpl, "git rev-parse HEAD", worktreePath);
+    preRevertHead = stdout.trim();
+  } catch (error) {
+    throw new TaskRevertError("failed to resolve HEAD before applying revert", "head-resolve-failed", error);
+  }
+
+  let mutated = false;
+  let anyStaged = false;
+  try {
+    for (const sha of commits) {
+      mutated = true;
+      const outcome = await applyRevertNoCommit(execImpl, worktreePath, sha);
+      if (outcome.kind === "conflict") {
+        await runGit(execImpl, "git revert --abort", worktreePath).catch(() => undefined);
+        await runGit(execImpl, `git reset --hard ${quoteShellArg(preRevertHead)}`, worktreePath).catch(() => undefined);
+        return { applied: false, conflicts: outcome.conflicts };
+      }
+      if (outcome.kind === "staged") anyStaged = true;
+    }
+
+    if (!anyStaged) {
+      // Defensive: every sha in this batch turned out to be a no-op during the
+      // apply pass even though classify saw at least one real change (branch
+      // moved between classify and apply, or a race). Nothing to commit —
+      // report already-reverted rather than attempting an empty commit.
+      return { applied: false, alreadyReverted: true };
+    }
+
+    let originalSubject = "";
+    try {
+      const { stdout } = await runGit(execImpl, `git log -1 --format=%s ${quoteShellArg(commits[0] ?? "HEAD")}`, worktreePath);
+      originalSubject = stdout.trim();
+    } catch {
+      originalSubject = "";
+    }
+
+    const shortSummary = deriveShortSummary(originalSubject);
+    const subject = `revert(${taskId}): ${shortSummary}`;
+    const referencedSha = commits[0] ?? "unknown";
+    const body1 = `Fusion-Task-Id: ${taskId}`;
+    const body2 = `Reverts work landed by task ${taskId} (${originalSubject || referencedSha} @ ${referencedSha.slice(0, 8)}).`;
+
+    await runGit(
+      execImpl,
+      `git commit -m ${quoteShellArg(subject)} -m ${quoteShellArg(body1)} -m ${quoteShellArg(body2)}`,
+      worktreePath,
+    );
+
+    const { stdout: newHead } = await runGit(execImpl, "git rev-parse HEAD", worktreePath);
+    return { applied: true, revertCommitSha: newHead.trim() };
+  } catch (error) {
+    if (mutated) {
+      await runGit(execImpl, "git revert --abort", worktreePath).catch(() => undefined);
+      await runGit(execImpl, `git reset --hard ${quoteShellArg(preRevertHead)}`, worktreePath).catch(() => undefined);
+    }
+    throw error instanceof TaskRevertError ? error : new TaskRevertError("failed to apply revert commit", "revert-apply-failed", error);
+  }
+}
+
+export interface WorkspaceRepoRevertCommits {
+  commits: string[];
+  source: TaskRevertCommitSource;
+}
+
+export interface ResolveWorkspaceTaskRevertCommitsOptions {
+  workspaceRootDir: string;
+  execAsyncImpl?: ExecAsyncImpl;
+  /** Lineage-snapshot fallback source (typically the scoped TaskStore). */
+  commitAssociationSource?: TaskCommitAssociationSource;
+}
+
+/**
+ * FNXC:TaskRevert 2026-07-04-00:00 (FN-7547 per-repo attribution):
+ * Resolves the attributable commit(s) for EACH sub-repo of a workspace task,
+ * keyed by repo-relative path, iterating `Object.keys(task.workspaceWorktrees)
+ * .sort()` for the SAME deterministic order `landWorkspaceTask`/self-healing
+ * use (KTD1) — this determinism matters because Step 2/3's all-or-nothing
+ * commit ordering depends on a stable, reproducible repo iteration order.
+ *
+ * Precedence per sub-repo (mirrors the single-repo precedence in
+ * `resolveTaskRevertCommits`, adapted to the workspace land model where each
+ * sub-repo has its own representative squash sha rather than one task-wide
+ * `mergeDetails.commitSha`):
+ *   1. Squash — `mergeDetails.workspaceLandedShas[repoRel]` alone, when the
+ *      sub-repo's `workspaceWorktrees[repoRel].baseCommitSha` is unset (the
+ *      representative squash sha landed the entire sub-repo's contribution).
+ *   2. Rebase/range — when `baseCommitSha` IS set, filter the range
+ *      `baseCommitSha..landedSha` to this task's own commits via
+ *      `collectOwnTaskCommitsForRange` (shared with branch-attribution.ts),
+ *      falling back to the range endpoint (`landedSha`) when no per-commit
+ *      attribution is possible.
+ *   3. Lineage snapshot fallback — `TaskCommitAssociation` rows keyed by
+ *      `taskLineageId`, filtered to commits that are reachable in THIS
+ *      sub-repo (`git cat-file -e <sha>`) — a lineage snapshot is task-wide,
+ *      not per-repo, so it must be filtered per sub-repo to avoid attributing
+ *      another sub-repo's commit here.
+ */
+export async function resolveWorkspaceTaskRevertCommits(
+  task: Pick<Task, "id" | "lineageId" | "mergeDetails" | "workspaceWorktrees">,
+  opts: ResolveWorkspaceTaskRevertCommitsOptions,
+): Promise<Record<string, WorkspaceRepoRevertCommits>> {
+  const execImpl = opts.execAsyncImpl ?? defaultExecAsync;
+  const workspaceWorktrees = task.workspaceWorktrees ?? {};
+  const repoKeys = Object.keys(workspaceWorktrees).sort();
+  const workspaceLandedShas = task.mergeDetails?.workspaceLandedShas ?? {};
+
+  const result: Record<string, WorkspaceRepoRevertCommits> = {};
+
+  for (const repoRel of repoKeys) {
+    const entry = workspaceWorktrees[repoRel];
+    const repoRootDir = join(opts.workspaceRootDir, repoRel);
+    const landedSha = workspaceLandedShas[repoRel] ?? entry?.landedSha;
+
+    if (landedSha && !entry?.baseCommitSha) {
+      result[repoRel] = { commits: [landedSha], source: "squash" };
+      continue;
+    }
+
+    if (landedSha && entry?.baseCommitSha) {
+      const rangeRef = `${entry.baseCommitSha}..${landedSha}`;
+      let ownCommitShas: string[];
+      try {
+        const collected = await collectOwnTaskCommitsForRange({
+          worktreePath: repoRootDir,
+          rangeRef,
+          taskId: task.id,
+          execAsyncImpl: execImpl,
+        });
+        ownCommitShas = collected.ownCommitShas;
+      } catch (error) {
+        throw new TaskRevertError(`git log failed for sub-repo ${repoRel} range ${rangeRef}`, "git-log-failed", error);
+      }
+      if (ownCommitShas.length > 0) {
+        result[repoRel] = { commits: ownCommitShas, source: "rebase" };
+      } else {
+        result[repoRel] = { commits: [landedSha], source: "rebase" };
+      }
+      continue;
+    }
+
+    // No representative landed sha recorded for this sub-repo — fall back to
+    // the lineage-snapshot association table, filtered to commits reachable
+    // in THIS sub-repo (a lineage snapshot is task-wide, not per-repo).
+    const lineageId = task.lineageId ?? task.id;
+    if (!opts.commitAssociationSource) {
+      result[repoRel] = { commits: [], source: "none" };
+      continue;
+    }
+    const associations = await opts.commitAssociationSource.getTaskCommitAssociationsByLineageId(lineageId);
+    const reachableShas: string[] = [];
+    for (const association of associations) {
+      try {
+        await runGit(execImpl, `git cat-file -e ${quoteShellArg(`${association.commitSha}^{commit}`)}`, repoRootDir);
+        reachableShas.push(association.commitSha);
+      } catch {
+        // Not reachable in this sub-repo — belongs to another sub-repo or is stale.
+      }
+    }
+    result[repoRel] = { commits: reachableShas, source: reachableShas.length > 0 ? "lineage" : "none" };
+  }
+
+  return result;
+}
+
+export interface WorkspaceRepoRevertResult {
+  repo: string;
+  classification: TaskRevertClassification;
+  revertCommitSha?: string;
+  conflicts?: TaskRevertConflict[];
+  alreadyReverted?: boolean;
+}
+
+export type WorkspaceTaskRevertResult =
+  | { mode: "git"; clean: true; workspace: { repos: WorkspaceRepoRevertResult[] } }
+  | { mode: "git"; clean: false; workspace: { repos: WorkspaceRepoRevertResult[] }; conflicts: (TaskRevertConflict & { repo: string })[] }
+  | { mode: "git"; unsupported: true; reason: string }
+  | { mode: "git"; needsHuman: true; reason: string };
+
+export interface RevertWorkspaceTaskOptions {
+  task: Pick<Task, "id" | "lineageId" | "column" | "mergeDetails" | "workspaceWorktrees" | "autoMerge" | "userPaused" | "paused">;
+  /** Project root dir; each sub-repo lives at `join(workspaceRootDir, repoRel)` (mirrors `landWorkspaceTask`). */
+  workspaceRootDir: string;
+  /** Project settings, passed through to `resolveIntegrationBranch` per sub-repo with `integrationBranch`/`baseBranch` stripped (KTD1 — each sub-repo resolves its OWN default). */
+  settings: IntegrationBranchSettings;
+  execAsyncImpl?: ExecAsyncImpl;
+  commitAssociationSource?: TaskCommitAssociationSource;
+  /** Resolved effective project autoMerge setting (task.autoMerge overrides this when set). Defaults to true (autoMerge on) when omitted. */
+  effectiveAutoMerge?: boolean;
+}
+
+interface WorkspaceRepoRevertContext {
+  repo: string;
+  repoRootDir: string;
+  preRevertHead: string;
+  commits: string[];
+  classification: ClassifyTaskRevertResult;
+}
+
+/**
+ * FNXC:TaskRevert 2026-07-04-00:00 (FN-7547 — the core safety invariant of
+ * this module's workspace path):
+ *
+ * ALL-OR-NOTHING WHOLE-TASK CLASSIFICATION: this function dry-run classifies
+ * EVERY sub-repo FIRST (via the shared `classifyTaskRevert`, which already
+ * guarantees a byte-identical per-repo rollback in its own `finally`). The
+ * whole task is `clean` iff EVERY acquired sub-repo classifies clean or
+ * already-reverted; if ANY sub-repo classifies conflicting, the whole task is
+ * `conflicting` and the commit phase never runs for ANY sub-repo.
+ *
+ * TWO-PHASE COMMIT ORDERING: only after every sub-repo classifies
+ * clean/already-reverted does this function re-apply and commit per repo
+ * (reusing `applyAndCommitRevert`, the same machinery `performTaskRevert`
+ * uses for the single-repo squash path). This classify-all-then-commit-all
+ * ordering means a late conflict (the sub-repo's branch moved between
+ * classify and apply) can only ever occur DURING the commit phase, never
+ * invalidating an already-clean classification from an earlier repo in the
+ * same pass.
+ *
+ * MULTI-REPO ROLLBACK GUARANTEE: if a LATER sub-repo conflicts during the
+ * commit phase after an EARLIER sub-repo in this same pass already committed,
+ * every already-committed sub-repo is rolled back (`git revert --abort` +
+ * `git reset --hard <preRevertHead>`) before returning — so a late conflict
+ * can never leave some sub-repos reverted while others are not. Every touched
+ * sub-repo worktree is guaranteed byte-identical to its pre-call state on any
+ * non-success path.
+ *
+ * GUARD RAILS (mirrors `performTaskRevert`): only done/archived tasks are
+ * revertable; `autoMerge:false` refuses with `needsHuman` instead of forcing
+ * a write; this function NEVER mutates the source task's store row/column.
+ */
+export async function revertWorkspaceTask(opts: RevertWorkspaceTaskOptions): Promise<WorkspaceTaskRevertResult> {
+  const { task, workspaceRootDir } = opts;
+  const execImpl = opts.execAsyncImpl ?? defaultExecAsync;
+
+  if (!REVERTABLE_COLUMNS.has(task.column)) {
+    return { mode: "git", needsHuman: true, reason: `task is in column "${task.column}"; only done/archived tasks are revertable` };
+  }
+
+  const effectiveAutoMerge = task.autoMerge ?? opts.effectiveAutoMerge ?? true;
+  if (effectiveAutoMerge === false) {
+    return { mode: "git", needsHuman: true, reason: "autoMerge is disabled for this task/project; refusing to force-write a revert commit" };
+  }
+
+  const workspaceWorktrees = task.workspaceWorktrees ?? {};
+  const repoKeys = Object.keys(workspaceWorktrees).sort();
+  if (repoKeys.length === 0) {
+    return { mode: "git", unsupported: true, reason: "task has no workspaceWorktrees entries; not a workspace task" };
+  }
+
+  const attribution = await resolveWorkspaceTaskRevertCommits(task, {
+    workspaceRootDir,
+    execAsyncImpl: execImpl,
+    commitAssociationSource: opts.commitAssociationSource,
+  });
+
+  // Phase 1: resolve each sub-repo's integration branch, capture its
+  // pre-revert HEAD, refuse (without mutating) on a dirty tree, then dry-run
+  // classify. classifyTaskRevert already guarantees its OWN byte-identical
+  // rollback per repo, so no additional rollback bookkeeping is needed here
+  // for the classify phase itself.
+  const contexts: WorkspaceRepoRevertContext[] = [];
+  for (const repoRel of repoKeys) {
+    const repoRootDir = join(workspaceRootDir, repoRel);
+
+    // Re-resolve THIS sub-repo's integration branch with the shared overrides
+    // stripped (KTD1), mirroring `landWorkspaceTask`/self-healing, so each
+    // sub-repo resolves its own default rather than inheriting a workspace-wide override.
+    let integrationBranch: string;
+    try {
+      integrationBranch = await resolveIntegrationBranch(repoRootDir, { ...opts.settings, integrationBranch: undefined, baseBranch: undefined });
+    } catch (error) {
+      throw new TaskRevertError(`failed to resolve integration branch for sub-repo ${repoRel}`, "integration-branch-resolve-failed", error);
+    }
+
+    // FNXC:TaskRevert 2026-07-04-00:00: each sub-repo checkout under
+    // `workspaceRootDir` can legitimately sit on any branch (mirrors the
+    // single-repo route's `rootDir` branch-mismatch guard) — refuse rather
+    // than silently committing a revert onto the wrong branch.
+    const currentBranch = (await runGit(execImpl, "git rev-parse --abbrev-ref HEAD", repoRootDir)).stdout.trim();
+    if (currentBranch !== integrationBranch) {
+      throw new TaskRevertError(
+        `sub-repo ${repoRel} checkout is on "${currentBranch}", not its integration branch "${integrationBranch}"; switch to "${integrationBranch}" before reverting`,
+        "branch-mismatch",
+      );
+    }
+
+    const { stdout: statusOut } = await runGit(execImpl, "git status --porcelain", repoRootDir);
+    if (statusOut.trim().length > 0) {
+      throw new TaskRevertError(
+        `working tree for sub-repo ${repoRel} is dirty; refusing to attempt a revert dry-run`,
+        "dirty-working-tree",
+      );
+    }
+
+    const { stdout: headOut } = await runGit(execImpl, "git rev-parse HEAD", repoRootDir);
+    const preRevertHead = headOut.trim();
+
+    const commits = attribution[repoRel]?.commits ?? [];
+    const classification = await classifyTaskRevert({ worktreePath: repoRootDir, commits, execAsyncImpl: execImpl });
+
+    contexts.push({ repo: repoRel, repoRootDir, preRevertHead, commits, classification });
+  }
+
+  const anyConflicting = contexts.some((ctx) => ctx.classification.classification === "conflicting");
+  if (anyConflicting) {
+    const repos: WorkspaceRepoRevertResult[] = contexts.map((ctx) => ({
+      repo: ctx.repo,
+      classification: ctx.classification.classification,
+      conflicts: ctx.classification.conflicts,
+      alreadyReverted: ctx.classification.alreadyReverted,
+    }));
+    const conflicts = contexts.flatMap((ctx) =>
+      (ctx.classification.conflicts ?? []).map((conflict) => ({ ...conflict, repo: ctx.repo })),
+    );
+    return { mode: "git", clean: false, workspace: { repos }, conflicts };
+  }
+
+  // Phase 2: every sub-repo classified clean/already-reverted — apply+commit
+  // per repo. Track committed repos so a LATE conflict (branch moved between
+  // classify and apply) can roll back every already-committed sub-repo too.
+  const repos: WorkspaceRepoRevertResult[] = [];
+  const committedRepos: { repo: string; repoRootDir: string; preRevertHead: string }[] = [];
+
+  try {
+    for (const ctx of contexts) {
+      if (ctx.classification.classification === "already-reverted" || ctx.commits.length === 0) {
+        repos.push({ repo: ctx.repo, classification: "already-reverted", alreadyReverted: true });
+        continue;
+      }
+
+      const applied = await applyAndCommitRevert({
+        worktreePath: ctx.repoRootDir,
+        commits: ctx.commits,
+        taskId: task.id,
+        execAsyncImpl: execImpl,
+      });
+
+      if (applied.applied) {
+        repos.push({ repo: ctx.repo, classification: "clean", revertCommitSha: applied.revertCommitSha });
+        committedRepos.push({ repo: ctx.repo, repoRootDir: ctx.repoRootDir, preRevertHead: ctx.preRevertHead });
+        continue;
+      }
+
+      if ("alreadyReverted" in applied) {
+        repos.push({ repo: ctx.repo, classification: "already-reverted", alreadyReverted: true });
+        continue;
+      }
+
+      // Late conflict — applyAndCommitRevert already rolled back THIS repo.
+      // Roll back every PREVIOUSLY committed sub-repo in this pass so the
+      // whole-task revert stays all-or-nothing.
+      for (const committed of committedRepos) {
+        await runGit(execImpl, "git revert --abort", committed.repoRootDir).catch(() => undefined);
+        await runGit(execImpl, `git reset --hard ${quoteShellArg(committed.preRevertHead)}`, committed.repoRootDir).catch(() => undefined);
+      }
+      const conflictRepos: WorkspaceRepoRevertResult[] = [
+        ...repos,
+        { repo: ctx.repo, classification: "conflicting", conflicts: applied.conflicts },
+      ];
+      const conflicts = (applied.conflicts ?? []).map((conflict) => ({ ...conflict, repo: ctx.repo }));
+      return { mode: "git", clean: false, workspace: { repos: conflictRepos }, conflicts };
+    }
+  } catch (error) {
+    // Unexpected failure mid-pass — roll back every already-committed sub-repo.
+    for (const committed of committedRepos) {
+      await runGit(execImpl, "git revert --abort", committed.repoRootDir).catch(() => undefined);
+      await runGit(execImpl, `git reset --hard ${quoteShellArg(committed.preRevertHead)}`, committed.repoRootDir).catch(() => undefined);
+    }
+    throw error instanceof TaskRevertError ? error : new TaskRevertError("failed to apply workspace revert", "workspace-revert-apply-failed", error);
+  }
+
+  return { mode: "git", clean: true, workspace: { repos } };
+}
+
 // ────────────────────────────────────────────────────────────────────────
 // FN-7524: AI-undo fallback
 // ────────────────────────────────────────────────────────────────────────

From 6d364fc407891e6a2426cbc6514b4bfae648c07d Mon Sep 17 00:00:00 2001
From: gsxdsm <gsxdsm@users.noreply.github.com>
Date: Sat, 4 Jul 2026 22:26:50 -0700
Subject: [PATCH 08/65] FN-7560: move mobile terminal controls to footer with
 scrollable shortcuts

Relocates the mobile (<=768px) terminal action cluster from the header into a new bottom footer bar and ensures the shortcut key row can scroll horizontally without clipping.

- Add terminal-footer-actions bar for mobile viewports, keeping desktop/floating/pinned-below header layout (FN-7502) unchanged
- Apply min-width:0 and overflow-x:auto to the footer actions cluster so it no longer crowds the header
- Preserve the FN-7550 shortcut-panel horizontal scroll fix
- Update TerminalModal and mobile header-row tests to cover the new footer layout
- Add changeset documenting the fix

Files changed:
 .changeset/fn-7560-mobile-terminal-footer.md       |   7 +
 .../__tests__/terminal-mobile-header-row.test.ts   |  17 +-
 .../dashboard/app/components/TerminalModal.css     |  46 ++--
 .../dashboard/app/components/TerminalModal.tsx     | 233 +++++++++++++--------
 .../components/__tests__/TerminalModal.test.tsx    | 142 ++++++++++++-
 5 files changed, 331 insertions(+), 114 deletions(-)

Fusion-Task-Id: FN-7560

Fusion-Task-Lineage: 98ffeb22-ec33-419e-987a-18ec98af7aa3

Co-authored-by: Fusion (runfusion.ai) <noreply@runfusion.ai>
---
 .changeset/fn-7560-mobile-terminal-footer.md  |   7 +
 .../terminal-mobile-header-row.test.ts        |  17 +-
 .../app/components/TerminalModal.css          |  46 ++--
 .../app/components/TerminalModal.tsx          | 233 +++++++++++-------
 .../__tests__/TerminalModal.test.tsx          | 142 ++++++++++-
 5 files changed, 331 insertions(+), 114 deletions(-)
 create mode 100644 .changeset/fn-7560-mobile-terminal-footer.md

diff --git a/.changeset/fn-7560-mobile-terminal-footer.md b/.changeset/fn-7560-mobile-terminal-footer.md
new file mode 100644
index 0000000000..94b0877e65
--- /dev/null
+++ b/.changeset/fn-7560-mobile-terminal-footer.md
@@ -0,0 +1,7 @@
+---
+"@runfusion/fusion": patch
+---
+
+summary: Move the mobile terminal controls into a bottom footer so they no longer crowd the header, and keep the shortcut key bar horizontally scrollable.
+category: fix
+dev: On the ≤768px terminal, the `.terminal-actions` cluster now renders in a `terminal-footer-actions` bar (with `min-width:0; overflow-x:auto`) instead of the header; desktop/floating/pinned-below keep the FN-7502 header layout. Preserves the FN-7550 shortcut-panel scroll fix.
diff --git a/packages/dashboard/app/__tests__/terminal-mobile-header-row.test.ts b/packages/dashboard/app/__tests__/terminal-mobile-header-row.test.ts
index 279bf72bed..fccb136c2c 100644
--- a/packages/dashboard/app/__tests__/terminal-mobile-header-row.test.ts
+++ b/packages/dashboard/app/__tests__/terminal-mobile-header-row.test.ts
@@ -33,12 +33,21 @@ describe("terminal mobile header row CSS contract", () => {
     expect(mobileSelectorRule).not.toContain("min-width: 100%");
   });
 
-  it("keeps the action cluster reachable without a second-row divider", () => {
+  it("renders no .terminal-actions shell in the mobile header (FN-7560: actions moved to footer)", () => {
+    // FN-7560: on mobile the action-control cluster no longer lives in the
+    // header (`.terminal-actions`) at all — it moved to a bottom
+    // `.terminal-status-bar` footer so it doesn't crowd the tab dropdown and
+    // close button. The mobile media query must not define a `.terminal-actions`
+    // override any more.
     const ruleBody = findRuleBody(/\.terminal-actions/);
+    expect(ruleBody).toBe("");
+  });
 
-    expect(ruleBody).toContain("order: 3");
-    expect(ruleBody).toContain("flex: 0 0 auto");
-    expect(ruleBody).toContain("border-top: none");
+  it("gives the mobile footer action cluster the horizontal-scroll flex-scroll pattern (FN-7560)", () => {
+    const ruleBody = findRuleBody(/\.terminal-status-bar/);
+
+    expect(ruleBody).toContain("min-width: 0");
+    expect(ruleBody).toContain("overflow-x: auto");
     expect(ruleBody).not.toContain("flex: 1 1 100%");
   });
 
diff --git a/packages/dashboard/app/components/TerminalModal.css b/packages/dashboard/app/components/TerminalModal.css
index 454d2df5ff..14cfeed9bd 100644
--- a/packages/dashboard/app/components/TerminalModal.css
+++ b/packages/dashboard/app/components/TerminalModal.css
@@ -1507,21 +1507,17 @@ The Android keyboard-open recurrence can start with a touch-primary visualViewpo
     max-width: 150px;
   }
 
-  /* Hide the redundant title/status indicator on mobile — .terminal-status-bar shows connection state */
+  /*
+  FNXC:TerminalFooter 2026-07-04-20:00:
+  On mobile the header no longer renders .terminal-title or .terminal-actions at
+  all (FN-7560) — the header keeps only the tab dropdown and close button, and
+  the action controls (incl. connection state) render in the .terminal-status-bar
+  footer at the bottom of the panel instead, so they don't crowd the dropdown.
+  */
   .terminal-title {
     display: none;
   }
 
-  /* Actions stay reachable at the end of the header row and wrap as a unit after the selector/picker when space is exhausted. */
-  .terminal-actions {
-    order: 3;
-    flex: 0 0 auto;
-    justify-content: flex-end;
-    border-top: none;
-    padding: 0 var(--space-xs) 0 0;
-    min-height: 36px;
-  }
-
   /* Hide text labels on action buttons to save space */
   .terminal-action-label {
     display: none;
@@ -1694,9 +1690,31 @@ The Android keyboard-open recurrence can start with a touch-primary visualViewpo
     display: none;
   }
 
-  .terminal-actions {
-    flex-wrap: wrap;
-    justify-content: flex-end;
+  /*
+  FNXC:TerminalFooter 2026-07-04-20:00:
+  FN-7560: on mobile the terminal action controls (font-size, Clear, Shortcuts,
+  Preferences, connection status, exit code) render in this bottom footer bar
+  instead of the header, restoring pre-FN-7502 footer ergonomics so the narrow
+  header only has to fit the tab dropdown and close button. Reuses the same
+  min-width: 0 + overflow-x: auto flex-scroll pattern as .terminal-actions and
+  .terminal-shortcut-panel (FN-7550) so a crowded footer scrolls horizontally
+  instead of clipping/wrapping. padding-bottom composes with the iOS safe-area
+  inset so the bar clears the home indicator; it stays in-flow at the bottom of
+  the panel's flex column, so the .terminal-modal[style*="--keyboard-overlap"]
+  height clamp shrinks .terminal-container (flex: 1) rather than the footer.
+  */
+  .terminal-status-bar {
+    display: flex;
+    align-items: center;
+    flex-wrap: nowrap;
+    gap: var(--space-xs);
+    border-top: 1px solid var(--border);
+    padding: var(--space-xs);
+    padding-bottom: max(var(--space-xs), env(safe-area-inset-bottom, 0));
+    min-height: 36px;
+    min-width: 0;
+    overflow-x: auto;
+    scrollbar-width: thin;
   }
 
   .terminal-shortcuts--header,
diff --git a/packages/dashboard/app/components/TerminalModal.tsx b/packages/dashboard/app/components/TerminalModal.tsx
index e6d3fb98b4..cf9f432a38 100644
--- a/packages/dashboard/app/components/TerminalModal.tsx
+++ b/packages/dashboard/app/components/TerminalModal.tsx
@@ -2194,6 +2194,96 @@ export function TerminalModal({ isOpen, onClose, initialCommand, initialCommandG
       : {}),
   } as CSSProperties;
 
+  /*
+  FNXC:TerminalFooter 2026-07-04-20:00:
+  Single source of truth for the terminal action-control cluster (reconnect/restart,
+  font-size, Clear, Shortcuts toggle, Preferences toggle, connection status, exit code,
+  help text, and the desktop-only pin/pop-out toggles). Rendered in exactly ONE place
+  per breakpoint: inside the header `.terminal-actions` on desktop/floating/pinned-below
+  (FN-7502), or inside a dedicated bottom `.terminal-status-bar` footer on mobile (FN-7560)
+  so the narrow mobile header does not crowd the tab dropdown and close button. Do not
+  duplicate these handlers elsewhere — always render this fragment.
+  */
+  const terminalActionControls = (
+    <>
+      {connectionStatus === "disconnected" && activeTab && (
+        <button
+          className="terminal-reconnect-btn"
+          onClick={reconnect}
+          title={t("terminal.reconnect", "Reconnect")}
+          data-testid="terminal-reconnect-btn"
+        >
+          <RefreshCw size={14} />
+          <span className="terminal-action-label">{t("terminal.reconnect", "Reconnect")}</span>
+        </button>
+      )}
+      {exitCode !== null && (
+        <button
+          className="terminal-restart-btn"
+          onClick={handleRestart}
+          title={t("terminal.newSession", "New Session")}
+          data-testid="terminal-restart-btn"
+        >
+          <RefreshCw size={14} />
+          <span className="terminal-action-label">{t("terminal.newSession", "New Session")}</span>
+        </button>
+      )}
+      <span className="terminal-font-size-controls terminal-font-size-controls--header">
+        <button type="button" className="terminal-font-size-btn" onClick={handleDecreaseFontSize} data-testid="terminal-font-size-decrease" aria-label={t("terminal.decreaseFontSize", "Decrease terminal font size")}>
+          <Minus size={14} />
+        </button>
+        <span className="terminal-font-size-value" data-testid="terminal-font-size-value">{fontSize}{TERMINAL_KEY_LABELS.pxUnit}</span>
+        <button type="button" className="terminal-font-size-btn" onClick={handleIncreaseFontSize} data-testid="terminal-font-size-increase" aria-label={t("terminal.increaseFontSize", "Increase terminal font size")}>
+          <Plus size={14} />
+        </button>
+      </span>
+      <button className="terminal-clear-btn" onClick={handleClear} data-testid="terminal-clear-btn" title={t("terminal.clearTerminal", "Clear terminal")}>
+        <Trash2 size={14} />
+        <span className="terminal-action-label">{t("terminal.clear", "Clear")}</span>
+      </button>
+      <button className="terminal-clear-btn terminal-clear-btn--shortcut" onClick={() => setShowShortcuts((current) => !current)} data-testid="terminal-shortcut-toggle" title={t("terminal.shortcuts", "Shortcuts")} aria-pressed={showShortcuts}>
+        <Keyboard size={14} />
+        <span className="terminal-action-label">{t("terminal.shortcuts", "Shortcuts")}</span>
+      </button>
+      <button className="terminal-clear-btn terminal-clear-btn--shortcut" onClick={() => setShowPreferences((current) => !current)} data-testid="terminal-preferences-toggle" title={t("terminal.preferences", "Preferences")} aria-pressed={showPreferences}>
+        <Settings size={14} />
+        <span className="terminal-action-label">{t("terminal.preferences", "Preferences")}</span>
+      </button>
+      <span className={`terminal-connection-status ${connectionStatus}`}>
+        {connectionStatus === "connected" && t("terminal.statusConnected", "Connected")}
+        {connectionStatus === "connecting" && t("terminal.statusConnecting", "Connecting...")}
+        {connectionStatus === "reconnecting" && t("terminal.statusReconnecting", "Reconnecting...")}
+        {connectionStatus === "disconnected" && t("terminal.statusDisconnected", "Disconnected")}
+      </span>
+      {exitCode !== null && <span className="terminal-exit-code" data-testid="terminal-exit-code">{t("terminal.exitLabel", "Exit: {{code}}", { code: exitCode })}</span>}
+      <span className="terminal-shortcuts terminal-shortcuts--header">{t("terminal.helpText", "Ctrl++/- zoom • ⌨ Shortcuts panel • Esc close")}</span>
+      {!isMobileTerminal && (
+        <button
+          className="terminal-clear-btn terminal-clear-btn--shortcut terminal-clear-btn--icon"
+          onClick={handleToggleBelowMode}
+          data-testid="terminal-pin-toggle"
+          title={isBelowMode ? t("terminal.unpinTerminal", "Unpin terminal (overlay content)") : t("terminal.pinTerminal", "Pin terminal (push content)")}
+          aria-label={isBelowMode ? t("terminal.unpinTerminal", "Unpin terminal (overlay content)") : t("terminal.pinTerminal", "Pin terminal (push content)")}
+          aria-pressed={isBelowMode}
+        >
+          {isBelowMode ? <PinOff size={14} /> : <Pin size={14} />}
+        </button>
+      )}
+      {!isMobileTerminal && (
+        <button
+          className="terminal-clear-btn terminal-clear-btn--shortcut terminal-clear-btn--icon"
+          onClick={handleToggleDisplayMode}
+          data-testid="terminal-popout-toggle"
+          title={displayMode === "floating" ? t("terminal.dockTerminal", "Dock terminal") : t("terminal.popOutTerminal", "Pop out terminal")}
+          aria-label={displayMode === "floating" ? t("terminal.dockTerminal", "Dock terminal") : t("terminal.popOutTerminal", "Pop out terminal")}
+          aria-pressed={displayMode === "floating"}
+        >
+          {displayMode === "floating" ? <Minimize2 size={14} /> : <Maximize2 size={14} />}
+        </button>
+      )}
+    </>
+  );
+
   const terminalPanel = (
     <div
       ref={modalRef}
@@ -2428,98 +2518,18 @@ export function TerminalModal({ isOpen, onClose, initialCommand, initialCommandG
             </div>
           )}
           
-          {/* Status indicator */}
-          <div className="terminal-title" data-testid="terminal-title">
-            <TerminalIcon size={16} />
-            {getStatusIndicator()}
-          </div>
-          
-          {/* Actions — labels hidden on mobile via .terminal-action-label */}
-          <div className="terminal-actions" data-testid="terminal-actions">
-            {connectionStatus === "disconnected" && activeTab && (
-              <button
-                className="terminal-reconnect-btn"
-                onClick={reconnect}
-                title={t("terminal.reconnect", "Reconnect")}
-                data-testid="terminal-reconnect-btn"
-              >
-                <RefreshCw size={14} />
-                <span className="terminal-action-label">{t("terminal.reconnect", "Reconnect")}</span>
-              </button>
-            )}
-            {exitCode !== null && (
-              <button
-                className="terminal-restart-btn"
-                onClick={handleRestart}
-                title={t("terminal.newSession", "New Session")}
-                data-testid="terminal-restart-btn"
-              >
-                <RefreshCw size={14} />
-                <span className="terminal-action-label">{t("terminal.newSession", "New Session")}</span>
-              </button>
-            )}
-            {/*
-            FNXC:TerminalHeader 2026-07-04-19:16:
-            Footer controls live in the terminal header so docked, floating, pinned-below, and mobile layouts keep terminal actions reachable without spending a separate footer row. The pin button mirrors the right sidebar contract: aria-pressed means the persistent below-application push layout is active.
-            */}
-            <span className="terminal-font-size-controls terminal-font-size-controls--header">
-              <button type="button" className="terminal-font-size-btn" onClick={handleDecreaseFontSize} data-testid="terminal-font-size-decrease" aria-label={t("terminal.decreaseFontSize", "Decrease terminal font size")}>
-                <Minus size={14} />
-              </button>
-              <span className="terminal-font-size-value" data-testid="terminal-font-size-value">{fontSize}{TERMINAL_KEY_LABELS.pxUnit}</span>
-              <button type="button" className="terminal-font-size-btn" onClick={handleIncreaseFontSize} data-testid="terminal-font-size-increase" aria-label={t("terminal.increaseFontSize", "Increase terminal font size")}>
-                <Plus size={14} />
-              </button>
-            </span>
-            <button className="terminal-clear-btn" onClick={handleClear} data-testid="terminal-clear-btn" title={t("terminal.clearTerminal", "Clear terminal")}>
-              <Trash2 size={14} />
-              <span className="terminal-action-label">{t("terminal.clear", "Clear")}</span>
-            </button>
-            <button className="terminal-clear-btn terminal-clear-btn--shortcut" onClick={() => setShowShortcuts((current) => !current)} data-testid="terminal-shortcut-toggle" title={t("terminal.shortcuts", "Shortcuts")} aria-pressed={showShortcuts}>
-              <Keyboard size={14} />
-              <span className="terminal-action-label">{t("terminal.shortcuts", "Shortcuts")}</span>
-            </button>
-            <button className="terminal-clear-btn terminal-clear-btn--shortcut" onClick={() => setShowPreferences((current) => !current)} data-testid="terminal-preferences-toggle" title={t("terminal.preferences", "Preferences")} aria-pressed={showPreferences}>
-              <Settings size={14} />
-              <span className="terminal-action-label">{t("terminal.preferences", "Preferences")}</span>
-            </button>
-            <span className={`terminal-connection-status ${connectionStatus}`}>
-              {connectionStatus === "connected" && t("terminal.statusConnected", "Connected")}
-              {connectionStatus === "connecting" && t("terminal.statusConnecting", "Connecting...")}
-              {connectionStatus === "reconnecting" && t("terminal.statusReconnecting", "Reconnecting...")}
-              {connectionStatus === "disconnected" && t("terminal.statusDisconnected", "Disconnected")}
-            </span>
-            {exitCode !== null && <span className="terminal-exit-code" data-testid="terminal-exit-code">{t("terminal.exitLabel", "Exit: {{code}}", { code: exitCode })}</span>}
-            <span className="terminal-shortcuts terminal-shortcuts--header">{t("terminal.helpText", "Ctrl++/- zoom • ⌨ Shortcuts panel • Esc close")}</span>
-            {!isMobileTerminal && (
-              <button
-                className="terminal-clear-btn terminal-clear-btn--shortcut terminal-clear-btn--icon"
-                onClick={handleToggleBelowMode}
-                data-testid="terminal-pin-toggle"
-                title={isBelowMode ? t("terminal.unpinTerminal", "Unpin terminal (overlay content)") : t("terminal.pinTerminal", "Pin terminal (push content)")}
-                aria-label={isBelowMode ? t("terminal.unpinTerminal", "Unpin terminal (overlay content)") : t("terminal.pinTerminal", "Pin terminal (push content)")}
-                aria-pressed={isBelowMode}
-              >
-                {isBelowMode ? <PinOff size={14} /> : <Pin size={14} />}
-              </button>
-            )}
-            {/*
-            FNXC:Terminal 2026-06-23-00:15:
-            Clear / Shortcuts / Preferences moved OUT of the header actions and DOWN into the bottom status bar (footer) next to the text-size control, so the header keeps only contextual reconnect/restart, the icon-only pop-out toggle, and close.
-            The pop-out/dock toggle is now ICON-ONLY (no visible "Pop out"/"Dock" text); the icon flips and the title/aria-label still announce the toggle target for accessibility.
-            */}
-            {!isMobileTerminal && (
-              <button
-                className="terminal-clear-btn terminal-clear-btn--shortcut terminal-clear-btn--icon"
-                onClick={handleToggleDisplayMode}
-                data-testid="terminal-popout-toggle"
-                title={displayMode === "floating" ? t("terminal.dockTerminal", "Dock terminal") : t("terminal.popOutTerminal", "Pop out terminal")}
-                aria-label={displayMode === "floating" ? t("terminal.dockTerminal", "Dock terminal") : t("terminal.popOutTerminal", "Pop out terminal")}
-                aria-pressed={displayMode === "floating"}
-              >
-                {displayMode === "floating" ? <Minimize2 size={14} /> : <Maximize2 size={14} />}
-              </button>
-            )}
+          {/*
+          FNXC:TerminalFooter 2026-07-04-20:00:
+          On desktop/floating/pinned-below the header keeps its FN-7502 shape:
+          status title + `.terminal-actions` (rendering the shared
+          `terminalActionControls` fragment) + close. On mobile (isMobileTerminal)
+          the header renders ONLY the close button here — no `.terminal-actions`
+          shell — because the mobile tab dropdown already occupies the header and
+          the action controls move into the `.terminal-status-bar` footer below
+          (FN-7560) so they don't crowd the dropdown/close. Both sites render the
+          SAME fragment, never a duplicated copy, so handlers cannot drift.
+          */}
+          {isMobileTerminal ? (
             <button
               className="terminal-close"
               onClick={onClose}
@@ -2528,7 +2538,28 @@ export function TerminalModal({ isOpen, onClose, initialCommand, initialCommandG
             >
               <X size={20} />
             </button>
-          </div>
+          ) : (
+            <>
+              {/* Status indicator */}
+              <div className="terminal-title" data-testid="terminal-title">
+                <TerminalIcon size={16} />
+                {getStatusIndicator()}
+              </div>
+
+              {/* Actions — labels hidden on mobile via .terminal-action-label */}
+              <div className="terminal-actions" data-testid="terminal-actions">
+                {terminalActionControls}
+                <button
+                  className="terminal-close"
+                  onClick={onClose}
+                  data-testid="terminal-close-btn"
+                  title={t("terminal.closeTerminal", "Close terminal")}
+                >
+                  <X size={20} />
+                </button>
+              </div>
+            </>
+          )}
         </div>
 
         {/* Error message */}
@@ -2798,6 +2829,22 @@ export function TerminalModal({ isOpen, onClose, initialCommand, initialCommandG
           </div>
         )}
 
+        {/*
+        FNXC:TerminalFooter 2026-07-04-20:00:
+        Mobile-only footer bar (FN-7560) restoring the pre-FN-7502 footer
+        ergonomics: the same `terminalActionControls` fragment used by the
+        desktop header renders here instead so font-size/Clear/Shortcuts/
+        Preferences/connection-status/exit-code stay reachable without
+        crowding the mobile header's tab dropdown and close button. Scrolls
+        horizontally (min-width: 0 + overflow-x: auto) if controls exceed the
+        viewport width, matching the .terminal-shortcut-panel (FN-7550) pattern.
+        */}
+        {isMobileTerminal && (
+          <div className="terminal-status-bar" data-testid="terminal-footer-actions">
+            {terminalActionControls}
+          </div>
+        )}
+
     </div>
   );
 
diff --git a/packages/dashboard/app/components/__tests__/TerminalModal.test.tsx b/packages/dashboard/app/components/__tests__/TerminalModal.test.tsx
index 321091101e..a2a3b80f12 100644
--- a/packages/dashboard/app/components/__tests__/TerminalModal.test.tsx
+++ b/packages/dashboard/app/components/__tests__/TerminalModal.test.tsx
@@ -680,13 +680,26 @@ describe("TerminalModal", () => {
   it("encodes below-terminal in-flow layout without fixed overlay geometry", () => {
     const hostRule = terminalModalCss.match(/\.terminal-below-host\s*\{([^}]*)\}/)?.[1] ?? "";
     const belowRule = terminalModalCss.match(/\.modal\.terminal-modal\.terminal-modal--below\s*\{([^}]*)\}/)?.[1] ?? "";
-    const footerShellRule = terminalModalCss.match(/\.terminal-status-bar\s*\{/);
 
     expect(hostRule).toContain("display: flex;");
     expect(belowRule).toContain("position: relative;");
     expect(belowRule).not.toContain("position: fixed;");
     expect(belowRule).toContain("height: var(--terminal-below-height);");
-    expect(footerShellRule).toBeNull();
+
+    // FN-7560: the `.terminal-status-bar` footer is a MOBILE-ONLY affordance
+    // (isMobileTerminal, which itself excludes below mode) — it must exist only
+    // scoped inside a `@media (max-width: 768px)` block, never as a global/
+    // unscoped rule that could leak a footer shell into desktop/floating/
+    // pinned-below. Strip every mobile media-query block out of the
+    // stylesheet and confirm no `.terminal-status-bar` rule remains outside it.
+    const cssWithoutMobileMediaBlocks = terminalModalCss.replace(
+      /@media \(max-width: 768px\) \{(?:[^{}]*\{[^{}]*\})*[^{}]*\}/g,
+      "",
+    );
+    expect(cssWithoutMobileMediaBlocks).not.toMatch(/\.terminal-status-bar\s*\{/);
+    const mobileFooterRule =
+      terminalModalCss.match(/@media \(max-width: 768px\) \{[\s\S]*?\.terminal-status-bar\s*\{/);
+    expect(mobileFooterRule).not.toBeNull();
   });
 
   it("exposes floating drag and resize handles and refits after floating resize", async () => {
@@ -1353,6 +1366,16 @@ describe("TerminalModal", () => {
       expect(mobilePanelRule).not.toContain("min-width");
     });
 
+    it("gives the mobile footer bar the same horizontal-scroll pattern (FN-7560)", () => {
+      // FN-7560: the mobile action-control footer must reuse the min-width: 0 +
+      // overflow-x: auto flex-scroll pattern so a crowded footer scrolls
+      // horizontally instead of clipping/wrapping.
+      const footerRule =
+        terminalModalCss.match(/@media \(max-width: 768px\) \{[\s\S]*?\.terminal-status-bar\s*\{([^}]*)\}/)?.[1] ?? "";
+      expect(footerRule).toContain("overflow-x: auto;");
+      expect(footerRule).toContain("min-width: 0;");
+    });
+
     it("is hidden by default and toggles from header action", async () => {
       render(<TerminalModal isOpen={true} onClose={mockOnClose} />);
 
@@ -3303,7 +3326,14 @@ describe("TerminalModal — mobile layout contract", () => {
     });
   });
 
-  it("header actions show connection state without a footer status-bar shell", async () => {
+  it("header actions show connection state without a footer status-bar shell (desktop, FN-7502)", async () => {
+    // FN-7560: explicitly desktop-width — the footer only exists on the mobile
+    // (isMobileTerminal) path; desktop/floating/pinned-below keep the FN-7502
+    // header-actions contract with NO footer shell rendered.
+    const previousInnerWidth = window.innerWidth;
+    Object.defineProperty(window, "innerWidth", { value: 1280, configurable: true });
+
+    try {
     render(<TerminalModal isOpen={true} onClose={mockOnClose} />);
 
     await waitFor(() => {
@@ -3313,6 +3343,112 @@ describe("TerminalModal — mobile layout contract", () => {
       const connectionStatus = actions.querySelector(".terminal-connection-status");
       expect(connectionStatus?.textContent).toBe("Disconnected");
     });
+    } finally {
+      Object.defineProperty(window, "innerWidth", { value: previousInnerWidth, configurable: true });
+    }
+  });
+
+  it("renders terminal action controls in a mobile footer, not the header (FN-7560)", async () => {
+    const previousInnerWidth = window.innerWidth;
+    Object.defineProperty(window, "innerWidth", { value: 390, configurable: true });
+
+    try {
+      render(<TerminalModal isOpen={true} onClose={mockOnClose} />);
+
+      await waitFor(() => {
+        const footer = screen.getByTestId("terminal-footer-actions");
+        expect(footer.className).toContain("terminal-status-bar");
+
+        const clearBtn = screen.getByTestId("terminal-clear-btn");
+        const shortcutToggle = screen.getByTestId("terminal-shortcut-toggle");
+        const preferencesToggle = screen.getByTestId("terminal-preferences-toggle");
+        const fontSizeValue = screen.getByTestId("terminal-font-size-value");
+
+        // Controls live inside the footer region...
+        expect(footer.contains(clearBtn)).toBe(true);
+        expect(footer.contains(shortcutToggle)).toBe(true);
+        expect(footer.contains(preferencesToggle)).toBe(true);
+        expect(footer.contains(fontSizeValue)).toBe(true);
+
+        // ...and NOT inside the header.
+        const header = document.querySelector(".terminal-header");
+        expect(header).toBeTruthy();
+        expect(header?.contains(clearBtn)).toBe(false);
+        expect(header?.contains(shortcutToggle)).toBe(false);
+        expect(header?.contains(preferencesToggle)).toBe(false);
+        expect(header?.contains(fontSizeValue)).toBe(false);
+
+        // No empty .terminal-actions shell renders in the mobile header.
+        expect(header?.querySelector(".terminal-actions")).toBeNull();
+
+        // The close button and mobile tab dropdown remain in the header.
+        const closeBtn = screen.getByTestId("terminal-close-btn");
+        expect(header?.contains(closeBtn)).toBe(true);
+        expect(footer.contains(closeBtn)).toBe(false);
+        const mobileTabs = screen.getByTestId("terminal-mobile-tabs");
+        expect(header?.contains(mobileTabs)).toBe(true);
+      });
+    } finally {
+      Object.defineProperty(window, "innerWidth", { value: previousInnerWidth, configurable: true });
+    }
+  });
+
+  it("shows the reconnect control in the mobile footer when disconnected (FN-7560)", async () => {
+    const previousInnerWidth = window.innerWidth;
+    Object.defineProperty(window, "innerWidth", { value: 390, configurable: true });
+
+    try {
+      mockUseTerminal.mockReturnValue(
+        createMockTerminalState({ connectionStatus: "disconnected" }),
+      );
+
+      render(<TerminalModal isOpen={true} onClose={mockOnClose} />);
+
+      await waitFor(() => {
+        const footer = screen.getByTestId("terminal-footer-actions");
+        const reconnectBtn = screen.getByTestId("terminal-reconnect-btn");
+        expect(footer.contains(reconnectBtn)).toBe(true);
+      });
+    } finally {
+      Object.defineProperty(window, "innerWidth", { value: previousInnerWidth, configurable: true });
+    }
+  });
+
+  it("shows the restart control and exit code in the mobile footer after the terminal exits (FN-7560)", async () => {
+    const previousInnerWidth = window.innerWidth;
+    Object.defineProperty(window, "innerWidth", { value: 390, configurable: true });
+
+    let exitCallback: ((code: number) => void) | null = null;
+    const customOnExit = vi.fn((cb: (code: number) => void) => {
+      exitCallback = cb;
+      return vi.fn();
+    });
+
+    try {
+      mockUseTerminal.mockReturnValue(
+        createMockTerminalState({ connectionStatus: "connected", onExit: customOnExit }),
+      );
+
+      render(<TerminalModal isOpen={true} onClose={mockOnClose} />);
+
+      await waitFor(() => {
+        expect(mockTerminalInstance.open).toHaveBeenCalled();
+      });
+
+      act(() => {
+        exitCallback?.(0);
+      });
+
+      await waitFor(() => {
+        const footer = screen.getByTestId("terminal-footer-actions");
+        const restartBtn = screen.getByTestId("terminal-restart-btn");
+        const exitCodeEl = screen.getByTestId("terminal-exit-code");
+        expect(footer.contains(restartBtn)).toBe(true);
+        expect(footer.contains(exitCodeEl)).toBe(true);
+      });
+    } finally {
+      Object.defineProperty(window, "innerWidth", { value: previousInnerWidth, configurable: true });
+    }
   });
 
   it("delivers buffered terminal output to xterm when subscriptions are established after websocket messages", async () => {

From 71dfd3aecace08ca99c3053a96e311c65ccf826e Mon Sep 17 00:00:00 2001
From: gsxdsm <gsxdsm@users.noreply.github.com>
Date: Sat, 4 Jul 2026 22:33:16 -0700
Subject: [PATCH 09/65] FN-7568: rename CLI release binary assets to
 fn-cli-<platform>

Renames the downloadable GitHub Release CLI binaries so they don't collide with other well-known fn-named tools on a user's PATH; the local dev binary name is unchanged.

- Update binaryNameForTarget in packages/cli/build.ts to emit fn-cli-<suffix> instead of fn-<suffix> (local dev binary stays fn/fn.exe)
- Update release.yml and test-release.yml build matrices to use fn-cli-linux-x64, fn-cli-linux-arm64, fn-cli-darwin-arm64, fn-cli-windows-x64.exe
- Update build-exe-cross, ci-workflow, and package-config tests to assert the new fn-cli-<platform> asset names
- Add changeset documenting the release-asset rename

Files changed:
 .changeset/fn-7568-fn-cli-release-asset.md         |  7 +++++++
 .github/workflows/release.yml                      |  8 ++++----
 .github/workflows/test-release.yml                 |  8 ++++----
 packages/cli/build.ts                              | 10 ++++++++--
 packages/cli/src/__tests__/build-exe-cross.test.ts | 14 +++++++-------
 packages/cli/src/__tests__/ci-workflow.test.ts     |  8 ++++----
 packages/cli/src/__tests__/package-config.test.ts  | 10 +++++-----
 7 files changed, 39 insertions(+), 26 deletions(-)

Fusion-Task-Id: FN-7568

Fusion-Task-Lineage: 1c04d763-5e2f-43e3-84b7-df8dcff8467f

Co-authored-by: Fusion (runfusion.ai) <noreply@runfusion.ai>
---
 .changeset/fn-7568-fn-cli-release-asset.md         |  7 +++++++
 .github/workflows/release.yml                      |  8 ++++----
 .github/workflows/test-release.yml                 |  8 ++++----
 packages/cli/build.ts                              | 10 ++++++++--
 packages/cli/src/__tests__/build-exe-cross.test.ts | 14 +++++++-------
 packages/cli/src/__tests__/ci-workflow.test.ts     |  8 ++++----
 packages/cli/src/__tests__/package-config.test.ts  | 10 +++++-----
 7 files changed, 39 insertions(+), 26 deletions(-)
 create mode 100644 .changeset/fn-7568-fn-cli-release-asset.md

diff --git a/.changeset/fn-7568-fn-cli-release-asset.md b/.changeset/fn-7568-fn-cli-release-asset.md
new file mode 100644
index 0000000000..3ef5b22298
--- /dev/null
+++ b/.changeset/fn-7568-fn-cli-release-asset.md
@@ -0,0 +1,7 @@
+---
+"@runfusion/fusion": patch
+---
+
+summary: Rename downloadable CLI release binaries to the fn-cli-<platform> base name.
+category: internal
+dev: `binaryNameForTarget` in `packages/cli/build.ts` and the `release.yml` / `test-release.yml` matrices now emit `fn-cli-<suffix>`; the local dev binary stays `fn`/`fn.exe`.
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index 2451ce510d..a35a0d6532 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -36,19 +36,19 @@ jobs:
         include:
           - os: ubuntu-latest
             target: bun-linux-x64
-            binary: fn-linux-x64
+            binary: fn-cli-linux-x64
           - os: ubuntu-24.04-arm
             target: bun-linux-arm64
-            binary: fn-linux-arm64
+            binary: fn-cli-linux-arm64
           - os: macos-latest
             target: bun-darwin-arm64
-            binary: fn-darwin-arm64
+            binary: fn-cli-darwin-arm64
           # bun-darwin-x64 (Intel) dropped: macos-13 runners are scarce and
           # blocked releases by sitting queued for hours. The CLI ships
           # Apple-Silicon-only for macOS; desktop macOS DMG/ZIP is universal.
           - os: windows-latest
             target: bun-windows-x64
-            binary: fn-windows-x64.exe
+            binary: fn-cli-windows-x64.exe
 
     steps:
       - name: Checkout
diff --git a/.github/workflows/test-release.yml b/.github/workflows/test-release.yml
index 7edd2ca8fc..33f0ad5fc8 100644
--- a/.github/workflows/test-release.yml
+++ b/.github/workflows/test-release.yml
@@ -19,18 +19,18 @@ jobs:
         include:
           - os: ubuntu-latest
             target: bun-linux-x64
-            binary: fn-linux-x64
+            binary: fn-cli-linux-x64
           - os: ubuntu-24.04-arm
             target: bun-linux-arm64
-            binary: fn-linux-arm64
+            binary: fn-cli-linux-arm64
           - os: macos-latest
             target: bun-darwin-arm64
-            binary: fn-darwin-arm64
+            binary: fn-cli-darwin-arm64
           # bun-darwin-x64 (Intel) dropped: macos-13 runner scarcity — CLI is
           # Apple-Silicon-only for macOS. Keep in sync with release.yml.
           - os: windows-latest
             target: bun-windows-x64
-            binary: fn-windows-x64.exe
+            binary: fn-cli-windows-x64.exe
 
     steps:
       - name: Checkout
diff --git a/packages/cli/build.ts b/packages/cli/build.ts
index 479d1359af..c75a9abf3c 100644
--- a/packages/cli/build.ts
+++ b/packages/cli/build.ts
@@ -108,13 +108,19 @@ function targetToPrebuildName(target: BunTarget): string {
 
 /**
  * Map a Bun target identifier to the output binary name.
- * e.g. "bun-linux-x64" → "fn-linux-x64", "bun-windows-x64" → "fn-windows-x64.exe"
+ * e.g. "bun-linux-x64" → "fn-cli-linux-x64", "bun-windows-x64" → "fn-cli-windows-x64.exe"
+ *
+ * FNXC:Release 2026-07-04-00:00:
+ * GitHub Release CLI assets use the `fn-cli-` base name (not `fn-`) so the
+ * downloadable binary doesn't collide with other well-known `fn` tools on a
+ * user's PATH. The local dev binary (defaultBinaryName) intentionally stays
+ * `fn`/`fn.exe` — this rename only affects cross-compiled release assets.
  */
 function binaryNameForTarget(target: BunTarget): string {
   // "bun-linux-x64" → "linux-x64"
   const suffix = target.replace(/^bun-/, "");
   const isWindows = target.includes("windows");
-  return `fn-${suffix}${isWindows ? ".exe" : ""}`;
+  return `fn-cli-${suffix}${isWindows ? ".exe" : ""}`;
 }
 
 /**
diff --git a/packages/cli/src/__tests__/build-exe-cross.test.ts b/packages/cli/src/__tests__/build-exe-cross.test.ts
index 610e67e52b..cb7f70506c 100644
--- a/packages/cli/src/__tests__/build-exe-cross.test.ts
+++ b/packages/cli/src/__tests__/build-exe-cross.test.ts
@@ -25,7 +25,7 @@ function hasKnownBunSqliteLimitation(result: { stdout: string; stderr: string })
 function expectedBinaryName(target: string): string {
   const suffix = target.replace(/^bun-/, "");
   const isWindows = target.includes("windows");
-  return `fn-${suffix}${isWindows ? ".exe" : ""}`;
+  return `fn-cli-${suffix}${isWindows ? ".exe" : ""}`;
 }
 
 /**
@@ -51,7 +51,7 @@ const SHOULD_RUN_BUILD_EXE =
 
 describe.skipIf(!SHOULD_RUN_BUILD_EXE)("build-exe-cross: single target", () => {
   beforeAll(() => {
-    const bin = join(distDir, "fn-linux-x64");
+    const bin = join(distDir, "fn-cli-linux-x64");
     if (existsSync(bin)) return;
     execSync("bun run build.ts --target bun-linux-x64", {
       cwd: cliRoot,
@@ -60,8 +60,8 @@ describe.skipIf(!SHOULD_RUN_BUILD_EXE)("build-exe-cross: single target", () => {
     });
   }, 180_000);
 
-  it("produces dist/fn-linux-x64", () => {
-    const bin = join(distDir, "fn-linux-x64");
+  it("produces dist/fn-cli-linux-x64", () => {
+    const bin = join(distDir, "fn-cli-linux-x64");
     expect(existsSync(bin)).toBe(true);
     expect(statSync(bin).size).toBeGreaterThan(0);
   });
@@ -73,7 +73,7 @@ describe.skipIf(!SHOULD_RUN_BUILD_EXE)("build-exe-cross: single target", () => {
 
 describe.skipIf(!SHOULD_RUN_BUILD_EXE)("build-exe-cross: windows target has .exe extension", () => {
   beforeAll(() => {
-    const bin = join(distDir, "fn-windows-x64.exe");
+    const bin = join(distDir, "fn-cli-windows-x64.exe");
     if (existsSync(bin)) return;
     execSync("bun run build.ts --target bun-windows-x64", {
       cwd: cliRoot,
@@ -82,8 +82,8 @@ describe.skipIf(!SHOULD_RUN_BUILD_EXE)("build-exe-cross: windows target has .exe
     });
   }, 180_000);
 
-  it("produces dist/fn-windows-x64.exe", () => {
-    const bin = join(distDir, "fn-windows-x64.exe");
+  it("produces dist/fn-cli-windows-x64.exe", () => {
+    const bin = join(distDir, "fn-cli-windows-x64.exe");
     expect(existsSync(bin)).toBe(true);
     expect(statSync(bin).size).toBeGreaterThan(0);
   });
diff --git a/packages/cli/src/__tests__/ci-workflow.test.ts b/packages/cli/src/__tests__/ci-workflow.test.ts
index 58e3f91d00..4751e59134 100644
--- a/packages/cli/src/__tests__/ci-workflow.test.ts
+++ b/packages/cli/src/__tests__/ci-workflow.test.ts
@@ -485,10 +485,10 @@ describe("Binary release workflow (.github/workflows/release.yml)", () => {
     expect(osMap["bun-windows-x64"]).toBe("windows-latest");
   });
 
-  it("maps bun-linux-arm64 to fn-linux-arm64 binary name", () => {
+  it("maps bun-linux-arm64 to fn-cli-linux-arm64 binary name", () => {
     const matrix = workflow.jobs["build-binaries"].strategy.matrix.include;
     const arm64Entry = matrix.find((m: any) => m.target === "bun-linux-arm64");
-    expect(arm64Entry?.binary).toBe("fn-linux-arm64");
+    expect(arm64Entry?.binary).toBe("fn-cli-linux-arm64");
   });
 
   it("uses softprops/action-gh-release", () => {
@@ -586,10 +586,10 @@ describe("Test-release workflow (.github/workflows/test-release.yml)", () => {
     expect(targets).not.toContain("bun-darwin-x64");
   });
 
-  it("maps bun-linux-arm64 to fn-linux-arm64 binary name", () => {
+  it("maps bun-linux-arm64 to fn-cli-linux-arm64 binary name", () => {
     const matrix = workflow.jobs["build-binaries"].strategy.matrix.include;
     const arm64Entry = matrix.find((m: any) => m.target === "bun-linux-arm64");
-    expect(arm64Entry?.binary).toBe("fn-linux-arm64");
+    expect(arm64Entry?.binary).toBe("fn-cli-linux-arm64");
   });
 
   it("includes smoke tests with --help", () => {
diff --git a/packages/cli/src/__tests__/package-config.test.ts b/packages/cli/src/__tests__/package-config.test.ts
index 45afae9263..7268547855 100644
--- a/packages/cli/src/__tests__/package-config.test.ts
+++ b/packages/cli/src/__tests__/package-config.test.ts
@@ -96,11 +96,11 @@ describe("CLI package.json publishing config", () => {
   it("does not include bare 'dist' entry or globs that would match Bun binaries", () => {
     const bunBinaryNames = [
       "fn",
-      "fn-linux-x64",
-      "fn-linux-arm64",
-      "fn-darwin-x64",
-      "fn-darwin-arm64",
-      "fn-windows-x64.exe",
+      "fn-cli-linux-x64",
+      "fn-cli-linux-arm64",
+      "fn-cli-darwin-x64",
+      "fn-cli-darwin-arm64",
+      "fn-cli-windows-x64.exe",
     ];
     // No bare "dist" entry that would include everything
     expect(pkg.files).not.toContain("dist");

From 24b27e8b382a7572f2e2443a5f7a6ba4ffc8461b Mon Sep 17 00:00:00 2001
From: gsxdsm <gsxdsm@users.noreply.github.com>
Date: Sat, 4 Jul 2026 22:35:30 -0700
Subject: [PATCH 10/65] FN-7564: block approve/reject-plan API bypass of
 release-authorization holds

Enforce the FN-7559 release-authorization hold in the approve-plan and reject-plan routes, since a direct API call previously bypassed the dashboard's UI-only protection.

- Add a guard in register-task-workflow-routes.ts: reject approve-plan and reject-plan requests with 400 when task.awaitingApprovalReason === "release-authorization", instructing the caller to add the **Release Authorized By User:** yes marker instead.
- Add regression tests in routes-github.test.ts covering both approve-plan and reject-plan against release-authorization-held tasks.
- Add changeset fn-7564-approve-plan-release-authorization-guard.md (patch, security) documenting the fix.

Files changed:
 .changeset/fn-7564-approve-plan-release-authorization-guard.md | 7 ++
 packages/dashboard/src/__tests__/routes-github.test.ts | 82 ++++++++++++++++++++++
 packages/dashboard/src/routes/register-task-workflow-routes.ts | 23 ++++++
 3 files changed, 112 insertions(+)

Fusion-Task-Id: FN-7564

Fusion-Task-Lineage: ccadd492-ee2b-4f0e-af2f-5f37c6351922

Co-authored-by: Fusion (runfusion.ai) <noreply@runfusion.ai>
---
 ...pprove-plan-release-authorization-guard.md |  7 ++
 .../src/__tests__/routes-github.test.ts       | 82 +++++++++++++++++++
 .../routes/register-task-workflow-routes.ts   | 23 ++++++
 3 files changed, 112 insertions(+)
 create mode 100644 .changeset/fn-7564-approve-plan-release-authorization-guard.md

diff --git a/.changeset/fn-7564-approve-plan-release-authorization-guard.md b/.changeset/fn-7564-approve-plan-release-authorization-guard.md
new file mode 100644
index 0000000000..e225c8e2a9
--- /dev/null
+++ b/.changeset/fn-7564-approve-plan-release-authorization-guard.md
@@ -0,0 +1,7 @@
+---
+"@runfusion/fusion": patch
+---
+
+summary: Plan approve/reject API now blocks release-authorization holds, requiring the authorization marker first.
+category: fix
+dev: FN-7564 — POST /tasks/:id/approve-plan and /reject-plan now return 400 when task.awaitingApprovalReason === "release-authorization" (FN-7559 discriminator), enforcing the FN-6481 release-authorization gate at the API layer regardless of client. Manual-approval holds are unaffected.
diff --git a/packages/dashboard/src/__tests__/routes-github.test.ts b/packages/dashboard/src/__tests__/routes-github.test.ts
index 23245b9a79..d5ce7afe51 100644
--- a/packages/dashboard/src/__tests__/routes-github.test.ts
+++ b/packages/dashboard/src/__tests__/routes-github.test.ts
@@ -2043,6 +2043,48 @@ describe("POST /tasks/:id/approve-plan", () => {
     expect(res.status).toBe(500);
     expect(res.body.error).toBe("Database error");
   });
+
+  // FN-7564: a release-authorization hold (FN-7559's awaitingApprovalReason
+  // discriminator) must reject a direct approve-plan API call with 400 — the
+  // FN-6481 authorization-marker requirement must not be bypassable outside the UI.
+  it("returns 400 and does not move the task for a release-authorization hold", async () => {
+    const releaseHoldTask = {
+      ...FAKE_TASK_DETAIL,
+      column: "triage" as const,
+      status: "awaiting-approval" as const,
+      awaitingApprovalReason: "release-authorization" as const,
+    };
+    (store.getTask as ReturnType<typeof vi.fn>).mockResolvedValue(releaseHoldTask);
+
+    const res = await REQUEST(buildApp(), "POST", "/api/tasks/KB-001/approve-plan");
+
+    expect(res.status).toBe(400);
+    expect(res.body.error).toContain("release authorization");
+    expect(res.body.error).toContain("Release Authorized By User");
+    expect(store.moveTask).not.toHaveBeenCalled();
+    expect(store.updateTask).not.toHaveBeenCalled();
+  });
+
+  // Passthrough: an ordinary manual-approval hold (no awaitingApprovalReason)
+  // must still approve exactly as before — the guard is scoped to release-authorization only.
+  it("still approves a manual-approval hold with awaitingApprovalReason unset", async () => {
+    const awaitingTask = {
+      ...FAKE_TASK_DETAIL,
+      column: "triage" as const,
+      status: "awaiting-approval" as const,
+      awaitingApprovalReason: undefined,
+    };
+    const movedTask = { ...FAKE_TASK_DETAIL, column: "todo" as const };
+
+    (store.getTask as ReturnType<typeof vi.fn>).mockResolvedValue(awaitingTask);
+    (store.moveTask as ReturnType<typeof vi.fn>).mockResolvedValue(movedTask);
+    (store.updateTask as ReturnType<typeof vi.fn>).mockResolvedValue({ ...movedTask, status: undefined });
+
+    const res = await REQUEST(buildApp(), "POST", "/api/tasks/KB-001/approve-plan");
+
+    expect(res.status).toBe(200);
+    expect(store.moveTask).toHaveBeenCalledWith("FN-001", "todo");
+  });
 });
 
 describe("POST /tasks/:id/reject-plan", () => {
@@ -2119,6 +2161,46 @@ describe("POST /tasks/:id/reject-plan", () => {
     expect(res.status).toBe(500);
     expect(res.body.error).toBe("Database error");
   });
+
+  // FN-7564: a release-authorization hold must reject a direct reject-plan API
+  // call with 400 too — rejecting must not silently wipe/regenerate the spec
+  // without the operator ever acknowledging the FN-6481 authorization gate.
+  it("returns 400 and does not clear status or remove PROMPT.md for a release-authorization hold", async () => {
+    const releaseHoldTask = {
+      ...FAKE_TASK_DETAIL,
+      column: "triage" as const,
+      status: "awaiting-approval" as const,
+      awaitingApprovalReason: "release-authorization" as const,
+    };
+    (store.getTask as ReturnType<typeof vi.fn>).mockResolvedValue(releaseHoldTask);
+
+    const res = await REQUEST(buildApp(), "POST", "/api/tasks/KB-001/reject-plan");
+
+    expect(res.status).toBe(400);
+    expect(res.body.error).toContain("release authorization");
+    expect(res.body.error).toContain("Release Authorized By User");
+    expect(store.updateTask).not.toHaveBeenCalled();
+  });
+
+  // Passthrough: an ordinary manual-approval hold (no awaitingApprovalReason)
+  // must still reject exactly as before — the guard is scoped to release-authorization only.
+  it("still rejects a manual-approval hold with awaitingApprovalReason unset", async () => {
+    const awaitingTask = {
+      ...FAKE_TASK_DETAIL,
+      column: "triage" as const,
+      status: "awaiting-approval" as const,
+      awaitingApprovalReason: undefined,
+    };
+    const updatedTask = { ...FAKE_TASK_DETAIL, column: "triage" as const, status: undefined };
+
+    (store.getTask as ReturnType<typeof vi.fn>).mockResolvedValue(awaitingTask);
+    (store.updateTask as ReturnType<typeof vi.fn>).mockResolvedValue(updatedTask);
+
+    const res = await REQUEST(buildApp(), "POST", "/api/tasks/KB-001/reject-plan");
+
+    expect(res.status).toBe(200);
+    expect(store.updateTask).toHaveBeenCalledWith("FN-001", { status: undefined });
+  });
 });
 
 // --- Task diff route tests ---
diff --git a/packages/dashboard/src/routes/register-task-workflow-routes.ts b/packages/dashboard/src/routes/register-task-workflow-routes.ts
index da1ade20c0..31909c31c4 100644
--- a/packages/dashboard/src/routes/register-task-workflow-routes.ts
+++ b/packages/dashboard/src/routes/register-task-workflow-routes.ts
@@ -2737,6 +2737,19 @@ export function registerTaskWorkflowRoutes(ctx: ApiRoutesContext, deps: TaskWork
       if (task.status !== "awaiting-approval") {
         throw badRequest("Task must have status 'awaiting-approval' to approve plan");
       }
+      // FNXC:ReleaseAuthorizationGate 2026-07-04-22:30:
+      // FN-6481 requires a release-class task to carry an explicit
+      // "**Release Authorized By User:** yes" marker before it can dispatch.
+      // FN-7559 parks such tasks with awaitingApprovalReason === "release-authorization"
+      // (distinct from an ordinary manual plan-approval hold) and hides the
+      // Approve/Reject Plan buttons in the dashboard UI, but a direct API call bypasses
+      // that UI protection. Enforce the gate here too so no client can dispatch a
+      // release-class task without the authorization marker.
+      if (task.awaitingApprovalReason === "release-authorization") {
+        throw badRequest(
+          "This task is held for release authorization. Add the **Release Authorized By User:** yes marker to its PROMPT.md and resubmit the spec instead of approving the plan.",
+        );
+      }
 
       // Log the approval
       await scopedStore.logEntry(task.id, "Plan approved by user");
@@ -2769,6 +2782,16 @@ export function registerTaskWorkflowRoutes(ctx: ApiRoutesContext, deps: TaskWork
       if (task.status !== "awaiting-approval") {
         throw badRequest("Task must have status 'awaiting-approval' to reject plan");
       }
+      // FNXC:ReleaseAuthorizationGate 2026-07-04-22:30:
+      // Mirror of the approve-plan guard above: a release-authorization hold
+      // (FN-7559's awaitingApprovalReason discriminator) must not be rejectable
+      // through the API either, since rejecting would wipe/regenerate the spec
+      // without the operator ever acknowledging the FN-6481 authorization gate.
+      if (task.awaitingApprovalReason === "release-authorization") {
+        throw badRequest(
+          "This task is held for release authorization. Add the **Release Authorized By User:** yes marker to its PROMPT.md and resubmit the spec instead of rejecting the plan.",
+        );
+      }
 
       // Log the rejection
       await scopedStore.logEntry(task.id, "Plan rejected by user", "Specification will be regenerated");

From 34fd3c791277c8f1776edb3b98027f0cad1a45ad Mon Sep 17 00:00:00 2001
From: gsxdsm <gsxdsm@users.noreply.github.com>
Date: Sat, 4 Jul 2026 22:40:37 -0700
Subject: [PATCH 11/65] FN-7570: shorten oversight-controls changeset summary
 to fit 120-char limit

Trims the FN-7546 changeset summary line so it stays within the 120-character release-notes limit.
- Shortened the `summary:` field in .changeset/FN-7546-oversight-controls-clarity.md
- Preserved category and dev fields unchanged

Files changed:
 .changeset/FN-7546-oversight-controls-clarity.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

Fusion-Task-Id: FN-7570

Fusion-Task-Lineage: c486f2af-9543-4976-8b24-ee4bd3a2d07d

Co-authored-by: Fusion (runfusion.ai) <noreply@runfusion.ai>
---
 .changeset/FN-7546-oversight-controls-clarity.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.changeset/FN-7546-oversight-controls-clarity.md b/.changeset/FN-7546-oversight-controls-clarity.md
index 9c9f5ac826..05ad551fe9 100644
--- a/.changeset/FN-7546-oversight-controls-clarity.md
+++ b/.changeset/FN-7546-oversight-controls-clarity.md
@@ -2,6 +2,6 @@
 "@runfusion/fusion": patch
 ---
 
-summary: Clarify the task-detail planner-oversight Nudge/Explain controls with a visible label, an in-DOM disabled reason, and an always-openable Explain panel.
+summary: Clarify task-detail planner-oversight controls with a visible label, a disabled-reason hint, and always-open Explain.
 category: fix
 dev: TaskDetailModal now renders a `detail-oversight-controls-label` group label and `detail-overseer-nudge-disabled-reason` helper text (both gated by the existing oversight-cluster visibility condition); Explain no longer disables on `!canExplainOverseer` since it is read-only. Nudge's `canNudgeOverseer` gate and Stop's confirm dialog are unchanged.

From fb451574013c8178987c7c3687e9b3b6e359cce5 Mon Sep 17 00:00:00 2001
From: gsxdsm <gsxdsm@users.noreply.github.com>
Date: Sat, 4 Jul 2026 22:43:12 -0700
Subject: [PATCH 12/65] FN-7565: pin mobile terminal close button to top-right
 corner

Corner-pins the mobile terminal header's close (X) button so it renders last in flex order and hugs the top-right edge, instead of falling back to order:0 and landing at the far left of the header.

- Add .terminal-close--corner class (order:3 + margin-inline-start:auto) applied only on mobile, both in the base .terminal-modal--mobile selector and the max-width:768px media query (covers folded-Android visualViewport path)
- Apply terminal-close--corner alongside terminal-close on the mobile close button in TerminalModal.tsx; desktop/floating/pinned-below placement inside .terminal-actions is unchanged
- Add regression tests asserting the corner-pin class, its persistence across connection/exit states, the unaffected desktop .terminal-actions placement, and the CSS flex-order relationship vs .terminal-mobile-tabs/.terminal-workspace-picker
- Add changeset (patch) documenting the fix for release notes

Files changed:
 .changeset/fn-7565-mobile-terminal-close-corner.md |   7 ++
 .../dashboard/app/components/TerminalModal.css     |  30 +++++
 .../dashboard/app/components/TerminalModal.tsx     |  14 ++-
 .../components/__tests__/TerminalModal.test.tsx    | 126 +++++++++++++++++++++
 4 files changed, 176 insertions(+), 1 deletion(-)

Fusion-Task-Id: FN-7565
Fusion-Task-Lineage: f5d82128-6c14-4281-9cfc-fd87dbc89d5d
Co-authored-by: Fusion (runfusion.ai) <noreply@runfusion.ai>
---
 .../fn-7565-mobile-terminal-close-corner.md   |   7 +
 .../app/components/TerminalModal.css          |  30 +++++
 .../app/components/TerminalModal.tsx          |  14 +-
 .../__tests__/TerminalModal.test.tsx          | 126 ++++++++++++++++++
 4 files changed, 176 insertions(+), 1 deletion(-)
 create mode 100644 .changeset/fn-7565-mobile-terminal-close-corner.md

diff --git a/.changeset/fn-7565-mobile-terminal-close-corner.md b/.changeset/fn-7565-mobile-terminal-close-corner.md
new file mode 100644
index 0000000000..57f627a4b1
--- /dev/null
+++ b/.changeset/fn-7565-mobile-terminal-close-corner.md
@@ -0,0 +1,7 @@
+---
+"@runfusion/fusion": patch
+---
+
+summary: Pin the mobile terminal close (X) button to the top-right corner so it is easy to find and tap.
+category: fix
+dev: On the ≤768px terminal, the `terminal-close` button now carries a `terminal-close--corner` class (order:3 + margin-inline-start:auto) so it renders last in flex order and hugs the right edge next to the tab dropdown, instead of falling back to order:0 (far left). Desktop/floating/pinned-below placement inside `.terminal-actions` is unchanged.
diff --git a/packages/dashboard/app/components/TerminalModal.css b/packages/dashboard/app/components/TerminalModal.css
index 14cfeed9bd..3495ecaa16 100644
--- a/packages/dashboard/app/components/TerminalModal.css
+++ b/packages/dashboard/app/components/TerminalModal.css
@@ -1419,6 +1419,22 @@ Android folded Chrome can keep a wide layout viewport while visualViewport is th
   min-width: 0;
 }
 
+/*
+FNXC:TerminalHeader 2026-07-04-20:45:
+FN-7565: pin the mobile close (X) button to the top-right corner of the header.
+Without an explicit order, the close button (a direct .terminal-header child)
+defaults to order:0 and sorts BEFORE .terminal-mobile-tabs (order:1) /
+.terminal-workspace-picker (order:2), landing at the far left instead of the
+corner. Giving it the highest order plus margin-inline-start:auto renders it
+last and flush against the right edge, matching where users expect an
+app-sheet close control. Covers the folded-Android visualViewport path (this
+selector applies even when the max-width media query below does not).
+*/
+.modal.terminal-modal.terminal-modal--mobile .terminal-close--corner {
+  order: 3;
+  margin-inline-start: auto;
+}
+
 /*
 FNXC:Terminal 2026-07-02-12:30:
 The Android keyboard-open recurrence can start with a touch-primary visualViewport narrower than the layout viewport, so `terminal-modal--mobile` must apply the same keyboard-constrained height and current visual viewport width even when CSS media queries still see the wider layout viewport. This keeps xterm's initial 10px fit on contiguous monospace cells instead of a stale wide box that spaces filenames like `AGENTS.md` apart.
@@ -1485,6 +1501,20 @@ The Android keyboard-open recurrence can start with a touch-primary visualViewpo
     border-left: none;
   }
 
+  /*
+  FNXC:TerminalHeader 2026-07-04-20:45:
+  FN-7565: same corner-pin rationale as the non-media `.terminal-modal--mobile`
+  rule above — the close button needs an explicit order higher than
+  .terminal-mobile-tabs (1) and .terminal-workspace-picker (2) plus
+  margin-inline-start:auto so it renders last in flex order and hugs the right
+  edge of the (non-wrapping) top header row, instead of falling back to its
+  default order:0 and landing on the left.
+  */
+  .terminal-close--corner {
+    order: 3;
+    margin-inline-start: auto;
+  }
+
   .terminal-workspace-picker-trigger {
     width: clamp(92px, 28vw, 132px);
     max-width: 132px;
diff --git a/packages/dashboard/app/components/TerminalModal.tsx b/packages/dashboard/app/components/TerminalModal.tsx
index cf9f432a38..e84ac9c5ad 100644
--- a/packages/dashboard/app/components/TerminalModal.tsx
+++ b/packages/dashboard/app/components/TerminalModal.tsx
@@ -2528,10 +2528,22 @@ export function TerminalModal({ isOpen, onClose, initialCommand, initialCommandG
           the action controls move into the `.terminal-status-bar` footer below
           (FN-7560) so they don't crowd the dropdown/close. Both sites render the
           SAME fragment, never a duplicated copy, so handlers cannot drift.
+
+          FNXC:TerminalHeader 2026-07-04-20:45:
+          FN-7565: on mobile, being a direct child of `.terminal-header` (not
+          nested in `.terminal-actions`) is necessary but not sufficient to land
+          in the top-right corner — flex items without an explicit `order` fall
+          back to `order: 0`, which sorts BEFORE `.terminal-mobile-tabs`
+          (`order: 1`) and `.terminal-workspace-picker` (`order: 2`), pushing the
+          close button to the far LEFT of the header instead of the corner users
+          expect for an app-sheet close control. The `terminal-close--corner`
+          class (CSS: highest `order` + `margin-inline-start: auto`) fixes this
+          so the X renders last in flex order and hugs the right edge regardless
+          of how wide the tab dropdown / workspace picker grow.
           */}
           {isMobileTerminal ? (
             <button
-              className="terminal-close"
+              className="terminal-close terminal-close--corner"
               onClick={onClose}
               data-testid="terminal-close-btn"
               title={t("terminal.closeTerminal", "Close terminal")}
diff --git a/packages/dashboard/app/components/__tests__/TerminalModal.test.tsx b/packages/dashboard/app/components/__tests__/TerminalModal.test.tsx
index a2a3b80f12..5153399c89 100644
--- a/packages/dashboard/app/components/__tests__/TerminalModal.test.tsx
+++ b/packages/dashboard/app/components/__tests__/TerminalModal.test.tsx
@@ -3393,6 +3393,132 @@ describe("TerminalModal — mobile layout contract", () => {
     }
   });
 
+  it("pins the mobile close button to the top-right corner of the header, not buried in .terminal-actions (FN-7565)", async () => {
+    const previousInnerWidth = window.innerWidth;
+    Object.defineProperty(window, "innerWidth", { value: 390, configurable: true });
+
+    try {
+      render(<TerminalModal isOpen={true} onClose={mockOnClose} />);
+
+      await waitFor(() => {
+        const header = document.querySelector(".terminal-header");
+        expect(header).toBeTruthy();
+
+        // Exactly one close button renders on mobile — no duplicate close target.
+        const closeButtons = screen.getAllByTestId("terminal-close-btn");
+        expect(closeButtons).toHaveLength(1);
+        const closeBtn = closeButtons[0];
+
+        // It is a direct child of .terminal-header, not nested inside a wrapping
+        // .terminal-actions cluster (which no longer renders on mobile at all).
+        expect(closeBtn.parentElement).toBe(header);
+        expect(header?.querySelector(".terminal-actions")).toBeNull();
+
+        // It carries the mobile corner-pin class so CSS order/margin can place
+        // it last in flex order, flush against the right edge next to the tab
+        // dropdown, instead of falling back to order:0 (far left).
+        expect(closeBtn.className).toContain("terminal-close--corner");
+      });
+    } finally {
+      Object.defineProperty(window, "innerWidth", { value: previousInnerWidth, configurable: true });
+    }
+  });
+
+  it("keeps the mobile corner-pin invariant across connection/exit states (FN-7565)", async () => {
+    const previousInnerWidth = window.innerWidth;
+    Object.defineProperty(window, "innerWidth", { value: 390, configurable: true });
+
+    try {
+      mockUseTerminal.mockReturnValue(
+        createMockTerminalState({ connectionStatus: "disconnected" }),
+      );
+      const { rerender } = render(<TerminalModal isOpen={true} onClose={mockOnClose} />);
+
+      await waitFor(() => {
+        const header = document.querySelector(".terminal-header");
+        const closeBtn = screen.getByTestId("terminal-close-btn");
+        expect(closeBtn.parentElement).toBe(header);
+        expect(closeBtn.className).toContain("terminal-close--corner");
+        // Reconnect control lives in the footer, not the header, so it cannot
+        // crowd the corner-pinned close button.
+        expect(screen.getByTestId("terminal-reconnect-btn").closest(".terminal-header")).toBeNull();
+      });
+
+      let exitCallback: ((code: number) => void) | null = null;
+      const customOnExit = vi.fn((cb: (code: number) => void) => {
+        exitCallback = cb;
+        return vi.fn();
+      });
+      mockUseTerminal.mockReturnValue(
+        createMockTerminalState({ connectionStatus: "connected", onExit: customOnExit }),
+      );
+      rerender(<TerminalModal isOpen={true} onClose={mockOnClose} />);
+
+      await waitFor(() => {
+        expect(mockTerminalInstance.open).toHaveBeenCalled();
+      });
+      act(() => {
+        exitCallback?.(1);
+      });
+
+      await waitFor(() => {
+        const header = document.querySelector(".terminal-header");
+        const closeBtn = screen.getByTestId("terminal-close-btn");
+        expect(closeBtn.parentElement).toBe(header);
+        expect(closeBtn.className).toContain("terminal-close--corner");
+        // Restart control + exit code live in the footer, not the header.
+        expect(screen.getByTestId("terminal-restart-btn").closest(".terminal-header")).toBeNull();
+      });
+    } finally {
+      Object.defineProperty(window, "innerWidth", { value: previousInnerWidth, configurable: true });
+    }
+  });
+
+  it("keeps the desktop close button in .terminal-actions with no mobile-only corner slot (FN-7565)", async () => {
+    const previousInnerWidth = window.innerWidth;
+    Object.defineProperty(window, "innerWidth", { value: 1280, configurable: true });
+
+    try {
+      render(<TerminalModal isOpen={true} onClose={mockOnClose} />);
+
+      await waitFor(() => {
+        const closeButtons = screen.getAllByTestId("terminal-close-btn");
+        expect(closeButtons).toHaveLength(1);
+        const closeBtn = closeButtons[0];
+        const actions = screen.getByTestId("terminal-actions");
+
+        // Desktop/floating/pinned-below keep the FN-7502 placement: close stays
+        // the rightmost child of .terminal-actions.
+        expect(actions.contains(closeBtn)).toBe(true);
+        expect(actions.lastElementChild).toBe(closeBtn);
+
+        // No mobile-only corner class/slot renders on desktop.
+        expect(closeBtn.className).not.toContain("terminal-close--corner");
+      });
+    } finally {
+      Object.defineProperty(window, "innerWidth", { value: previousInnerWidth, configurable: true });
+    }
+  });
+
+  it("corner-pins the mobile close button after .terminal-mobile-tabs and .terminal-workspace-picker in flex order (FN-7565)", () => {
+    const nonMediaMobileRule =
+      terminalModalCss.match(/\.modal\.terminal-modal\.terminal-modal--mobile \.terminal-close--corner\s*\{([^}]*)\}/)?.[1] ?? "";
+    const mediaMobileRule =
+      terminalModalCss.match(/@media \(max-width: 768px\) \{[\s\S]*?\.terminal-close--corner\s*\{([^}]*)\}/)?.[1] ?? "";
+    const mobileTabsOrderMedia = terminalModalCss.match(/@media \(max-width: 768px\) \{[\s\S]*?\.terminal-mobile-tabs\s*\{([^}]*)\}/)?.[1] ?? "";
+    const workspacePickerOrderMedia = terminalModalCss.match(/@media \(max-width: 768px\) \{[\s\S]*?\.terminal-workspace-picker\s*\{([^}]*)\}/)?.[1] ?? "";
+    const baseHeaderRule = terminalModalCss.match(/\.terminal-header\s*\{([^}]*)\}/)?.[1] ?? "";
+
+    expect(nonMediaMobileRule).toContain("order: 3;");
+    expect(nonMediaMobileRule).toContain("margin-inline-start: auto;");
+    expect(mediaMobileRule).toContain("order: 3;");
+    expect(mediaMobileRule).toContain("margin-inline-start: auto;");
+    expect(mobileTabsOrderMedia).toContain("order: 1;");
+    expect(workspacePickerOrderMedia).toContain("order: 2;");
+    // Base header stays a flex row so order-based corner-pinning applies.
+    expect(baseHeaderRule).toContain("display: flex;");
+  });
+
   it("shows the reconnect control in the mobile footer when disconnected (FN-7560)", async () => {
     const previousInnerWidth = window.innerWidth;
     Object.defineProperty(window, "innerWidth", { value: 390, configurable: true });

From a8865aa058ad1777bb9d1612846eb4eab9da73bc Mon Sep 17 00:00:00 2001
From: gsxdsm <gsxdsm@users.noreply.github.com>
Date: Sat, 4 Jul 2026 22:45:30 -0700
Subject: [PATCH 13/65] FN-7572: shorten mobile-terminal-footer changeset
 summary under 120 chars

Narrative: The FN-7560 changeset summary line exceeded the 120-char changeset linter limit; trimmed wording while preserving the user-facing meaning.

- Shortened the `summary` field in .changeset/fn-7560-mobile-terminal-footer.md to fit within the 120-character limit enforced by pnpm check:changesets

Files changed:
 .changeset/fn-7560-mobile-terminal-footer.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

Fusion-Task-Id: FN-7572

Fusion-Task-Lineage: 96e2b047-0c47-4717-b870-6df8d90bbd92

Co-authored-by: Fusion (runfusion.ai) <noreply@runfusion.ai>
---
 .changeset/fn-7560-mobile-terminal-footer.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.changeset/fn-7560-mobile-terminal-footer.md b/.changeset/fn-7560-mobile-terminal-footer.md
index 94b0877e65..6ae6140ab1 100644
--- a/.changeset/fn-7560-mobile-terminal-footer.md
+++ b/.changeset/fn-7560-mobile-terminal-footer.md
@@ -2,6 +2,6 @@
 "@runfusion/fusion": patch
 ---
 
-summary: Move the mobile terminal controls into a bottom footer so they no longer crowd the header, and keep the shortcut key bar horizontally scrollable.
+summary: Move mobile terminal controls into a bottom footer so they no longer crowd the header, with a scrollable shortcut bar.
 category: fix
 dev: On the ≤768px terminal, the `.terminal-actions` cluster now renders in a `terminal-footer-actions` bar (with `min-width:0; overflow-x:auto`) instead of the header; desktop/floating/pinned-below keep the FN-7502 header layout. Preserves the FN-7550 shortcut-panel scroll fix.

From bc0553a949845efe32ad9bef4f35d6cfa8b2b2d7 Mon Sep 17 00:00:00 2001
From: gsxdsm <gsxdsm@users.noreply.github.com>
Date: Sat, 4 Jul 2026 22:49:51 -0700
Subject: [PATCH 14/65] FN-7573: shorten oversight-controls changeset summary
 under 120 chars

Shortened the changeset summary line for the oversight Nudge/Explain controls fix so it stays within the 120-character release-notes limit.

- Replaced the overlong summary with a concise version describing the visible label, disabled reason, and always-openable Explain panel

Files changed:
 .changeset/FN-7546-oversight-controls-clarity.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

Fusion-Task-Id: FN-7573

Fusion-Task-Lineage: e7b429db-06cd-4a11-b758-49d37a1ff7c2

Co-authored-by: Fusion (runfusion.ai) <noreply@runfusion.ai>
---
 .changeset/FN-7546-oversight-controls-clarity.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.changeset/FN-7546-oversight-controls-clarity.md b/.changeset/FN-7546-oversight-controls-clarity.md
index 05ad551fe9..632089357e 100644
--- a/.changeset/FN-7546-oversight-controls-clarity.md
+++ b/.changeset/FN-7546-oversight-controls-clarity.md
@@ -2,6 +2,6 @@
 "@runfusion/fusion": patch
 ---
 
-summary: Clarify task-detail planner-oversight controls with a visible label, a disabled-reason hint, and always-open Explain.
+summary: Clarify task-detail oversight Nudge/Explain controls: visible label, disabled reason, always-openable Explain panel.
 category: fix
 dev: TaskDetailModal now renders a `detail-oversight-controls-label` group label and `detail-overseer-nudge-disabled-reason` helper text (both gated by the existing oversight-cluster visibility condition); Explain no longer disables on `!canExplainOverseer` since it is read-only. Nudge's `canNudgeOverseer` gate and Stop's confirm dialog are unchanged.

From c31f9ef4d4dd3978c184d79884fec2205dd18d8b Mon Sep 17 00:00:00 2001
From: gsxdsm <gsxdsm@users.noreply.github.com>
Date: Sat, 4 Jul 2026 22:55:45 -0700
Subject: [PATCH 15/65] FN-7571: move planner intervention timeline into
 Activity dropdown

Relocates the FN-7519 Intervention Timeline out of the inline oversight cluster and into the task Activity view as a fourth selectable segment.
- Add `interventions` to the `ActivitySegment` union and gate its dropdown option on the same oversight-active expression previously used by the inline mount
- Render `PlannerInterventionTimeline` in a new Activity segment panel instead of inline next to the oversight controls
- Fall back to the Live segment automatically if oversight turns off (or was never resolved) while Interventions is selected, avoiding an orphaned selection
- Update oversight-controls and task-activity-chat tests to cover the new dropdown segment and removed inline mount
- Add changeset and update dashboard guide docs

Files changed:
 ...7571-intervention-timeline-activity-dropdown.md |   7 +
 docs/dashboard-guide.md                            |   4 +-
 .../dashboard/app/components/TaskDetailModal.tsx   |  49 ++++---
 .../TaskDetailModal.oversight-controls.test.tsx    | 148 +++++++++++++++++++++
 .../TaskDetailModal.task-activity-chat.test.tsx    |   7 +-
 5 files changed, 195 insertions(+), 20 deletions(-)

Fusion-Task-Id: FN-7571

Fusion-Task-Lineage: 331a1b32-5712-4583-9777-e36ff5cc3ffc

Co-authored-by: Fusion (runfusion.ai) <noreply@runfusion.ai>
---
 ...intervention-timeline-activity-dropdown.md |   7 +
 docs/dashboard-guide.md                       |   4 +-
 .../app/components/TaskDetailModal.tsx        |  49 ++++--
 ...askDetailModal.oversight-controls.test.tsx | 148 ++++++++++++++++++
 ...askDetailModal.task-activity-chat.test.tsx |   7 +-
 5 files changed, 195 insertions(+), 20 deletions(-)
 create mode 100644 .changeset/fn-7571-intervention-timeline-activity-dropdown.md

diff --git a/.changeset/fn-7571-intervention-timeline-activity-dropdown.md b/.changeset/fn-7571-intervention-timeline-activity-dropdown.md
new file mode 100644
index 0000000000..a3af496a8b
--- /dev/null
+++ b/.changeset/fn-7571-intervention-timeline-activity-dropdown.md
@@ -0,0 +1,7 @@
+---
+"@runfusion/fusion": patch
+---
+
+summary: Move the planner intervention timeline into the task Activity view dropdown.
+category: feature
+dev: Removes the inline `PlannerInterventionTimeline` mount from the FN-7517 oversight cluster in `TaskDetailModal.tsx` and adds a fourth `interventions` `ActivitySegment`, shown in the Activity dropdown only when planner oversight is active for the task; falls back to Live if oversight turns off while Interventions is selected.
diff --git a/docs/dashboard-guide.md b/docs/dashboard-guide.md
index 55afafc73b..07e9d30bdb 100644
--- a/docs/dashboard-guide.md
+++ b/docs/dashboard-guide.md
@@ -202,8 +202,8 @@ Features:
 - The FN-7517 controls above carry a visible, non-interactive **`"Overseer controls"` group label** (`data-testid="detail-oversight-controls-label"`) so Nudge/Stop/Explain read as an identifiable cluster rather than unlabeled chips; the label is gated by the same `(hasTaskOversightOverride || workflowOversightResolved) && !oversightIsOff` condition as the buttons, so it never renders an empty shell when oversight is Off/unresolved. When **Nudge** is disabled, an always-visible helper line (`data-testid="detail-overseer-nudge-disabled-reason"`) states the reason in-DOM (mirroring the existing hover `title`) instead of relying on a mouse-hover tooltip alone. **Explain** is read-only and non-mutating, so it is never disabled purely because the overseer is inactive — clicking it always opens/closes the panel, which shows the overseer's live state when watching or an informative "not currently watching this task" message otherwise. Nudge's mutating enablement rule (`canNudgeOverseer`, including the human-control suppression cases) and Stop's confirmation dialog are unchanged.
 <!-- FNXC:PlannerOversight 2026-07-04-19:00: FN-7545 collapses the above controls into a mobile overflow menu below the 768px breakpoint. -->
 - On mobile (viewport ≤ 768px), the level-select/nudge/stop/explain controls above collapse behind a single compact **"Oversight" overflow-menu button** (`data-testid="detail-oversight-menu-trigger"`, `MoreVertical` icon, `aria-haspopup="menu"`) that opens a `role="menu"` popover (mirroring the existing move-action dropdown pattern) listing the same controls as full-width, comfortably tappable `role="menuitem"` entries with the SAME testids and enablement/visibility rules as the desktop inline controls. The trigger itself is withheld entirely when none of those controls would render (no empty-shell overflow button for the oversight-off + overseer-inactive default). Desktop (>768px) keeps the inline cluster unchanged. Opening the menu presents exactly one surface: menu-open auto-focus lands on the first actionable button menuitem, never the native level `<select>`, so the OS option picker never auto-opens on top of the custom popover (FN-7562).
-<!-- FNXC:PlannerOversight 2026-07-04-18:00: FN-7519 adds a read-only Intervention Timeline immediately below the FN-7517 controls above. -->
-- Below the quick oversight controls, the task detail modal renders an **Intervention Timeline** (`data-testid="planner-intervention-timeline"`) listing every recorded planner-overseer intervention for the task, newest-first: watched stage, reason, action taken, outcome (with a `.status-dot` indicator using semantic outcome tokens), an attempt count/limit badge (only when both are present), and source links (agent log / review comment / failed check / merge error / PR state / generic URL). It renders a calm "No planner interventions yet" empty state rather than an empty shell when there are none, and is hidden entirely (no leftover container) when oversight is off or unresolved for the task. Entries are read via `GET /tasks/:id/overseer/interventions`, which assembles them from the existing run-audit store under the `overseer:intervention` mutation type (`recordPlannerIntervention`/`getPlannerInterventionTimeline` in `@fusion/core`). This is a pure read surface — FN-7520 wires the actual intervention-producing call-sites.
+<!-- FNXC:PlannerOversight 2026-07-04-18:00: FN-7519 adds a read-only Intervention Timeline. FN-7571 (2026-07-04-19:00) relocates it from an inline mount below the FN-7517 controls into the task-detail Activity view dropdown as a fourth "Interventions" segment, alongside Live/Feed/Raw. -->
+- The task detail modal's **Activity** tab view dropdown (Live/Feed/Raw) gains a fourth **Interventions** option, shown only when planner oversight is active for the task (same gate as the former inline mount: `(hasTaskOversightOverride || workflowOversightResolved) && !oversightIsOff`). Selecting it renders the **Intervention Timeline** (`data-testid="planner-intervention-timeline"`) inside the Activity panel, listing every recorded planner-overseer intervention for the task, newest-first: watched stage, reason, action taken, outcome (with a `.status-dot` indicator using semantic outcome tokens), an attempt count/limit badge (only when both are present), and source links (agent log / review comment / failed check / merge error / PR state / generic URL). It renders a calm "No planner interventions yet" empty state rather than an empty shell when there are none. When oversight is off or unresolved, the Interventions option is absent from the dropdown entirely (no leftover empty segment), and if it was previously selected the view falls back to Live rather than leaving a blank panel. Entries are read via `GET /tasks/:id/overseer/interventions`, which assembles them from the existing run-audit store under the `overseer:intervention` mutation type (`recordPlannerIntervention`/`getPlannerInterventionTimeline` in `@fusion/core`). This is a pure read surface — FN-7520 wires the actual intervention-producing call-sites.
 - 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/packages/dashboard/app/components/TaskDetailModal.tsx b/packages/dashboard/app/components/TaskDetailModal.tsx
index 962f524ea7..015bbcda71 100644
--- a/packages/dashboard/app/components/TaskDetailModal.tsx
+++ b/packages/dashboard/app/components/TaskDetailModal.tsx
@@ -224,7 +224,7 @@ function formatDurationCompact(ageMs: number): string {
 }
 
 type TabId = "summary" | "definition" | "chat" | "planner-chat" | "logs" | "changes" | "review" | "pr" | "comments" | "model" | "workflow" | "documents" | "stats" | "routing" | "retries" | "terminal" | `plugin-${string}`;
-type ActivitySegment = "current" | "feed" | "raw-logs";
+type ActivitySegment = "current" | "feed" | "raw-logs" | "interventions";
 
 /*
 FNXC:TaskDetailActivityTab 2026-06-30-00:00:
@@ -3306,13 +3306,35 @@ export function TaskDetailContent({
     });
   }, []);
 
+  /*
+  FNXC:PlannerOversight 2026-07-04-19:00:
+  FN-7571 moves the FN-7519 Intervention Timeline out of the inline oversight
+  cluster and into the Activity view dropdown as a fourth `interventions`
+  segment, alongside Live/Feed/Raw. It is gated on the SAME oversight-active
+  expression the inline mount used to use (`hasTaskOversightOverride ||
+  workflowOversightResolved`, minus `oversightIsOff`) so the option never
+  appears — and never leaves an always-empty segment — when oversight is off
+  or unresolved for the task.
+  */
+  const oversightActive = (hasTaskOversightOverride || workflowOversightResolved) && !oversightIsOff;
+
   const activityViewOptions = useMemo<Array<{ value: ActivitySegment; label: string }>>(() => [
     { value: "current", label: t("taskDetail.activity.current", "Live") },
     { value: "feed", label: t("taskDetail.activity.feed", "Feed") },
     { value: "raw-logs", label: t("taskDetail.activity.raw", "Raw") },
-  ], [t]);
+    ...(oversightActive ? [{ value: "interventions" as const, label: t("taskDetail.activity.interventions", "Interventions") }] : []),
+  ], [t, oversightActive]);
   const selectedActivityViewLabel = activityViewOptions.find((option) => option.value === activitySegment)?.label ?? activityViewOptions[0]?.label ?? "Live";
 
+  // FNXC:PlannerOversight 2026-07-04-19:00: if oversight turns off (or was never active) while
+  // the Interventions segment is selected, fall back to Live so a hidden dropdown option never
+  // leaves a blank/selected segment behind.
+  useEffect(() => {
+    if (!oversightActive && activitySegment === "interventions") {
+      setActivitySegment("current");
+    }
+  }, [oversightActive, activitySegment]);
+
   const selectActivityView = useCallback((value: ActivitySegment) => {
     activityViewMenuViewportGuardUntilRef.current = 0;
     setActiveTab("chat");
@@ -4097,21 +4119,6 @@ export function TaskDetailContent({
                     )}
                   </div>
                 )}
-                {/*
-                FNXC:PlannerOversight 2026-07-04-18:00:
-                FN-7519 Intervention Timeline: rendered adjacent to the FN-7517
-                oversight cluster (no separate `.task-oversight-controls` class
-                exists in the merged FN-7517 code, so this attaches to the
-                closest existing seam — the same gating condition used by the
-                nudge/stop/explain controls above). Hidden entirely (no
-                leftover empty shell) when oversight is Off or unresolved, per
-                the Surface Enumeration gate.
-                */}
-                <PlannerInterventionTimeline
-                  taskId={task.id}
-                  projectId={projectId}
-                  hidden={!(hasTaskOversightOverride || workflowOversightResolved) || oversightIsOff}
-                />
                 {provenanceDisplay && (
                   <div className="detail-provenance">
                     <GitBranch aria-hidden="true" />
@@ -4474,6 +4481,14 @@ export function TaskDetailContent({
                   loadingMore={agentLogLoadingMore}
                   totalCount={agentLogTotal}
                 />
+              ) : activitySegment === "interventions" ? (
+                // FNXC:PlannerOversight 2026-07-04-19:00: FN-7571 relocates the FN-7519
+                // Intervention Timeline from the inline oversight cluster into this
+                // Activity segment. Reachable only via the dropdown, which already gates
+                // on oversightActive, so no `hidden` prop is needed here.
+                <div className="detail-activity" role="tabpanel">
+                  <PlannerInterventionTimeline taskId={task.id} projectId={projectId} />
+                </div>
               ) : (
                 <div className="detail-activity" role="tabpanel">
                   <button
diff --git a/packages/dashboard/app/components/__tests__/TaskDetailModal.oversight-controls.test.tsx b/packages/dashboard/app/components/__tests__/TaskDetailModal.oversight-controls.test.tsx
index 42292dccde..69e65c3224 100644
--- a/packages/dashboard/app/components/__tests__/TaskDetailModal.oversight-controls.test.tsx
+++ b/packages/dashboard/app/components/__tests__/TaskDetailModal.oversight-controls.test.tsx
@@ -477,3 +477,151 @@ describe("TaskDetailModal oversight controls — mobile breakpoint (FN-7521, FN-
     expect(screen.queryByTestId("detail-overseer-explain")).not.toBeInTheDocument();
   });
 });
+
+/*
+FNXC:PlannerOversight 2026-07-04-19:00:
+FN-7571 coverage: the FN-7519 Intervention Timeline moved from an inline
+mount in the oversight cluster into the Activity view dropdown as a fourth
+"Interventions" segment, gated on the same oversight-active expression the
+inline mount used. These assertions cover: (a) no inline mount remains,
+(b) the dropdown option appears/renders the timeline when oversight is
+active, (c) the option is absent and nothing mounts when oversight is off,
+and (d) selecting Interventions then losing oversight falls back to Live
+with no blank panel. Runs at the default (desktop) breakpoint, matching the
+first describe block's setup rather than the FN-7521/FN-7545 mobile one.
+*/
+describe("Intervention Timeline relocation into the Activity dropdown (FN-7571)", () => {
+  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 });
+  });
+
+    function openActivityViewMenu() {
+      const existingMenu = screen.queryByRole("menu", { name: "Activity views" });
+      if (!existingMenu) {
+        fireEvent.click(screen.getByRole("button", { name: "Activity" }));
+      }
+      return screen.getByRole("menu", { name: "Activity views" });
+    }
+
+    it("never renders the timeline inline in the oversight cluster", async () => {
+      render(
+        <TaskDetailModal
+          task={makeTask({ id: "FN-210", column: "in-progress", plannerOversightLevel: "autonomous", plannerOverseerState: activeSnapshot })}
+          onClose={noop}
+          onMoveTask={noopMove}
+          onDeleteTask={noopDelete}
+          onMergeTask={noopMerge}
+          onOpenDetail={noopOpenDetail}
+          addToast={noop}
+        />,
+      );
+
+      await screen.findByTestId("detail-overseer-nudge");
+      expect(screen.queryByTestId("planner-intervention-timeline")).not.toBeInTheDocument();
+    });
+
+    it("exposes an Interventions option in the Activity dropdown and renders the timeline when oversight is active", async () => {
+      render(
+        <TaskDetailModal
+          task={makeTask({ id: "FN-211", column: "in-progress", plannerOversightLevel: "autonomous", plannerOverseerState: activeSnapshot })}
+          onClose={noop}
+          onMoveTask={noopMove}
+          onDeleteTask={noopDelete}
+          onMergeTask={noopMerge}
+          onOpenDetail={noopOpenDetail}
+          addToast={noop}
+        />,
+      );
+
+      await screen.findByTestId("detail-overseer-nudge");
+      openActivityViewMenu();
+      const option = screen.getByRole("menuitem", { name: "Interventions" });
+      fireEvent.click(option);
+
+      expect(await screen.findByTestId("planner-intervention-timeline")).toBeInTheDocument();
+    });
+
+    it("omits the Interventions option and mounts nothing when oversight is off", async () => {
+      render(
+        <TaskDetailModal
+          task={makeTask({ id: "FN-212", column: "in-progress", plannerOversightLevel: "off" })}
+          onClose={noop}
+          onMoveTask={noopMove}
+          onDeleteTask={noopDelete}
+          onMergeTask={noopMerge}
+          onOpenDetail={noopOpenDetail}
+          addToast={noop}
+        />,
+      );
+
+      await screen.findByTestId("detail-oversight-level-select");
+      openActivityViewMenu();
+      expect(screen.queryByRole("menuitem", { name: "Interventions" })).not.toBeInTheDocument();
+      expect(screen.queryByTestId("planner-intervention-timeline")).not.toBeInTheDocument();
+    });
+
+    it("falls back to Live with no blank panel if oversight turns off after Interventions was selected", async () => {
+      const { rerender } = render(
+        <TaskDetailModal
+          task={makeTask({ id: "FN-213", column: "in-progress", plannerOversightLevel: "autonomous", plannerOverseerState: activeSnapshot })}
+          onClose={noop}
+          onMoveTask={noopMove}
+          onDeleteTask={noopDelete}
+          onMergeTask={noopMerge}
+          onOpenDetail={noopOpenDetail}
+          addToast={noop}
+        />,
+      );
+
+      await screen.findByTestId("detail-overseer-nudge");
+      openActivityViewMenu();
+      fireEvent.click(screen.getByRole("menuitem", { name: "Interventions" }));
+      expect(await screen.findByTestId("planner-intervention-timeline")).toBeInTheDocument();
+
+      rerender(
+        <TaskDetailModal
+          task={makeTask({ id: "FN-213", column: "in-progress", plannerOversightLevel: "off" })}
+          onClose={noop}
+          onMoveTask={noopMove}
+          onDeleteTask={noopDelete}
+          onMergeTask={noopMerge}
+          onOpenDetail={noopOpenDetail}
+          addToast={noop}
+        />,
+      );
+
+      await waitFor(() => {
+        expect(screen.queryByTestId("planner-intervention-timeline")).not.toBeInTheDocument();
+      });
+      openActivityViewMenu();
+      expect(screen.getByRole("menuitem", { name: "Live" })).toHaveAttribute("aria-current", "true");
+    });
+
+    it("still renders the empty state inside the Activity segment when there are no interventions", async () => {
+      render(
+        <TaskDetailModal
+          task={makeTask({ id: "FN-214", column: "in-progress", plannerOversightLevel: "autonomous", plannerOverseerState: activeSnapshot })}
+          onClose={noop}
+          onMoveTask={noopMove}
+          onDeleteTask={noopDelete}
+          onMergeTask={noopMerge}
+          onOpenDetail={noopOpenDetail}
+          addToast={noop}
+        />,
+      );
+
+      await screen.findByTestId("detail-overseer-nudge");
+      openActivityViewMenu();
+      fireEvent.click(screen.getByRole("menuitem", { name: "Interventions" }));
+
+      expect(await screen.findByTestId("planner-intervention-timeline-empty")).toBeInTheDocument();
+    });
+  });
+
diff --git a/packages/dashboard/app/components/__tests__/TaskDetailModal.task-activity-chat.test.tsx b/packages/dashboard/app/components/__tests__/TaskDetailModal.task-activity-chat.test.tsx
index bee0d0c4bb..12311a5a53 100644
--- a/packages/dashboard/app/components/__tests__/TaskDetailModal.task-activity-chat.test.tsx
+++ b/packages/dashboard/app/components/__tests__/TaskDetailModal.task-activity-chat.test.tsx
@@ -26,6 +26,11 @@ function renderModal(props: Partial<ComponentProps<typeof TaskDetailModal>> = {}
       task={makeTask({
         id: "FN-7315",
         column: "in-progress" as any,
+        // FNXC:PlannerOversight 2026-07-04-19:00: explicitly off so these Activity/Chat-tab
+        // integration tests (unrelated to FN-7571 oversight/intervention coverage) don't pick
+        // up the always-active default oversight level (autonomous) and gain an unrelated
+        // "Interventions" dropdown option.
+        plannerOversightLevel: "off",
         log: [
           { timestamp: "2026-06-30T20:00:00.000Z", action: "Started work", outcome: "Executor checked out" },
           { timestamp: "2026-06-30T20:01:00.000Z", action: "Posted update" },
@@ -686,7 +691,7 @@ describe("TaskDetailModal Activity and planner Chat tab integration", () => {
       mockRawLogs([]);
       render(
         <TaskDetailContent
-          task={makeTask({ id: "FN-7315-DONE", column: "done" as any, log: [], steeringComments: [] })}
+          task={makeTask({ id: "FN-7315-DONE", column: "done" as any, log: [], steeringComments: [], plannerOversightLevel: "off" })}
           embedded
           onRequestClose={noop}
           onMoveTask={noopMove}

From 9592e3ac5c9c2f3dc2b58a2c0ff101586ef2ec4a Mon Sep 17 00:00:00 2001
From: gsxdsm <gsxdsm@users.noreply.github.com>
Date: Sat, 4 Jul 2026 23:08:41 -0700
Subject: [PATCH 16/65] FN-7569: skip re-asking manual plan approval for
 unchanged re-specified plans

Manual plan approval now skips re-asking for approval when a re-specification produces an identical plan to one already approved.

- Add nullable Task.approvedPlanFingerprint field with DB migration 139 to track the approved PROMPT.md fingerprint
- Skip re-parking at awaiting-approval when replan/plan-review-retry/self-healing rebound yields the same plan fingerprint as before
- Require fresh approval when the plan content changes or when a plan is rejected
- Leave Release Authorization, Workflow Plan Review, and auto-approve-all behavior unchanged
- Add/extend tests across core (db, plan-approval, store-persistence), engine (triage), and dashboard (routes-github) to cover fingerprint comparison and idempotent re-approval
- Update docs (settings-reference.md, workflow-steps.md) to describe the idempotent approval behavior
- Add changeset for @runfusion/fusion (patch)

Files changed:
 .changeset/fn-7569-plan-approval-idempotent.md     |   7 +
 docs/settings-reference.md                         |   2 +-
 docs/workflow-steps.md                             |   2 +
 packages/core/src/__tests__/db.test.ts             |  54 +++++++
 packages/core/src/__tests__/plan-approval.test.ts  |  31 +++-
 .../core/src/__tests__/store-persistence.test.ts   |  39 +++++
 packages/core/src/db.ts                            |  22 ++-
 packages/core/src/index.ts                         |   2 +-
 packages/core/src/plan-approval.ts                 |  23 +++
 packages/core/src/store.ts                         |  20 ++-
 packages/core/src/types.ts                         |  13 ++
 .../dashboard/src/__tests__/routes-github.test.ts  |  69 +++++++-
 .../src/routes/register-task-workflow-routes.ts    |  37 ++++-
 packages/engine/src/__tests__/triage.test.ts       | 178 ++++++++++++++++++++-
 packages/engine/src/triage.ts                      |  58 +++++--
 15 files changed, 527 insertions(+), 30 deletions(-)

Fusion-Task-Id: FN-7569

Fusion-Task-Lineage: 7d3855ae-6f45-4571-90db-cf1ae3b541dd

Co-authored-by: Fusion (runfusion.ai) <noreply@runfusion.ai>
---
 .../fn-7569-plan-approval-idempotent.md       |   7 +
 docs/settings-reference.md                    |   2 +-
 docs/workflow-steps.md                        |   2 +
 packages/core/src/__tests__/db.test.ts        |  54 ++++++
 .../core/src/__tests__/plan-approval.test.ts  |  31 ++-
 .../src/__tests__/store-persistence.test.ts   |  39 ++++
 packages/core/src/db.ts                       |  22 ++-
 packages/core/src/index.ts                    |   2 +-
 packages/core/src/plan-approval.ts            |  23 +++
 packages/core/src/store.ts                    |  20 +-
 packages/core/src/types.ts                    |  13 ++
 .../src/__tests__/routes-github.test.ts       |  69 ++++++-
 .../routes/register-task-workflow-routes.ts   |  37 +++-
 packages/engine/src/__tests__/triage.test.ts  | 178 +++++++++++++++++-
 packages/engine/src/triage.ts                 |  58 ++++--
 15 files changed, 527 insertions(+), 30 deletions(-)
 create mode 100644 .changeset/fn-7569-plan-approval-idempotent.md

diff --git a/.changeset/fn-7569-plan-approval-idempotent.md b/.changeset/fn-7569-plan-approval-idempotent.md
new file mode 100644
index 0000000000..7e50bcf5b3
--- /dev/null
+++ b/.changeset/fn-7569-plan-approval-idempotent.md
@@ -0,0 +1,7 @@
+---
+"@runfusion/fusion": patch
+---
+
+summary: Manual plan approval no longer re-asks you to approve a plan you already approved when it hasn't changed.
+category: fix
+dev: FN-7569 — approving a plan records a fingerprint of the approved PROMPT.md (new nullable Task.approvedPlanFingerprint, migration 139). The manual plan-approval gate skips re-parking at awaiting-approval when a re-specification (replan, plan-review retry, self-healing rebound) produces the same plan; a changed plan or reject-plan still requires fresh approval. Release authorization, Workflow Plan Review, and auto-approve-all are unchanged.
diff --git a/docs/settings-reference.md b/docs/settings-reference.md
index 078ab035ba..3443cc6f53 100644
--- a/docs/settings-reference.md
+++ b/docs/settings-reference.md
@@ -419,7 +419,7 @@ Security-sensitive file-browser escape hatches are project-only. `allowAbsoluteF
 | `overlapIgnorePaths` | `string[]` | `[]` | Optional project-relative file or directory paths to exclude from overlap blocking (for example `docs` or `generated/openapi.json`). Entries are trimmed, deduplicated, and must not be absolute or contain `..` traversal. |
 | `allowAbsoluteFileBrowserPaths` | `boolean` | `false` | Project-scoped Settings → General toggle for the workspace file browser. When enabled, slash-prefixed paths such as `/tmp` can be listed/read/written/downloaded through workspace file-browser routes while keeping existing file-size, binary, type, null-byte, traversal, and permission checks. Windows drive-letter paths remain blocked, and task-local file routes, memory APIs, worktree-copy validation, plugin bundle paths, and other validators are unchanged. |
 | `autoMerge` | `boolean` | `true` | Auto-finalize tasks from `in-review`. Tasks can override this per-task (including at create time in New Task modal via **Auto-merge** = Default/Enabled/Disabled); explicit overrides are tagged with `autoMergeProvenance: "user"`, while tasks left at **Default** keep following the live global setting and do not snapshot it when entering review. Legacy pre-FN-6245 in-review rows that were stamped `autoMerge: true` are marked `autoMergeProvenance: "legacy-stamp"` on startup and can be inspected/cleared with Settings → Merge → **Legacy auto-merge stamp cleanup**, `fn pr automerge-cleanup [--apply] [--json]`, or `reconcileLegacyAutoMergeStamps({ apply: true })` after operator review. For grouped branch flows, per-task `autoMerge` governs member→group-integration landing while group `autoMerge` governs group→default-branch promotion eligibility. |
-| `planApprovalMode` | `"workflow" \| "auto-approve-all" \| "require-all"` | `"auto-approve-all"` | Project-scoped override for the manual planning approval gate. Defaults to auto-approve-all (FN-7557) so new/unset projects skip the manual gate; `"workflow"` instead preserves the workflow-resolved `requirePlanApproval`; `"auto-approve-all"` moves every successfully specified task to `todo` without manual plan approval even when the selected workflow or stored workflow setting has `requirePlanApproval: true`; `"require-all"` parks every specified task at `status: "awaiting-approval"` regardless of workflow settings. Settings → Merge remains the full three-state editor; the Board Triage/intake **Auto-approve plan** switch is a binary shortcut for `"auto-approve-all"` vs `"workflow"`. This does not disable Workflow Plan Review, release authorization, or other non-plan safety gates. **FN-7559:** release authorization and the manual gate both use `status: "awaiting-approval"`, so a release-class task that still parks under `"auto-approve-all"` is NOT a broken auto-approve — it is the intentionally-not-bypassed release-authorization gate. The task carries `awaitingApprovalReason: "release-authorization"` in that case (undefined for a genuine manual hold), and the dashboard renders a distinct "Awaiting Release Authorization" label with the Approve/Reject Plan buttons hidden, instead of the generic manual-approval affordance. |
+| `planApprovalMode` | `"workflow" \| "auto-approve-all" \| "require-all"` | `"auto-approve-all"` | Project-scoped override for the manual planning approval gate. Defaults to auto-approve-all (FN-7557) so new/unset projects skip the manual gate; `"workflow"` instead preserves the workflow-resolved `requirePlanApproval`; `"auto-approve-all"` moves every successfully specified task to `todo` without manual plan approval even when the selected workflow or stored workflow setting has `requirePlanApproval: true`; `"require-all"` parks every specified task at `status: "awaiting-approval"` regardless of workflow settings. Settings → Merge remains the full three-state editor; the Board Triage/intake **Auto-approve plan** switch is a binary shortcut for `"auto-approve-all"` vs `"workflow"`. This does not disable Workflow Plan Review, release authorization, or other non-plan safety gates. **FN-7559:** release authorization and the manual gate both use `status: "awaiting-approval"`, so a release-class task that still parks under `"auto-approve-all"` is NOT a broken auto-approve — it is the intentionally-not-bypassed release-authorization gate. The task carries `awaitingApprovalReason: "release-authorization"` in that case (undefined for a genuine manual hold), and the dashboard renders a distinct "Awaiting Release Authorization" label with the Approve/Reject Plan buttons hidden, instead of the generic manual-approval affordance. **FN-7569:** approving a plan under `"workflow"`/`"require-all"` manual approval records a fingerprint (hash) of the exact approved `PROMPT.md`. If the task is later re-specified (a replan, a plan-review reviewer-outage retry, or a self-healing rebound back to triage) and produces the identical plan content, the manual gate is idempotent: it skips re-parking at `status: "awaiting-approval"` and proceeds straight to `todo`, so the operator is never asked to re-approve a plan they already approved. A genuinely changed `PROMPT.md` still re-asks, and rejecting a plan (Reject Plan) clears the fingerprint so the regenerated plan is treated as new. This idempotency check lives strictly inside the manual gate, after release authorization and Workflow Plan Review have already decided, and has no effect under `"auto-approve-all"` (which never reaches the manual gate). |
 | `maxAutoMergeRetries` | `number` | `3` | Project-scoped positive-integer cap for auto-merge conflict-resolution retries before Fusion parks or bounces a task for human/recovery handling. Unset, non-finite, zero, or negative values fall back to `3` to preserve historical behavior. |
 | `mergeRequestContractShadowEnabled` | `boolean` | `false` | Phase-1 FN-5741 write-only shadow flag (project/global setting). When enabled, executor/self-healing/merger persist merge-request records and `completion_handoff_accepted` markers for observation only; legacy mergeQueue + lifecycle remains authoritative. |
 | `mergeStrategy` | `"direct" \| "pull-request"` | `"direct"` | Completion mode (local direct merge vs PR-first). |
diff --git a/docs/workflow-steps.md b/docs/workflow-steps.md
index bb314fe3da..eb89aace9e 100644
--- a/docs/workflow-steps.md
+++ b/docs/workflow-steps.md
@@ -214,6 +214,8 @@ Workflow Plan Review is separate from manual plan approval. Project `planApprova
 
 **FN-7559 — telling the three holds apart:** Plan Review parks a task with its own distinct statuses (`needs-replan` for a revision verdict, `plan-review-unavailable` for a reviewer-outage retry), so it never renders identically to a plan-approval hold. The release-authorization gate and the manual plan-approval gate, however, both use `status: "awaiting-approval"` — auto-approve-all bypasses the manual gate but never the release-authorization gate, so a release-class task (or a user-authored task missing the explicit authorization marker) still parks even with auto-approve-all on. To make that unambiguous to the operator, the task carries `awaitingApprovalReason: "release-authorization"` only when the release-authorization gate is the one holding it; the dashboard renders a distinct "Awaiting Release Authorization" label and hides the Approve/Reject Plan buttons for that hold instead of showing the generic manual-approval affordance.
 
+**FN-7569 — manual plan approval is idempotent against unchanged plans:** approving a plan under the manual gate records a fingerprint of the exact approved `PROMPT.md`. If the same task is later re-specified — a `needs-replan` replan, a Plan Review reviewer-outage retry, or a self-healing rebound back to `triage` — and produces byte-identical `PROMPT.md` content, the manual gate detects the match and proceeds straight to `todo` instead of re-parking at `status: "awaiting-approval"`. A genuinely revised plan still produces a different fingerprint and re-asks as before, and using Reject Plan clears the fingerprint so the regenerated plan is always treated as new. This idempotency check runs only inside the manual gate, strictly after release authorization and Plan Review have already made their independent decisions, and never applies under `planApprovalMode: "auto-approve-all"` (which bypasses the manual gate entirely).
+
 `builtin:legacy-coding` is backed by the original monolithic `BUILTIN_CODING_WORKFLOW_IR`: `planning` → `execute` → optional quality gates → `review` → merge region.
 
 `builtin:stepwise-coding` displays as Coding (per-step review). It is backed by `BUILTIN_STEPWISE_CODING_WORKFLOW_IR`; it keeps the same lifecycle columns/traits while adding the default-on optional Plan Review before `parse-steps`, modeling per-step parse/execute/review/rework as authored graph structure, and retaining the post-foreach optional Code Review gate before its final review/merge region.
diff --git a/packages/core/src/__tests__/db.test.ts b/packages/core/src/__tests__/db.test.ts
index efc1045b4f..f667939d84 100644
--- a/packages/core/src/__tests__/db.test.ts
+++ b/packages/core/src/__tests__/db.test.ts
@@ -1876,6 +1876,60 @@ describe("schema migrations", () => {
     db.close();
   });
 
+  /*
+   * FNXC:PlanApproval 2026-07-04-22:41:
+   * FN-7569: migration 139 adds approvedPlanFingerprint so manual plan approval can be
+   * idempotent against unchanged plan content — an approved-then-re-specified task whose
+   * PROMPT.md is unchanged should not be re-parked at awaiting-approval. Additive-only,
+   * no backfill — legacy rows stay NULL, meaning "never approved" (falls back to today's
+   * always-re-park behavior).
+   */
+  it("migrates v138 databases by adding approvedPlanFingerprint column with legacy rows staying NULL (no backfill)", () => {
+    tmpDir = makeTmpDir();
+    const fusionDir = join(tmpDir, ".fusion");
+    const db = new Database(fusionDir);
+
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS __meta (key TEXT PRIMARY KEY, value TEXT);
+      CREATE TABLE IF NOT EXISTS tasks (
+        id TEXT PRIMARY KEY,
+        description TEXT NOT NULL,
+        "column" TEXT NOT NULL,
+        status TEXT,
+        createdAt TEXT NOT NULL,
+        updatedAt TEXT NOT NULL,
+        executionMode TEXT DEFAULT 'standard',
+        plannerOversightLevel TEXT,
+        awaitingApprovalReason TEXT
+      );
+      CREATE TABLE IF NOT EXISTS config (
+        id INTEGER PRIMARY KEY CHECK (id = 1),
+        nextId INTEGER DEFAULT 1,
+        nextWorkflowStepId INTEGER DEFAULT 1,
+        settings TEXT DEFAULT '{}',
+        workflowSteps TEXT DEFAULT '[]',
+        updatedAt TEXT
+      );
+    `);
+    db.exec("INSERT INTO __meta (key, value) VALUES ('schemaVersion', '138')");
+    db.exec("INSERT INTO __meta (key, value) VALUES ('lastModified', '1000')");
+    db.exec(`INSERT INTO tasks (id, description, "column", status, createdAt, updatedAt) VALUES ('FN-1', 'legacy', 'triage', 'awaiting-approval', '2026-01-01', '2026-01-01')`);
+
+    db.init();
+
+    expect(db.getSchemaVersion()).toBe(SCHEMA_VERSION);
+
+    const cols = db.prepare("PRAGMA table_info(tasks)").all() as Array<{ name: string }>;
+    expect(cols.map((col) => col.name)).toContain("approvedPlanFingerprint");
+
+    const task = db.prepare("SELECT approvedPlanFingerprint FROM tasks WHERE id = 'FN-1'").get() as {
+      approvedPlanFingerprint: string | null;
+    };
+    expect(task.approvedPlanFingerprint).toBeNull();
+
+    db.close();
+  });
+
   it("migrates v43 databases by adding task token-usage aggregate columns with null-compatible defaults", () => {
     tmpDir = makeTmpDir();
     const fusionDir = join(tmpDir, ".fusion");
diff --git a/packages/core/src/__tests__/plan-approval.test.ts b/packages/core/src/__tests__/plan-approval.test.ts
index 418ca0d5e8..695fb7722c 100644
--- a/packages/core/src/__tests__/plan-approval.test.ts
+++ b/packages/core/src/__tests__/plan-approval.test.ts
@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest";
-import { resolvePlanApprovalRequired, type PlanApprovalMode } from "../plan-approval.js";
+import { computePlanApprovalFingerprint, resolvePlanApprovalRequired, type PlanApprovalMode } from "../plan-approval.js";
 
 const workflowValues = [true, false, undefined] as const;
 
@@ -35,3 +35,32 @@ describe("resolvePlanApprovalRequired", () => {
     ).toBe(false);
   });
 });
+
+/*
+ * FNXC:PlanApproval 2026-07-04-22:41:
+ * FN-7569 — computePlanApprovalFingerprint coverage: stable for identical content, normalizes only
+ * trailing whitespace/newlines, and differs whenever the actual plan body changes.
+ */
+describe("computePlanApprovalFingerprint", () => {
+  it("is stable for the same content across repeated calls", () => {
+    const text = "# Task: FN-1\n\n## File Scope\n\n- a.ts\n";
+    expect(computePlanApprovalFingerprint(text)).toBe(computePlanApprovalFingerprint(text));
+  });
+
+  it("is unaffected by trailing whitespace or trailing newline differences", () => {
+    const base = "# Task: FN-1\n\n## File Scope\n\n- a.ts";
+    expect(computePlanApprovalFingerprint(base)).toBe(computePlanApprovalFingerprint(`${base}\n`));
+    expect(computePlanApprovalFingerprint(base)).toBe(computePlanApprovalFingerprint(`${base}\n\n\n`));
+    expect(computePlanApprovalFingerprint("line one   \nline two")).toBe(computePlanApprovalFingerprint("line one\nline two"));
+  });
+
+  it("differs when the plan content actually changes", () => {
+    const original = "# Task: FN-1\n\n## File Scope\n\n- a.ts\n";
+    const changed = "# Task: FN-1\n\n## File Scope\n\n- a.ts\n- b.ts\n";
+    expect(computePlanApprovalFingerprint(original)).not.toBe(computePlanApprovalFingerprint(changed));
+  });
+
+  it("produces a hex sha256-length digest", () => {
+    expect(computePlanApprovalFingerprint("anything")).toMatch(/^[0-9a-f]{64}$/);
+  });
+});
diff --git a/packages/core/src/__tests__/store-persistence.test.ts b/packages/core/src/__tests__/store-persistence.test.ts
index c54be7ee39..247ab2f398 100644
--- a/packages/core/src/__tests__/store-persistence.test.ts
+++ b/packages/core/src/__tests__/store-persistence.test.ts
@@ -59,6 +59,45 @@ describe("TaskStore", () => {
     });
   });
 
+  /*
+   * FNXC:PlanApproval 2026-07-04-22:41:
+   * FN-7569 — approvedPlanFingerprint must survive create/update/null-clear round trips through
+   * SQLite so the manual plan-approval gate can compare it against the freshly written PROMPT.md
+   * on every re-specification, even after a full store reopen.
+   */
+  describe("approvedPlanFingerprint persistence", () => {
+    it("round-trips approvedPlanFingerprint through updateTask and getTask", async () => {
+      const task = await harness.store().createTask({ description: "Approval fingerprint task" });
+      expect(task.approvedPlanFingerprint).toBeUndefined();
+
+      const updated = await harness.store().updateTask(task.id, { approvedPlanFingerprint: "abc123" });
+      expect(updated.approvedPlanFingerprint).toBe("abc123");
+
+      const detail = await harness.store().getTask(task.id);
+      expect(detail.approvedPlanFingerprint).toBe("abc123");
+    });
+
+    it("clears approvedPlanFingerprint with an explicit null update (reject-plan semantics)", async () => {
+      const task = await harness.store().createTask({ description: "Approval fingerprint task" });
+      await harness.store().updateTask(task.id, { approvedPlanFingerprint: "abc123" });
+
+      const cleared = await harness.store().updateTask(task.id, { approvedPlanFingerprint: null });
+      expect(cleared.approvedPlanFingerprint).toBeUndefined();
+
+      const detail = await harness.store().getTask(task.id);
+      expect(detail.approvedPlanFingerprint).toBeUndefined();
+    });
+
+    it("returns approvedPlanFingerprint from listTasks", async () => {
+      const task = await harness.store().createTask({ description: "Approval fingerprint list task" });
+      await harness.store().updateTask(task.id, { approvedPlanFingerprint: "xyz789" });
+
+      const tasks = await harness.store().listTasks();
+      const listed = tasks.find((t) => t.id === task.id);
+      expect(listed?.approvedPlanFingerprint).toBe("xyz789");
+    });
+  });
+
   // FNXC:Workspace 2026-06-24-15:30 (multiworkspace fn_task_done regression):
   // task.workspaceWorktrees previously had NO SQLite column / no rowToTask mapping, so
   // fn_acquire_repo_worktree's updateTask({workspaceWorktrees}) set it only in memory and the very
diff --git a/packages/core/src/db.ts b/packages/core/src/db.ts
index 9ccc400a08..f0fc0198d3 100644
--- a/packages/core/src/db.ts
+++ b/packages/core/src/db.ts
@@ -183,7 +183,7 @@ export function isFts5CorruptionError(error: unknown): boolean {
 
 // ── Schema Definition ────────────────────────────────────────────────
 
-const SCHEMA_VERSION = 138;
+const SCHEMA_VERSION = 139;
 
 const TASKS_FTS_AUTOMERGE = 8;
 const TASKS_FTS_CRISISMERGE = 16;
@@ -301,6 +301,7 @@ CREATE TABLE IF NOT EXISTS tasks (
   executionMode TEXT DEFAULT 'standard',
   plannerOversightLevel TEXT,
   awaitingApprovalReason TEXT,
+  approvedPlanFingerprint TEXT,
   tokenUsageInputTokens INTEGER,
   tokenUsageOutputTokens INTEGER,
   tokenUsageCachedTokens INTEGER,
@@ -5590,6 +5591,25 @@ export class Database {
       });
     }
 
+    if (version < 139) {
+      /*
+       * FNXC:PlanApproval 2026-07-04-22:41:
+       * FN-7569 — manual plan approval had no persisted record of what the operator actually
+       * approved, so re-specification of an already-approved, unchanged plan (replan,
+       * plan-review reviewer-outage retry, self-healing rebound to triage) re-triggered the
+       * manual gate and re-parked the identical plan at "awaiting-approval", forcing the
+       * operator to re-approve a plan they already approved. This nullable column stores only
+       * a hash (computePlanApprovalFingerprint in packages/core/src/plan-approval.ts) of the
+       * last operator-approved PROMPT.md, set by POST /tasks/:id/approve-plan and cleared by
+       * POST /tasks/:id/reject-plan. Additive-only: NULL means never-approved (legacy rows) or
+       * a rejected/cleared approval, and the manual gate falls back to today's always-re-park
+       * behavior for those rows. No backfill.
+       */
+      this.applyMigration(139, () => {
+        this.addColumnIfMissing("tasks", "approvedPlanFingerprint", "TEXT");
+      });
+    }
+
   }
 
   /**
diff --git a/packages/core/src/index.ts b/packages/core/src/index.ts
index ea537ef253..db2fbf4f97 100644
--- a/packages/core/src/index.ts
+++ b/packages/core/src/index.ts
@@ -26,7 +26,7 @@ export type { AnthropicProviderRegistration } from "./anthropic-models.js";
 export { detectImageMimeFromBytes } from "./image-mime.js";
 export type { DetectedImageMime } from "./image-mime.js";
 export { redactSecrets } from "./redact-secrets.js";
-export { resolvePlanApprovalRequired } from "./plan-approval.js";
+export { computePlanApprovalFingerprint, resolvePlanApprovalRequired } from "./plan-approval.js";
 export type { PlanApprovalMode } from "./plan-approval.js";
 export { isActiveNearDuplicateColumn, isNearDuplicateCanonicalInactive } from "./near-duplicate-canonical.js";
 export type { NearDuplicateCanonicalState } from "./near-duplicate-canonical.js";
diff --git a/packages/core/src/plan-approval.ts b/packages/core/src/plan-approval.ts
index 13041bb29c..4d4bbc20f3 100644
--- a/packages/core/src/plan-approval.ts
+++ b/packages/core/src/plan-approval.ts
@@ -1,7 +1,30 @@
+import { createHash } from "node:crypto";
 import type { ProjectSettings } from "./types.js";
 
 export type PlanApprovalMode = NonNullable<ProjectSettings["planApprovalMode"]>;
 
+/**
+ * FNXC:PlanApproval 2026-07-04-22:41:
+ * FN-7569 — manual plan approval was not idempotent against unchanged plan content: an
+ * operator approving a plan (auto-approve-all off) had no persisted record of *what* they
+ * approved, so any re-specification of the same task (replan, plan-review reviewer-outage
+ * retry, self-healing rebound to triage) that re-ran finalizeApprovedTask re-triggered the
+ * manual gate and re-parked an already-approved, byte-identical plan at "awaiting-approval".
+ * computePlanApprovalFingerprint gives approve-plan a stable hash of the approved PROMPT.md
+ * (Task.approvedPlanFingerprint) so the manual gate can skip re-parking when the freshly
+ * written PROMPT.md is unchanged, while still re-asking when the plan genuinely changed or
+ * was rejected. Normalizes only trailing whitespace/newlines so cosmetic write differences
+ * (trailing newline, trailing spaces) never cause spurious re-approval.
+ */
+export function computePlanApprovalFingerprint(promptText: string): string {
+  const normalized = promptText
+    .split("\n")
+    .map((line) => line.replace(/[ \t]+$/, ""))
+    .join("\n")
+    .replace(/\s+$/, "");
+  return createHash("sha256").update(normalized, "utf8").digest("hex");
+}
+
 /**
  * FNXC:PlanApproval 2026-06-26-00:00:
  * Per-project planApprovalMode controls the planning approval gate for every task in the project: require-all always parks approved specs for manual approval, auto-approve-all always bypasses the gate, and workflow/undefined preserves the workflow-resolved requirePlanApproval value.
diff --git a/packages/core/src/store.ts b/packages/core/src/store.ts
index f2244d84b7..12e638163b 100644
--- a/packages/core/src/store.ts
+++ b/packages/core/src/store.ts
@@ -272,6 +272,7 @@ interface TaskRow {
   executionMode: string | null;
   plannerOversightLevel: string | null;
   awaitingApprovalReason: string | null;
+  approvedPlanFingerprint: string | null;
   tokenUsageInputTokens: number | null;
   tokenUsageOutputTokens: number | null;
   tokenUsageCachedTokens: number | null;
@@ -446,6 +447,13 @@ const TASK_COLUMN_DESCRIPTORS: TaskColumnDescriptor[] = [
    * the same task never survives past the manual gate's own awaiting-approval.
    */
   defineTaskColumn("awaitingApprovalReason", (task) => task.awaitingApprovalReason ?? null),
+  /*
+   * FNXC:PlanApproval 2026-07-04-22:41:
+   * FN-7569 — hash of the last operator-approved PROMPT.md (computePlanApprovalFingerprint).
+   * Set by POST /tasks/:id/approve-plan, cleared by POST /tasks/:id/reject-plan, and consulted
+   * by the manual plan-approval gate to skip re-parking an unchanged, already-approved plan.
+   */
+  defineTaskColumn("approvedPlanFingerprint", (task) => task.approvedPlanFingerprint ?? null),
   defineTaskColumn("tokenUsageInputTokens", (task) => task.tokenUsage?.inputTokens ?? null),
   defineTaskColumn("tokenUsageOutputTokens", (task) => task.tokenUsage?.outputTokens ?? null),
   defineTaskColumn("tokenUsageCachedTokens", (task) => task.tokenUsage?.cachedTokens ?? null),
@@ -2145,6 +2153,7 @@ export class TaskStore extends EventEmitter<TaskStoreEvents> {
       executionMode: (row.executionMode || undefined) as Task["executionMode"],
       plannerOversightLevel: (row.plannerOversightLevel || undefined) as Task["plannerOversightLevel"],
       awaitingApprovalReason: (row.awaitingApprovalReason || undefined) as Task["awaitingApprovalReason"],
+      approvedPlanFingerprint: row.approvedPlanFingerprint || undefined,
       createdAt: row.createdAt,
       updatedAt: row.updatedAt,
       columnMovedAt: row.columnMovedAt || undefined,
@@ -2701,7 +2710,7 @@ export class TaskStore extends EventEmitter<TaskStoreEvents> {
       "validatorModelProvider", "validatorModelId",
       "planningModelProvider", "planningModelId",
       "mergeRetries", "workflowStepRetries", "stuckKillCount", "resumeLimboCount", "graphResumeRetryCount", "resumeLimboTipSha", "resumeLimboStepSignature", "postReviewFixCount", "recoveryRetryCount", "taskDoneRetryCount", "worktreeSessionRetryCount", "completionHandoffLimboRecoveryCount", "verificationFailureCount", "mergeConflictBounceCount", "mergeAuditBounceCount", "mergeTransientRetryCount", "branchConflictRecoveryCount", "reviewerContextRetryCount", "reviewerFallbackRetryCount", "nextRecoveryAt",
-      "error", "summary", "thinkingLevel", "executionMode", "plannerOversightLevel", "awaitingApprovalReason",
+      "error", "summary", "thinkingLevel", "executionMode", "plannerOversightLevel", "awaitingApprovalReason", "approvedPlanFingerprint",
       "tokenUsageInputTokens", "tokenUsageOutputTokens", "tokenUsageCachedTokens", "tokenUsageCacheWriteTokens", "tokenUsageTotalTokens", "tokenUsageFirstUsedAt", "tokenUsageLastUsedAt", "tokenUsageModelProvider", "tokenUsageModelId", "tokenUsagePerModel", "tokenBudgetSoftAlertedAt", "tokenBudgetHardAlertedAt", "tokenBudgetOverride",
       "createdAt", "updatedAt", "columnMovedAt", "firstExecutionAt", "cumulativeActiveMs", "columnDwellMs", "executionStartedAt", "executionCompletedAt",
       "dependencies", "steps", "customFields", "comments", "review", "reviewState", "workflowStepResults", "steeringComments",
@@ -2797,7 +2806,7 @@ export class TaskStore extends EventEmitter<TaskStoreEvents> {
       "validatorModelProvider", "validatorModelId",
       "planningModelProvider", "planningModelId",
       "mergeRetries", "workflowStepRetries", "stuckKillCount", "resumeLimboCount", "graphResumeRetryCount", "resumeLimboTipSha", "resumeLimboStepSignature", "postReviewFixCount", "recoveryRetryCount", "taskDoneRetryCount", "worktreeSessionRetryCount", "completionHandoffLimboRecoveryCount", "verificationFailureCount", "mergeConflictBounceCount", "mergeAuditBounceCount", "mergeTransientRetryCount", "branchConflictRecoveryCount", "reviewerContextRetryCount", "reviewerFallbackRetryCount", "nextRecoveryAt",
-      "error", "summary", "thinkingLevel", "executionMode", "plannerOversightLevel", "awaitingApprovalReason",
+      "error", "summary", "thinkingLevel", "executionMode", "plannerOversightLevel", "awaitingApprovalReason", "approvedPlanFingerprint",
       "tokenUsageInputTokens", "tokenUsageOutputTokens", "tokenUsageCachedTokens", "tokenUsageCacheWriteTokens", "tokenUsageTotalTokens", "tokenUsageFirstUsedAt", "tokenUsageLastUsedAt", "tokenUsageModelProvider", "tokenUsageModelId", "tokenUsagePerModel", "tokenBudgetSoftAlertedAt", "tokenBudgetHardAlertedAt", "tokenBudgetOverride",
       "createdAt", "updatedAt", "columnMovedAt", "firstExecutionAt", "cumulativeActiveMs", "columnDwellMs", "executionStartedAt", "executionCompletedAt",
       "dependencies", "steps", "customFields", "attachments", "steeringComments",
@@ -8417,7 +8426,7 @@ ${TASK_UPSERT_SQL_ASSIGNMENTS}
 
   async updateTask(
     id: string,
-    updates: { title?: string; description?: string; priority?: TaskPriority | null; prompt?: string; worktree?: string | null; workspaceWorktrees?: import("./types.js").Task["workspaceWorktrees"]; status?: string | null; dependencies?: string[]; steps?: import("./types.js").TaskStep[]; customFields?: Record<string, unknown>; currentStep?: number; blockedBy?: string | null; overlapBlockedBy?: string | null; assignedAgentId?: string | null; pausedByAgentId?: string | null; pausedReason?: string | null; tokenBudgetSoftAlertedAt?: string | null; worktrunkFallbackAlertedAt?: string | null; worktrunkFailure?: import("./types.js").Task["worktrunkFailure"] | null; tokenBudgetHardAlertedAt?: string | null; tokenBudgetOverride?: import("./types.js").TaskTokenBudgetOverride | null; dispatchStormCount?: number | null; lastDispatchAt?: string | null; assigneeUserId?: string | null; scopeOverride?: boolean | null; scopeOverrideReason?: string | null; scopeAutoWiden?: string[] | null; nodeId?: string | null; effectiveNodeId?: string | null; effectiveNodeSource?: string | null; checkedOutBy?: string | null; checkedOutAt?: string | null; checkoutNodeId?: string | null; checkoutRunId?: string | null; checkoutLeaseRenewedAt?: string | null; checkoutLeaseEpoch?: number | null; paused?: boolean; baseBranch?: string | null; autoMerge?: boolean | null; branch?: string | null; executionStartBranch?: string | null; baseCommitSha?: string | null; size?: "S" | "M" | "L"; reviewLevel?: number; executionMode?: import("./types.js").ExecutionMode | null; plannerOversightLevel?: import("./types.js").PlannerOversightLevel | null; awaitingApprovalReason?: import("./types.js").Task["awaitingApprovalReason"] | null; mergeRetries?: number; workflowStepRetries?: number; stuckKillCount?: number | null; resumeLimboCount?: number | null; graphResumeRetryCount?: number | null; resumeLimboTipSha?: string | null; resumeLimboStepSignature?: string | null; postReviewFixCount?: number | null; recoveryRetryCount?: number | null; taskDoneRetryCount?: number | null; worktreeSessionRetryCount?: number | null; completionHandoffLimboRecoveryCount?: number | null; verificationFailureCount?: number | null; mergeConflictBounceCount?: number | null; mergeAuditBounceCount?: number | null; mergeTransientRetryCount?: number | null; branchConflictRecoveryCount?: number | null; reviewerContextRetryCount?: number | null; reviewerFallbackRetryCount?: number | null; nextRecoveryAt?: string | null; enabledWorkflowSteps?: string[]; noCommitsExpected?: boolean | null; modelProvider?: string | null; modelId?: string | null; validatorModelProvider?: string | null; validatorModelId?: string | null; planningModelProvider?: string | null; planningModelId?: string | null; thinkingLevel?: string | null; error?: string | null; summary?: string | null; sessionFile?: string | null; firstExecutionAt?: string | null; cumulativeActiveMs?: number | null; executionStartedAt?: string | null; executionCompletedAt?: string | null; review?: import("./types.js").TaskReview | null; reviewState?: import("./types.js").TaskReviewState | null; workflowStepResults?: import("./types.js").WorkflowStepResult[] | null; mergeDetails?: import("./types.js").MergeDetails | null; sourceIssue?: import("./types.js").TaskSourceIssue | null; sourceMetadataPatch?: Record<string, unknown> | null; githubTracking?: import("./types.js").TaskGithubTracking | null; gitlabTracking?: (Omit<import("./types.js").TaskGitLabTracking, "item"> & { item?: import("./types.js").TaskGitLabTrackedItem | null }) | null; tokenUsage?: import("./types.js").TaskTokenUsage | null; modifiedFiles?: string[] | null; workflowTransitionNotification?: import("./types.js").Task["workflowTransitionNotification"] | null; missionId?: string | null; sliceId?: string | null },
+    updates: { title?: string; description?: string; priority?: TaskPriority | null; prompt?: string; worktree?: string | null; workspaceWorktrees?: import("./types.js").Task["workspaceWorktrees"]; status?: string | null; dependencies?: string[]; steps?: import("./types.js").TaskStep[]; customFields?: Record<string, unknown>; currentStep?: number; blockedBy?: string | null; overlapBlockedBy?: string | null; assignedAgentId?: string | null; pausedByAgentId?: string | null; pausedReason?: string | null; tokenBudgetSoftAlertedAt?: string | null; worktrunkFallbackAlertedAt?: string | null; worktrunkFailure?: import("./types.js").Task["worktrunkFailure"] | null; tokenBudgetHardAlertedAt?: string | null; tokenBudgetOverride?: import("./types.js").TaskTokenBudgetOverride | null; dispatchStormCount?: number | null; lastDispatchAt?: string | null; assigneeUserId?: string | null; scopeOverride?: boolean | null; scopeOverrideReason?: string | null; scopeAutoWiden?: string[] | null; nodeId?: string | null; effectiveNodeId?: string | null; effectiveNodeSource?: string | null; checkedOutBy?: string | null; checkedOutAt?: string | null; checkoutNodeId?: string | null; checkoutRunId?: string | null; checkoutLeaseRenewedAt?: string | null; checkoutLeaseEpoch?: number | null; paused?: boolean; baseBranch?: string | null; autoMerge?: boolean | null; branch?: string | null; executionStartBranch?: string | null; baseCommitSha?: string | null; size?: "S" | "M" | "L"; reviewLevel?: number; executionMode?: import("./types.js").ExecutionMode | null; plannerOversightLevel?: import("./types.js").PlannerOversightLevel | null; awaitingApprovalReason?: import("./types.js").Task["awaitingApprovalReason"] | null; approvedPlanFingerprint?: string | null; mergeRetries?: number; workflowStepRetries?: number; stuckKillCount?: number | null; resumeLimboCount?: number | null; graphResumeRetryCount?: number | null; resumeLimboTipSha?: string | null; resumeLimboStepSignature?: string | null; postReviewFixCount?: number | null; recoveryRetryCount?: number | null; taskDoneRetryCount?: number | null; worktreeSessionRetryCount?: number | null; completionHandoffLimboRecoveryCount?: number | null; verificationFailureCount?: number | null; mergeConflictBounceCount?: number | null; mergeAuditBounceCount?: number | null; mergeTransientRetryCount?: number | null; branchConflictRecoveryCount?: number | null; reviewerContextRetryCount?: number | null; reviewerFallbackRetryCount?: number | null; nextRecoveryAt?: string | null; enabledWorkflowSteps?: string[]; noCommitsExpected?: boolean | null; modelProvider?: string | null; modelId?: string | null; validatorModelProvider?: string | null; validatorModelId?: string | null; planningModelProvider?: string | null; planningModelId?: string | null; thinkingLevel?: string | null; error?: string | null; summary?: string | null; sessionFile?: string | null; firstExecutionAt?: string | null; cumulativeActiveMs?: number | null; executionStartedAt?: string | null; executionCompletedAt?: string | null; review?: import("./types.js").TaskReview | null; reviewState?: import("./types.js").TaskReviewState | null; workflowStepResults?: import("./types.js").WorkflowStepResult[] | null; mergeDetails?: import("./types.js").MergeDetails | null; sourceIssue?: import("./types.js").TaskSourceIssue | null; sourceMetadataPatch?: Record<string, unknown> | null; githubTracking?: import("./types.js").TaskGithubTracking | null; gitlabTracking?: (Omit<import("./types.js").TaskGitLabTracking, "item"> & { item?: import("./types.js").TaskGitLabTrackedItem | null }) | null; tokenUsage?: import("./types.js").TaskTokenUsage | null; modifiedFiles?: string[] | null; workflowTransitionNotification?: import("./types.js").Task["workflowTransitionNotification"] | null; missionId?: string | null; sliceId?: string | null },
     runContext?: RunMutationContext,
   ): Promise<Task> {
     return this.withTaskLock(id, () => this.updateTaskUnlocked(id, updates, runContext));
@@ -9243,6 +9252,11 @@ ${TASK_UPSERT_SQL_ASSIGNMENTS}
       } else if (updates.awaitingApprovalReason !== undefined) {
         task.awaitingApprovalReason = updates.awaitingApprovalReason as import("./types.js").Task["awaitingApprovalReason"];
       }
+      if (updates.approvedPlanFingerprint === null) {
+        task.approvedPlanFingerprint = undefined;
+      } else if (updates.approvedPlanFingerprint !== undefined) {
+        task.approvedPlanFingerprint = updates.approvedPlanFingerprint;
+      }
       if (updates.error === null) {
         task.error = undefined;
       } else if (updates.error !== undefined) {
diff --git a/packages/core/src/types.ts b/packages/core/src/types.ts
index 2b5a47a26f..a783a8cf13 100644
--- a/packages/core/src/types.ts
+++ b/packages/core/src/types.ts
@@ -2485,6 +2485,19 @@ export interface Task {
    * no hold or an ordinary manual-approval hold.
    */
   awaitingApprovalReason?: "release-authorization";
+  /*
+   * FNXC:PlanApproval 2026-07-04-22:41:
+   * FN-7569 — records the computePlanApprovalFingerprint (packages/core/src/plan-approval.ts)
+   * hash of the exact PROMPT.md content an operator last approved via POST /tasks/:id/approve-plan.
+   * The manual plan-approval gate (packages/engine/src/triage.ts finalizeApprovedTask) compares this
+   * against the freshly written PROMPT.md on every re-specification (replan, plan-review retry,
+   * self-healing rebound to triage) and skips re-parking at "awaiting-approval" when they match, so an
+   * unchanged, already-approved plan is never re-asked. A genuine spec change produces a different
+   * fingerprint and still re-asks. POST /tasks/:id/reject-plan clears this field (null) alongside
+   * deleting PROMPT.md so the regenerated plan is treated as new. Stores only a hash, never plan text.
+   * Additive-only, nullable: legacy/never-approved rows stay NULL and behave exactly as before.
+   */
+  approvedPlanFingerprint?: string;
   /** Thinking level for AI agent sessions — controls reasoning effort (off/minimal/low/medium/high) */
   thinkingLevel?: ThinkingLevel;
   /** Execution mode for task implementation.
diff --git a/packages/dashboard/src/__tests__/routes-github.test.ts b/packages/dashboard/src/__tests__/routes-github.test.ts
index d5ce7afe51..a01ae12258 100644
--- a/packages/dashboard/src/__tests__/routes-github.test.ts
+++ b/packages/dashboard/src/__tests__/routes-github.test.ts
@@ -2085,6 +2085,46 @@ describe("POST /tasks/:id/approve-plan", () => {
     expect(res.status).toBe(200);
     expect(store.moveTask).toHaveBeenCalledWith("FN-001", "todo");
   });
+
+  /*
+   * FNXC:PlanApproval 2026-07-04-22:41:
+   * FN-7569 — approve-plan must persist an approvedPlanFingerprint hash of the current
+   * on-disk PROMPT.md so a later re-specification of the SAME plan can skip re-asking.
+   */
+  it("records an approvedPlanFingerprint hash of the on-disk PROMPT.md", async () => {
+    const root = mkdtempSync(join(tmpdir(), "kb-dashboard-approve-plan-"));
+    try {
+      mkdirSync(join(root, ".fusion", "tasks", "FN-001"), { recursive: true });
+      writeFileSync(join(root, ".fusion", "tasks", "FN-001", "PROMPT.md"), "# Task: FN-001\n\nApproved plan body.\n");
+
+      const localStore = createMockStore({
+        getTask: vi.fn(),
+        moveTask: vi.fn(),
+        updateTask: vi.fn(),
+        logEntry: vi.fn().mockResolvedValue(undefined),
+        getRootDir: vi.fn().mockReturnValue(root),
+      });
+      const awaitingTask = { ...FAKE_TASK_DETAIL, column: "triage" as const, status: "awaiting-approval" as const };
+      const movedTask = { ...FAKE_TASK_DETAIL, column: "todo" as const };
+      (localStore.getTask as ReturnType<typeof vi.fn>).mockResolvedValue(awaitingTask);
+      (localStore.moveTask as ReturnType<typeof vi.fn>).mockResolvedValue(movedTask);
+      (localStore.updateTask as ReturnType<typeof vi.fn>).mockResolvedValue({ ...movedTask, status: undefined });
+
+      const app = express();
+      app.use(express.json());
+      app.use("/api", createApiRoutes(localStore));
+
+      const res = await REQUEST(app, "POST", "/api/tasks/KB-001/approve-plan");
+
+      expect(res.status).toBe(200);
+      expect(localStore.updateTask).toHaveBeenCalledWith(
+        "FN-001",
+        expect.objectContaining({ status: undefined, approvedPlanFingerprint: expect.stringMatching(/^[0-9a-f]{64}$/) }),
+      );
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
 });
 
 describe("POST /tasks/:id/reject-plan", () => {
@@ -2117,7 +2157,9 @@ describe("POST /tasks/:id/reject-plan", () => {
 
     expect(res.status).toBe(200);
     expect(store.logEntry).toHaveBeenCalledWith("FN-001", "Plan rejected by user", "Specification will be regenerated");
-    expect(store.updateTask).toHaveBeenCalledWith("FN-001", { status: undefined });
+    // FN-7569: reject-plan clears any previously-recorded approval fingerprint so a
+    // regenerated plan is always treated as new and requires fresh manual approval.
+    expect(store.updateTask).toHaveBeenCalledWith("FN-001", { status: undefined, approvedPlanFingerprint: null });
     expect(res.body.column).toBe("triage");
   });
 
@@ -2199,7 +2241,30 @@ describe("POST /tasks/:id/reject-plan", () => {
     const res = await REQUEST(buildApp(), "POST", "/api/tasks/KB-001/reject-plan");
 
     expect(res.status).toBe(200);
-    expect(store.updateTask).toHaveBeenCalledWith("FN-001", { status: undefined });
+    expect(store.updateTask).toHaveBeenCalledWith("FN-001", { status: undefined, approvedPlanFingerprint: null });
+  });
+
+  /*
+   * FNXC:PlanApproval 2026-07-04-22:41:
+   * FN-7569 — reject-plan must clear a previously-recorded approval fingerprint
+   * regardless of its prior value, so a regenerated plan never inherits it.
+   */
+  it("clears an existing approvedPlanFingerprint on reject", async () => {
+    const awaitingTask = {
+      ...FAKE_TASK_DETAIL,
+      column: "triage" as const,
+      status: "awaiting-approval" as const,
+      approvedPlanFingerprint: "deadbeef",
+    };
+    const updatedTask = { ...FAKE_TASK_DETAIL, column: "triage" as const, status: undefined, approvedPlanFingerprint: undefined };
+
+    (store.getTask as ReturnType<typeof vi.fn>).mockResolvedValue(awaitingTask);
+    (store.updateTask as ReturnType<typeof vi.fn>).mockResolvedValue(updatedTask);
+
+    const res = await REQUEST(buildApp(), "POST", "/api/tasks/KB-001/reject-plan");
+
+    expect(res.status).toBe(200);
+    expect(store.updateTask).toHaveBeenCalledWith("FN-001", { status: undefined, approvedPlanFingerprint: null });
   });
 });
 
diff --git a/packages/dashboard/src/routes/register-task-workflow-routes.ts b/packages/dashboard/src/routes/register-task-workflow-routes.ts
index 31909c31c4..fd3d724078 100644
--- a/packages/dashboard/src/routes/register-task-workflow-routes.ts
+++ b/packages/dashboard/src/routes/register-task-workflow-routes.ts
@@ -60,7 +60,7 @@ import {
 } from "@fusion/engine";
 import { buildBoardWorkflowsPayload } from "./board-workflows.js";
 import { isBackwardMoveBlockedByOpenPr, PR_OPEN_BLOCKS_MOVE_BACK_MESSAGE } from "./register-pull-requests-routes.js";
-import { isWorkspaceTask, type RunAuditEventInput } from "@fusion/core";
+import { computePlanApprovalFingerprint, isWorkspaceTask, type RunAuditEventInput } from "@fusion/core";
 import { ApiError, badRequest, conflict, notFound } from "../api-error.js";
 import type { ApiRoutesContext } from "./types.js";
 import { deriveAutoTaskBranch, derivePerTaskBranch, getBranchSelectionMode, resolveBranchSelection } from "./branch-selection.js";
@@ -2754,11 +2754,34 @@ export function registerTaskWorkflowRoutes(ctx: ApiRoutesContext, deps: TaskWork
       // Log the approval
       await scopedStore.logEntry(task.id, "Plan approved by user");
 
+      /*
+       * FNXC:PlanApproval 2026-07-04-22:41:
+       * FN-7569 — persist a fingerprint of the exact PROMPT.md the operator just approved
+       * so a later re-specification (replan, plan-review retry, self-healing rebound) that
+       * produces the identical plan can skip re-parking at awaiting-approval. Read the
+       * on-disk PROMPT.md directly (best-effort) since the task row does not always carry
+       * full prompt text; a missing/unreadable file leaves the fingerprint unset and the
+       * manual gate falls back to today's always-re-park behavior for this task.
+       */
+      let approvedPlanFingerprint: string | undefined;
+      try {
+        const { readFile } = await import("node:fs/promises");
+        const { join } = await import("node:path");
+        const promptPath = join(scopedStore.getRootDir(), ".fusion", "tasks", task.id, "PROMPT.md");
+        const promptText = await readFile(promptPath, "utf8");
+        approvedPlanFingerprint = computePlanApprovalFingerprint(promptText);
+      } catch {
+        // No PROMPT.md to fingerprint (unusual for an awaiting-approval task) — leave unset.
+      }
+
       // Move to todo and clear status
       const updated = await scopedStore.moveTask(task.id, "todo");
-      await scopedStore.updateTask(task.id, { status: undefined });
+      await scopedStore.updateTask(task.id, {
+        status: undefined,
+        ...(approvedPlanFingerprint ? { approvedPlanFingerprint } : {}),
+      });
 
-      res.json({ ...updated, status: undefined });
+      res.json({ ...updated, status: undefined, ...(approvedPlanFingerprint ? { approvedPlanFingerprint } : {}) });
     } catch (err: unknown) {
       if (err instanceof ApiError) {
         throw err;
@@ -2797,7 +2820,13 @@ export function registerTaskWorkflowRoutes(ctx: ApiRoutesContext, deps: TaskWork
       await scopedStore.logEntry(task.id, "Plan rejected by user", "Specification will be regenerated");
 
       // Clear status to return to normal triage state
-      await scopedStore.updateTask(task.id, { status: undefined });
+      /*
+       * FNXC:PlanApproval 2026-07-04-22:41:
+       * FN-7569 — clear any previously-recorded approval fingerprint alongside the status
+       * clear and PROMPT.md removal, so the regenerated plan is always treated as new and
+       * requires fresh manual approval (it must never inherit the rejected plan's fingerprint).
+       */
+      await scopedStore.updateTask(task.id, { status: undefined, approvedPlanFingerprint: null });
 
       // Remove PROMPT.md to force regeneration
       const { rm } = await import("node:fs/promises");
diff --git a/packages/engine/src/__tests__/triage.test.ts b/packages/engine/src/__tests__/triage.test.ts
index f9e74208c7..e497d912b1 100644
--- a/packages/engine/src/__tests__/triage.test.ts
+++ b/packages/engine/src/__tests__/triage.test.ts
@@ -1,6 +1,6 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
 import type { TaskStore, Task, TaskDetail, Settings } from "@fusion/core";
-import { builtinSeamPrompt, MAX_TASK_LIST_TEXT_CHARS, renderTriagePolicyPlaceholders, resolveAgentPrompt } from "@fusion/core";
+import { builtinSeamPrompt, computePlanApprovalFingerprint, MAX_TASK_LIST_TEXT_CHARS, renderTriagePolicyPlaceholders, resolveAgentPrompt } from "@fusion/core";
 import {
   TriageProcessor,
   buildSpecificationPrompt,
@@ -2734,6 +2734,182 @@ describe("requirePlanApproval setting", () => {
     expect(manualUpdateCall?.[1]).toMatchObject({ awaitingApprovalReason: null });
   });
 
+  /*
+   * FNXC:PlanApproval 2026-07-04-22:41:
+   * FN-7569 — symptom repro + fix: manual plan approval must be idempotent against
+   * unchanged plan content. An operator approves a plan (approvedPlanFingerprint gets
+   * persisted on the task, mirroring POST /tasks/:id/approve-plan), then the SAME task
+   * re-enters finalizeApprovedTask (replan / plan-review retry / self-healing rebound)
+   * with byte-identical PROMPT.md. Today's code (pre-fix) would re-park at
+   * awaiting-approval a second time; the fix must move straight to todo instead.
+   */
+  describe("FN-7569: plan approval fingerprint idempotency", () => {
+    const planText = "# Task: FN-IDEMPOTENT - Idempotent plan\n\n## Mission\n\nDo the thing.\n\n## File Scope\n\n- a.ts\n";
+    const changedPlanText = "# Task: FN-IDEMPOTENT - Idempotent plan\n\n## Mission\n\nDo the thing, differently.\n\n## File Scope\n\n- a.ts\n- b.ts\n";
+
+    it("re-specifying the SAME approved plan skips the manual gate and moves straight to todo", async () => {
+      const fingerprint = computePlanApprovalFingerprint(planText);
+      const task = createTriageTask({
+        id: "FN-IDEMPOTENT",
+        status: "planning",
+        approvedPlanFingerprint: fingerprint,
+      } as Partial<Task>);
+      const store = createMockStore({
+        getTask: vi.fn().mockResolvedValue(task),
+      } as Partial<TaskStore>);
+      const processor = new TriageProcessor(store, rootDir);
+
+      await (processor as unknown as {
+        finalizeApprovedTask(task: Task, writtenInput: string, settings: Settings): Promise<void>;
+      }).finalizeApprovedTask(
+        task,
+        planText,
+        { requirePlanApproval: true, planApprovalMode: "require-all" } as Settings,
+      );
+
+      expect(store.moveTask).toHaveBeenCalledWith("FN-IDEMPOTENT", "todo");
+      expect(store.updateTask).not.toHaveBeenCalledWith("FN-IDEMPOTENT", expect.objectContaining({ status: "awaiting-approval" }));
+      expect(store.logEntry).toHaveBeenCalledWith(
+        "FN-IDEMPOTENT",
+        "Plan unchanged since prior approval — proceeding without re-approval",
+      );
+    });
+
+    it("re-specifying a CHANGED plan after prior approval still re-asks for approval", async () => {
+      const fingerprint = computePlanApprovalFingerprint(planText);
+      const task = createTriageTask({
+        id: "FN-IDEMPOTENT-CHANGED",
+        status: "planning",
+        approvedPlanFingerprint: fingerprint,
+      } as Partial<Task>);
+      const store = createMockStore({
+        getTask: vi.fn().mockResolvedValue(task),
+      } as Partial<TaskStore>);
+      const processor = new TriageProcessor(store, rootDir);
+
+      await (processor as unknown as {
+        finalizeApprovedTask(task: Task, writtenInput: string, settings: Settings): Promise<void>;
+      }).finalizeApprovedTask(
+        task,
+        changedPlanText,
+        { requirePlanApproval: true, planApprovalMode: "require-all" } as Settings,
+      );
+
+      expect(store.updateTask).toHaveBeenCalledWith("FN-IDEMPOTENT-CHANGED", expect.objectContaining({ status: "awaiting-approval", awaitingApprovalReason: null }));
+      expect(store.moveTask).not.toHaveBeenCalled();
+    });
+
+    it("never-approved task (no fingerprint) still parks at awaiting-approval on first specify", async () => {
+      const task = createTriageTask({
+        id: "FN-NEVER-APPROVED",
+        status: "planning",
+      } as Partial<Task>);
+      const store = createMockStore({
+        getTask: vi.fn().mockResolvedValue(task),
+      } as Partial<TaskStore>);
+      const processor = new TriageProcessor(store, rootDir);
+
+      await (processor as unknown as {
+        finalizeApprovedTask(task: Task, writtenInput: string, settings: Settings): Promise<void>;
+      }).finalizeApprovedTask(
+        task,
+        planText,
+        { requirePlanApproval: true, planApprovalMode: "require-all" } as Settings,
+      );
+
+      expect(store.updateTask).toHaveBeenCalledWith("FN-NEVER-APPROVED", expect.objectContaining({ status: "awaiting-approval" }));
+      expect(store.moveTask).not.toHaveBeenCalled();
+    });
+
+    it("rejected plan (fingerprint cleared to undefined) re-asks even though the same content was approved before", async () => {
+      const task = createTriageTask({
+        id: "FN-REJECTED-THEN-RESPECIFIED",
+        status: "planning",
+        approvedPlanFingerprint: undefined,
+      } as Partial<Task>);
+      const store = createMockStore({
+        getTask: vi.fn().mockResolvedValue(task),
+      } as Partial<TaskStore>);
+      const processor = new TriageProcessor(store, rootDir);
+
+      await (processor as unknown as {
+        finalizeApprovedTask(task: Task, writtenInput: string, settings: Settings): Promise<void>;
+      }).finalizeApprovedTask(
+        task,
+        planText,
+        { requirePlanApproval: true, planApprovalMode: "require-all" } as Settings,
+      );
+
+      expect(store.updateTask).toHaveBeenCalledWith("FN-REJECTED-THEN-RESPECIFIED", expect.objectContaining({ status: "awaiting-approval" }));
+      expect(store.moveTask).not.toHaveBeenCalled();
+    });
+
+    it("auto-approve-all moves to todo regardless of fingerprint state (manual gate never reached)", async () => {
+      const task = createTriageTask({
+        id: "FN-AUTO-APPROVE-FINGERPRINT",
+        status: "planning",
+        approvedPlanFingerprint: computePlanApprovalFingerprint(changedPlanText),
+      } as Partial<Task>);
+      const store = createMockStore({
+        getTask: vi.fn().mockResolvedValue(task),
+      } as Partial<TaskStore>);
+      const processor = new TriageProcessor(store, rootDir);
+
+      await (processor as unknown as {
+        finalizeApprovedTask(task: Task, writtenInput: string, settings: Settings): Promise<void>;
+      }).finalizeApprovedTask(
+        task,
+        planText,
+        { requirePlanApproval: true, planApprovalMode: "auto-approve-all" } as Settings,
+      );
+
+      expect(store.moveTask).toHaveBeenCalledWith("FN-AUTO-APPROVE-FINGERPRINT", "todo");
+      expect(store.updateTask).not.toHaveBeenCalledWith("FN-AUTO-APPROVE-FINGERPRINT", expect.objectContaining({ status: "awaiting-approval" }));
+    });
+
+    /*
+     * FN-7569: exercise the recoverApprovedTask caller (planning-recovery self-heal),
+     * not just finalizeApprovedTask directly, so the fingerprint short-circuit is
+     * proven to reach every finalizeApprovedTask caller, not just a direct-call seam.
+     */
+    it("recoverApprovedTask (self-healing planning recovery) skips re-park for an unchanged already-approved plan", async () => {
+      const fingerprint = computePlanApprovalFingerprint(planText);
+      await mkdir(join(rootDir, ".fusion", "tasks", "FN-RECOVER-IDEMPOTENT"), { recursive: true });
+      await writeFile(join(rootDir, ".fusion", "tasks", "FN-RECOVER-IDEMPOTENT", "PROMPT.md"), planText);
+      const store = createMockStore({
+        getSettings: vi.fn().mockResolvedValue({
+          maxConcurrent: 2,
+          maxWorktrees: 4,
+          pollIntervalMs: 10000,
+          groupOverlappingFiles: false,
+          autoMerge: true,
+          requirePlanApproval: true,
+        } as Settings),
+      });
+      const processor = new TriageProcessor(store, rootDir);
+
+      const recovered = await processor.recoverApprovedTask({
+        id: "FN-RECOVER-IDEMPOTENT",
+        description: "Recovered triage task",
+        column: "triage",
+        status: "planning",
+        approvedPlanFingerprint: fingerprint,
+        dependencies: [],
+        steps: [],
+        currentStep: 0,
+        log: [
+          { timestamp: "2026-01-01T00:00:00.000Z", action: "Spec review: APPROVE" },
+        ],
+        createdAt: "2026-01-01T00:00:00.000Z",
+        updatedAt: "2026-01-01T00:02:00.000Z",
+      });
+
+      expect(recovered).toBe(true);
+      expect(store.moveTask).toHaveBeenCalledWith("FN-RECOVER-IDEMPOTENT", "todo");
+      expect(store.updateTask).not.toHaveBeenCalledWith("FN-RECOVER-IDEMPOTENT", expect.objectContaining({ status: "awaiting-approval" }));
+    });
+  });
+
   /*
    * FNXC:PlanApproval 2026-07-04-12:30:
    * FN-7526 — auto-approve-all must NOT bypass Workflow Plan Review. A REVISE
diff --git a/packages/engine/src/triage.ts b/packages/engine/src/triage.ts
index 99ebc5b8c0..416d7a4bc1 100644
--- a/packages/engine/src/triage.ts
+++ b/packages/engine/src/triage.ts
@@ -28,6 +28,7 @@ import {
   compareTaskIdNumeric,
   resolveAgentMemoryInclusionMode,
   resolvePlanApprovalRequired,
+  computePlanApprovalFingerprint,
   extractIntentSignature,
   findNearDuplicates,
   isNearDuplicateCanonicalInactive,
@@ -2574,24 +2575,49 @@ export class TriageProcessor {
     */
     if (resolvePlanApprovalRequired(settings)) {
       /*
-       * FNXC:PlanApproval 2026-07-04-21:35:
-       * FN-7559: explicitly clear awaitingApprovalReason on the manual gate's own
-       * awaiting-approval write so a stale "release-authorization" reason left over
-       * from an earlier pass on this same task (e.g. a replan after the release
-       * gate parked it, now passing the release gate but still requiring manual
-       * approval) never survives into this genuinely-manual hold.
+       * FNXC:PlanApproval 2026-07-04-22:41:
+       * FN-7569 — idempotency short-circuit. Compare the freshly written PROMPT.md against
+       * the fingerprint recorded when the operator last approved a plan for this task
+       * (POST /tasks/:id/approve-plan, packages/core/src/plan-approval.ts). If they match,
+       * this is a re-specification of an already-approved, unchanged plan (replan,
+       * plan-review reviewer-outage retry, self-healing rebound to triage, duplicate-marker
+       * retry) and must proceed straight through like an approved task rather than re-parking
+       * at awaiting-approval and asking the operator to re-approve. A genuinely changed plan
+       * (or one whose approval was cleared by reject-plan) produces a different/absent
+       * fingerprint and falls through to the ordinary park below. This check lives strictly
+       * inside the manual-gate branch, after release authorization and Plan Review have
+       * already made their independent decisions, so it never weakens either of those gates
+       * or auto-approve-all (which never reaches this branch at all).
        */
-      const approvalUpdates: Record<string, unknown> = { status: "awaiting-approval", awaitingApprovalReason: null };
-      if (shouldApplyPromptDeclaredTitle && promptDeclaredTitle) {
-        approvalUpdates.title = promptDeclaredTitle;
+      const priorFingerprint = latestTransitionTask?.approvedPlanFingerprint ?? task.approvedPlanFingerprint;
+      const currentFingerprint = computePlanApprovalFingerprint(written);
+      if (priorFingerprint && priorFingerprint === currentFingerprint) {
+        await this.store.logEntry(
+          task.id,
+          "Plan unchanged since prior approval — proceeding without re-approval",
+        );
+        planLog.log(`${task.id} plan unchanged since prior approval — proceeding without re-approval`);
+      } else {
+        /*
+         * FNXC:PlanApproval 2026-07-04-21:35:
+         * FN-7559: explicitly clear awaitingApprovalReason on the manual gate's own
+         * awaiting-approval write so a stale "release-authorization" reason left over
+         * from an earlier pass on this same task (e.g. a replan after the release
+         * gate parked it, now passing the release gate but still requiring manual
+         * approval) never survives into this genuinely-manual hold.
+         */
+        const approvalUpdates: Record<string, unknown> = { status: "awaiting-approval", awaitingApprovalReason: null };
+        if (shouldApplyPromptDeclaredTitle && promptDeclaredTitle) {
+          approvalUpdates.title = promptDeclaredTitle;
+        }
+        await this.store.updateTask(task.id, approvalUpdates);
+        await this.store.logEntry(
+          task.id,
+          options.recoveryLogAction ?? "Specification approved by AI — awaiting manual approval",
+        );
+        planLog.log(`✓ ${task.id} specified and awaiting manual approval`);
+        return;
       }
-      await this.store.updateTask(task.id, approvalUpdates);
-      await this.store.logEntry(
-        task.id,
-        options.recoveryLogAction ?? "Specification approved by AI — awaiting manual approval",
-      );
-      planLog.log(`✓ ${task.id} specified and awaiting manual approval`);
-      return;
     }
 
     if (shouldClearWorkflowRunStepInstances) {

From 7c0be5311a12041ff421f150fb5e7acb060f3db5 Mon Sep 17 00:00:00 2001
From: gsxdsm <gsxdsm@users.noreply.github.com>
Date: Sat, 4 Jul 2026 23:33:03 -0700
Subject: [PATCH 17/65] FN-7567: re-bake xterm letter-spacing after fit() to
 fix mobile terminal spacing recurrence

Fixes recurrence #4 of the mobile terminal excess character-spacing bug: SessionTerminal and TerminalModal now force a second genuine xterm font remeasure AFTER fitAddon.fit() settles the post-fit column count, since handleResize() never re-bakes DomRenderer's letter-spacing compensation itself.

- SessionTerminal.tsx: call forceTerminalFontRemeasure() again after fit()/sendResizeMessage() in the resize handler, re-baking spacing against the settled (post-fit) column count instead of the stale pre-fit one.
- TerminalModal.tsx: same second forceTerminalFontRemeasure() call after fitAddon.fit()/sendResize() in its resize handling path.
- Expanded SessionTerminal.test.tsx and TerminalModal.test.tsx coverage to assert the post-fit remeasure occurs.
- Added docs/solutions/ui-bugs/xterm-options-noop-remeasure-after-font-settle.md documenting recurrence #4 root cause (DomRenderer._setDefaultSpacing() never recomputes from handleResize()).
- Added changeset fn-7567-mobile-terminal-spacing.md (patch, category fix).

Files changed:
 .changeset/fn-7567-mobile-terminal-spacing.md      |   7 +
 docs/solutions/ui-bugs/xterm-options-noop-remeasure-after-font-settle.md |  89 ++++++
 packages/dashboard/app/components/SessionTerminal.tsx   |  23 ++
 packages/dashboard/app/components/TerminalModal.tsx     |  43 ++-
 packages/dashboard/app/components/__tests__/SessionTerminal.test.tsx  | 127 +++++++-
 packages/dashboard/app/components/__tests__/TerminalModal.test.tsx    | 334 ++++++++++++++++++++-
 6 files changed, 619 insertions(+), 4 deletions(-)

Fusion-Task-Id: FN-7567
Fusion-Task-Lineage: 5da20522-82d3-4c4d-9008-db71bc5b4d75
Co-authored-by: Fusion (runfusion.ai) <noreply@runfusion.ai>
---
 .changeset/fn-7567-mobile-terminal-spacing.md |   7 +
 ...ptions-noop-remeasure-after-font-settle.md |  89 +++++
 .../app/components/SessionTerminal.tsx        |  23 ++
 .../app/components/TerminalModal.tsx          |  43 ++-
 .../__tests__/SessionTerminal.test.tsx        | 127 ++++++-
 .../__tests__/TerminalModal.test.tsx          | 334 +++++++++++++++++-
 6 files changed, 619 insertions(+), 4 deletions(-)
 create mode 100644 .changeset/fn-7567-mobile-terminal-spacing.md

diff --git a/.changeset/fn-7567-mobile-terminal-spacing.md b/.changeset/fn-7567-mobile-terminal-spacing.md
new file mode 100644
index 0000000000..1462cca8e4
--- /dev/null
+++ b/.changeset/fn-7567-mobile-terminal-spacing.md
@@ -0,0 +1,7 @@
+---
+"@runfusion/fusion": patch
+---
+
+summary: Fix mobile terminal excess character spacing that survived earlier font-remeasure fixes.
+category: fix
+dev: `TerminalModal`/`SessionTerminal` re-bake xterm's `DomRenderer` letter-spacing compensation AFTER `fitAddon.fit()` settles the post-fit column count (not just before it), since `handleResize()` never re-bakes spacing itself. See `docs/solutions/ui-bugs/xterm-options-noop-remeasure-after-font-settle.md` recurrence #4.
diff --git a/docs/solutions/ui-bugs/xterm-options-noop-remeasure-after-font-settle.md b/docs/solutions/ui-bugs/xterm-options-noop-remeasure-after-font-settle.md
index dbf4337082..2ea9a036da 100644
--- a/docs/solutions/ui-bugs/xterm-options-noop-remeasure-after-font-settle.md
+++ b/docs/solutions/ui-bugs/xterm-options-noop-remeasure-after-font-settle.md
@@ -23,12 +23,15 @@ related_components:
   - FN-7456
   - FN-7460
   - FN-7561
+  - FN-7567
 tags:
   - xterm
   - font-loading
   - options-service
   - mobile-safari
   - remeasure
+  - letter-spacing
+  - domrenderer
 ---
 
 # xterm OptionsService no-op reassignment silently skips post-load remeasure
@@ -118,3 +121,89 @@ jsdom cannot exercise real xterm.js internals, so the regression coverage models
 - Cover both `TerminalModal` (mobile viewport, keyboard-open and keyboard-closed initial render) and `SessionTerminal` (embedded attach surface) — both surfaces independently reapply font options after settle and both had the bug.
 - Run: `pnpm --filter @fusion/dashboard exec vitest run app/components/__tests__/TerminalModal.test.tsx app/components/__tests__/SessionTerminal.test.tsx app/components/__tests__/SessionTerminal.mobile.test.tsx app/__tests__/terminal-input.test.ts app/utils/__tests__/terminalPreferences.test.ts --silent=passed-only --reporter=dot`.
 - Real mobile Safari/Chrome verification remains the strongest signal for this class of bug; if unavailable, record that as an explicit gap rather than treating desktop WebKit/jsdom as proof (see `docs/ios-acceptance.md`).
+
+## Recurrence #4 (FN-7567): forcing a genuine remeasure BEFORE `fit()` bakes stale spacing
+
+FN-7561's `forceTerminalFontRemeasure()` fix (above) is necessary but was not sufficient. On the real
+mobile device, ordinary ASCII (`test`, `ls`, filenames) still rendered with visible gaps on the
+initial paint even with the FN-7561 fix, FN-7460's `text-size-adjust: none`, and FN-7456's
+symbols-free font stack all present.
+
+### New root cause
+
+Real xterm's `DomRenderer._setDefaultSpacing()` — the letter-spacing compensation baked onto
+`.xterm-rows` as `spacing = dimensions.css.cell.width - widthCache.get('W')` — only recomputes from
+two call sites:
+
+- `handleCharSizeChanged()`, wired to `CharSizeService.onCharSizeChange`, which fires on any
+  **genuine** (distinct-value) `fontFamily`/`fontSize` option transition — exactly what
+  `forceTerminalFontRemeasure()` forces.
+- `handleDevicePixelRatioChange()`.
+
+It is **never** recomputed from `handleResize()` — the path `fitAddon.fit()` →
+`terminal.resize(cols, rows)` takes.
+
+Both mobile settle sites in `TerminalModal.tsx` and `SessionTerminal.tsx` (the initial post-font-load
+settle and the live-preferences-apply settle) called `forceTerminalFontRemeasure()` **before**
+`fitAddon.fit()`. That correctly forces a genuine option transition and does bake letter-spacing —
+but it bakes it against the column count that predates the fit. `fitAddon.fit()` then changes the
+column count (and therefore the true cell width) but never re-bakes the spacing, so the terminal keeps
+rendering with a spacing value computed against a column count that no longer matches reality. The
+gap persists until an unrelated later event (device-pixel-ratio change, orientation, reconnect)
+happens to force another genuine option/DPR-triggered remeasure — exactly matching the report that
+the terminal "only repairs itself after an incidental refit."
+
+### Why FN-7456/FN-7460/FN-7561 missed this
+
+All three prior fixes and their regressions asserted CSS-property presence (`text-size-adjust: none`,
+symbols-free `fontFamily`) or a remeasure **call count** (`fontRemeasureCount`), never the actual baked
+letter-spacing value relative to the **post-fit** column count. A test that only checks "a remeasure
+happened" cannot distinguish "remeasure happened but was baked against stale pre-fit geometry" from
+"remeasure happened and reflects final geometry."
+
+### Solution
+
+Force a **second** genuine remeasure **after** `fitAddon.fit()` settles the column count, so the
+letter-spacing bake is recomputed against the FINAL (post-fit) geometry, not the pre-fit one:
+
+```ts
+// packages/dashboard/app/components/TerminalModal.tsx (mirrored in SessionTerminal.tsx)
+forceTerminalFontRemeasure(terminal, resolvedFontFamilyRef.current);
+terminal.options.fontSize = fontSizeRef.current;
+fitAddon.fit();
+resizeRef.current?.(terminal.cols, terminal.rows);
+forceTerminalFontRemeasure(terminal, resolvedFontFamilyRef.current); // re-bake against final cols
+terminal.refresh(0, Math.max(0, terminal.rows - 1));
+```
+
+The `scheduleRefit(rebakeSpacingAfterFit)` path in `TerminalModal.tsx` only re-bakes on the *settled*
+(font-metrics-ready) call site, not on the immediate first frame — at that point the web font may not
+have loaded yet, so re-baking there would only bake against fallback-font metrics again.
+
+Do not:
+
+- Re-bake unconditionally on every frame/resize — only after a settle that already forced a genuine
+  remeasure and then fit.
+- Replace this with a hardcoded letter-spacing/cell-width compensation.
+
+### Regression coverage (geometry-based, not CSS/call-count)
+
+jsdom cannot exercise real xterm.js internals, so the FN-7567 regression models the real
+`CharSizeService`/`DomRenderer` contracts directly on the test double instead of a plain mock:
+
+- `mockHandleCharSizeChanged()` mirrors `CharSizeService.measure()` → `DomRenderer.handleCharSizeChanged()`
+  → `_setDefaultSpacing()`: recomputes `bakedLetterSpacingPx = cellWidthPx - measuredCharWidthPx` using
+  the **current** (possibly stale, pre-fit) column count, firing only on a genuine option transition.
+- `mockFitAddonFit()` mirrors `FitAddon.fit()` → `terminal.resize(cols, rows)` →
+  `DomRenderer.handleResize()`: recomputes `cols`/cell-width from the current measured char width but
+  deliberately does **not** touch the baked letter-spacing (matching real xterm).
+- The assertion is the actual rendered geometry invariant: baked letter-spacing must equal `0` (cell
+  width matches the settled glyph advance width) after the full settle+fit sequence — not merely that
+  `forceTerminalFontRemeasure`/`fontRemeasureCount` was called.
+- See `TerminalModal.test.tsx` describe block "FN-7567 mobile inter-character spacing (stale post-fit
+  letter-spacing bake)" and the mirrored `SessionTerminal.test.tsx` coverage.
+- Run: `pnpm --filter @fusion/dashboard exec vitest run app/components/__tests__/TerminalModal.test.tsx app/components/__tests__/SessionTerminal.test.tsx app/components/__tests__/SessionTerminal.mobile.test.tsx app/utils/__tests__/terminalPreferences.test.ts app/__tests__/terminal-input.test.ts --silent=passed-only --reporter=dot`.
+- Real mobile Safari/Chrome sanity check remains the strongest signal; a real-device screenshot was not
+  obtainable in this execution environment (headless coding agent, no physical device access) — this
+  gap is recorded explicitly rather than treating jsdom/desktop WebKit as proof. See task document
+  key="repro" on FN-7567 and `docs/ios-acceptance.md`.
diff --git a/packages/dashboard/app/components/SessionTerminal.tsx b/packages/dashboard/app/components/SessionTerminal.tsx
index 2acf5783c9..1b0d72cd2f 100644
--- a/packages/dashboard/app/components/SessionTerminal.tsx
+++ b/packages/dashboard/app/components/SessionTerminal.tsx
@@ -341,6 +341,15 @@ export function SessionTerminal({
         try {
           (fitAddonRef.current as { fit?: () => void } | null)?.fit?.();
           sendResizeMessage(terminal.cols, terminal.rows);
+          /*
+          FNXC:Terminal 2026-07-04-11:45:
+          FN-7567 recurrence #4: `_setDefaultSpacing()` only recomputes from a
+          genuine option-change remeasure or a devicePixelRatio change, never
+          from the `fit()`/resize above, so re-bake spacing once more here
+          against the settled (post-fit) column count instead of the stale
+          pre-fit one baked by the `forceTerminalFontRemeasure` call above.
+          */
+          forceTerminalFontRemeasure(terminal, resolvedFontFamily);
           terminal.refresh(0, Math.max(0, terminal.rows - 1));
         } catch {
           /* ignore teardown or transient measure failures */
@@ -507,11 +516,25 @@ export function SessionTerminal({
 
           FNXC:Terminal 2026-07-04-09:40:
           FN-7561 recurrence #3: reassigning fontFamily to the SAME already-resolved value is a no-op against real xterm's OptionsService (no onOptionChange fires), so CharSizeService/DomRenderer never remeasure the web font that only just finished loading after xterm's initial pre-load measurement. Force a genuine value transition via `forceTerminalFontRemeasure`.
+
+          FNXC:Terminal 2026-07-04-11:45:
+          FN-7567 recurrence #4: the remeasure above is necessary but not
+          sufficient. Real xterm's `DomRenderer._setDefaultSpacing()` (the
+          letter-spacing compensation baked onto `.xterm-rows`) only recomputes
+          from a genuine option-change remeasure (what `forceTerminalFontRemeasure`
+          triggers) or a devicePixelRatio change — NEVER from `handleResize()`,
+          which is what `fitAddon.fit()` -> `terminal.resize(cols, rows)`
+          triggers. Baking spacing BEFORE `fit()` bakes it against the stale
+          pre-fit column count; force a second genuine remeasure AFTER `fit()`
+          settles the column count so spacing is re-baked against the FINAL
+          geometry, not the pre-fit one. See
+          `docs/solutions/ui-bugs/xterm-options-noop-remeasure-after-font-settle.md`.
           */
           forceTerminalFontRemeasure(term, resolvedFontFamily);
           term.options.fontSize = terminalPreferences.fontSize;
           (fitAddon as unknown as { fit: () => void }).fit();
           sendResize(term.cols, term.rows);
+          forceTerminalFontRemeasure(term, resolvedFontFamily);
           term.refresh(0, Math.max(0, term.rows - 1));
         } catch {
           /* ignore teardown or transient measure failures */
diff --git a/packages/dashboard/app/components/TerminalModal.tsx b/packages/dashboard/app/components/TerminalModal.tsx
index e84ac9c5ad..39e4c78bf1 100644
--- a/packages/dashboard/app/components/TerminalModal.tsx
+++ b/packages/dashboard/app/components/TerminalModal.tsx
@@ -1254,11 +1254,32 @@ export function TerminalModal({ isOpen, onClose, initialCommand, initialCommandG
 
         FNXC:Terminal 2026-07-04-09:35:
         FN-7561 recurrence #3: reassigning `fontFamily` to the SAME already-resolved value (the common case, since preferences are unchanged) is a no-op against real xterm's OptionsService — no `onOptionChange` fires, so CharSizeService/DomRenderer never remeasure the web font that only just finished loading. Force a genuine value transition via `forceTerminalFontRemeasure` so the character/cell metrics and `_setDefaultSpacing()` letter-spacing compensation are recomputed against the settled font on every settle, not just when the preference itself changed.
+
+        FNXC:Terminal 2026-07-04-11:35:
+        FN-7567 recurrence #4: forcing the remeasure above is necessary but not
+        sufficient. Real xterm's `DomRenderer._setDefaultSpacing()` (the
+        letter-spacing compensation baked onto `.xterm-rows`, computed as
+        `dimensions.css.cell.width - widthCache.get('W')`) only recomputes from
+        `handleCharSizeChanged()` (wired to `CharSizeService.onCharSizeChange`,
+        i.e. exactly what `forceTerminalFontRemeasure` above triggers) and from
+        `handleDevicePixelRatioChange()` — NEVER from `handleResize()`, which is
+        what `fitAddon.fit()` -> `terminal.resize(cols, rows)` triggers. Calling
+        `forceTerminalFontRemeasure` BEFORE `fitAddon.fit()` bakes spacing
+        against the column count that predates the fit, so once fit() changes
+        the column count (and therefore the true cell width) the baked spacing
+        goes stale and stays wrong until an unrelated later event (DPR change,
+        orientation) coincidentally forces another genuine option/DPR-change
+        remeasure — exactly the reported "only repairs itself after an
+        incidental refit" symptom. Force a SECOND genuine remeasure AFTER
+        `fitAddon.fit()` settles the column count so the letter-spacing bake is
+        recomputed against the FINAL geometry, not the pre-fit one. See
+        `docs/solutions/ui-bugs/xterm-options-noop-remeasure-after-font-settle.md`.
         */
         forceTerminalFontRemeasure(terminal, resolvedFontFamilyRef.current);
         terminal.options.fontSize = fontSizeRef.current;
         fitAddon.fit();
         resizeRef.current?.(terminal.cols, terminal.rows);
+        forceTerminalFontRemeasure(terminal, resolvedFontFamilyRef.current);
         terminal.refresh(0, Math.max(0, terminal.rows - 1));
       } catch {
         // Ignore fit/refresh errors during teardown or viewport transitions.
@@ -1757,7 +1778,22 @@ export function TerminalModal({ isOpen, onClose, initialCommand, initialCommandG
     // Defer fit until the next frame so layout reflects the new font metrics
     // before FitAddon measures rows/cols. Reuse pendingFitRef so font changes and
     // visualViewport-triggered fits are coalesced into a single scheduled fit.
-    const scheduleRefit = () => {
+    /*
+    FNXC:Terminal 2026-07-04-11:40:
+    FN-7567 recurrence #4: `rebakeSpacingAfterFit` is set only by the settled
+    (font-metrics-ready) call site below. Real xterm's `DomRenderer._setDefaultSpacing()`
+    letter-spacing bake only recomputes from a genuine option-change remeasure,
+    never from `handleResize()` (what `fitAddon.fit()` triggers), so a settle
+    that calls `forceTerminalFontRemeasure()` and THEN fits must force one more
+    genuine remeasure AFTER the fit to re-bake spacing against the FINAL
+    (post-fit) column count — otherwise the bake stays computed against the
+    stale pre-fit column count until an unrelated later event happens to force
+    another remeasure. The unsettled immediate frame intentionally does not
+    rebake: at that point the web font has not necessarily loaded yet, so
+    forcing another remeasure there would just re-bake against the same
+    (possibly still-fallback) metrics.
+    */
+    const scheduleRefit = (rebakeSpacingAfterFit = false) => {
       if (pendingFitRef.current !== null) {
         cancelAnimationFrame(pendingFitRef.current);
         pendingFitRef.current = null;
@@ -1770,6 +1806,9 @@ export function TerminalModal({ isOpen, onClose, initialCommand, initialCommandG
         }
         refitTerminal();
         xtermRef.current?.refresh?.(0, Math.max(0, xtermRef.current.rows - 1));
+        if (rebakeSpacingAfterFit && xtermRef.current) {
+          forceTerminalFontRemeasure(xtermRef.current, resolvedFontFamily);
+        }
       });
       pendingFitRef.current = frame;
       return frame;
@@ -1797,7 +1836,7 @@ export function TerminalModal({ isOpen, onClose, initialCommand, initialCommandG
         }
         forceTerminalFontRemeasure(xtermRef.current, resolvedFontFamily);
         xtermRef.current.options.fontSize = terminalPreferences.fontSize;
-        scheduleRefit();
+        scheduleRefit(true);
       },
       () => {
         // FontFaceSet failures are non-fatal; the immediate frame above still
diff --git a/packages/dashboard/app/components/__tests__/SessionTerminal.test.tsx b/packages/dashboard/app/components/__tests__/SessionTerminal.test.tsx
index 616330e24e..e038937403 100644
--- a/packages/dashboard/app/components/__tests__/SessionTerminal.test.tsx
+++ b/packages/dashboard/app/components/__tests__/SessionTerminal.test.tsx
@@ -2,7 +2,64 @@ import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
 import { act, render, screen, fireEvent, waitFor } from "@testing-library/react";
 
 // ── Mock xterm + addon dynamic imports (jsdom has no canvas/WebGL) ──────────
-const mockFitAddon = { fit: vi.fn() };
+/*
+FNXC:Terminal 2026-07-04-11:50:
+FN-7567 recurrence #4: forcing a genuine fontFamily/fontSize transition
+(FN-7561's `forceTerminalFontRemeasure`) is necessary but not sufficient. Real
+xterm's `DomRenderer._setDefaultSpacing()` (the letter-spacing compensation
+baked onto `.xterm-rows`) is recomputed on `CharSizeService.onCharSizeChange`
+(any genuine option change) and on `handleDevicePixelRatioChange`, but NOT on
+`handleResize()` (the path `fitAddon.fit()` -> `terminal.resize(cols, rows)`
+takes). `mockFitAddon.fit`/`mockTerm.cols` model this ordering-sensitive
+geometry (measured char width, cell width derived from cols, and the baked
+letter-spacing) directly, mirroring xterm's real internals, so the regression
+asserts actual rendered geometry instead of a CSS-property or call-count check.
+*/
+const MOCK_CONTAINER_WIDTH_PX = 728;
+const MOCK_FALLBACK_CHAR_WIDTH_PX = 9;
+const MOCK_SETTLED_CHAR_WIDTH_PX = 7;
+let mockFontsSettledForCharSize = false;
+let mockMeasuredCharWidthPx = MOCK_FALLBACK_CHAR_WIDTH_PX;
+let mockBakedLetterSpacingPx = 0;
+
+function resetMockTerminalGeometry(): void {
+  mockFontsSettledForCharSize = false;
+  mockMeasuredCharWidthPx = MOCK_FALLBACK_CHAR_WIDTH_PX;
+  mockBakedLetterSpacingPx = 0;
+  mockTerm.cols = 80;
+}
+
+/** Mirrors the real web font finishing its network load/paint settle. */
+function settleMockTerminalFontForCharSize(): void {
+  mockFontsSettledForCharSize = true;
+}
+
+/** The rendered cell/advance-width geometry invariant under test: 0 == tight contiguous monospace. */
+function getMockBakedLetterSpacingPx(): number {
+  return mockBakedLetterSpacingPx;
+}
+
+// Mirrors xterm's CharSizeService.measure() -> onCharSizeChange ->
+// DomRenderer.handleCharSizeChanged(): runs on every GENUINE fontFamily/fontSize
+// option transition, using the CURRENT (possibly stale, pre-fit) column count.
+function mockHandleCharSizeChanged(): void {
+  mockMeasuredCharWidthPx = mockFontsSettledForCharSize
+    ? MOCK_SETTLED_CHAR_WIDTH_PX
+    : MOCK_FALLBACK_CHAR_WIDTH_PX;
+  const cols = (mockTerm.cols as number) || 1;
+  const cellWidthPx = MOCK_CONTAINER_WIDTH_PX / cols;
+  mockBakedLetterSpacingPx = cellWidthPx - mockMeasuredCharWidthPx;
+}
+
+// Mirrors FitAddon.fit() -> terminal.resize(cols, rows) ->
+// DomRenderer.handleResize(): recomputes cols from the CURRENT measured char
+// width but deliberately does NOT touch letter-spacing (real xterm's
+// handleResize() never calls _setDefaultSpacing()).
+const mockFitAddon = {
+  fit: vi.fn(() => {
+    mockTerm.cols = Math.max(1, Math.floor(MOCK_CONTAINER_WIDTH_PX / mockMeasuredCharWidthPx));
+  }),
+};
 let sessionKeyEventHandler: ((event: KeyboardEvent) => boolean) | null = null;
 
 /*
@@ -38,6 +95,7 @@ function wrapMockTerminalOptions(initial: Record<string, unknown>): Record<strin
           store[key] = value;
           if (key === "fontFamily" || key === "fontSize") {
             fontRemeasureCount += 1;
+            mockHandleCharSizeChanged();
           }
         }
       },
@@ -151,6 +209,7 @@ beforeEach(() => {
   mockTerm.dispose.mockClear();
   mockTerm.options = {};
   resetFontRemeasureCount();
+  resetMockTerminalGeometry();
   Object.defineProperty(document, "fonts", {
     value: undefined,
     configurable: true,
@@ -404,6 +463,7 @@ describe("SessionTerminal", () => {
     // touched terminal preferences), so this must be a forced remeasure, not
     // an incidental preference-driven one.
     resetFontRemeasureCount();
+    resetMockTerminalGeometry();
 
     await act(async () => {
       resolveLoad?.();
@@ -420,6 +480,71 @@ describe("SessionTerminal", () => {
     expect(mockTerm.options.fontFamily).toBe(resolveTerminalFontFamily("nerd-font"));
   });
 
+  /*
+  FNXC:Terminal 2026-07-04-11:55:
+  FN-7567 recurrence #4: forcing a genuine remeasure (the assertion above) is
+  necessary but not sufficient. Real xterm's `DomRenderer._setDefaultSpacing()`
+  letter-spacing bake only recomputes from a genuine option-change remeasure or
+  a devicePixelRatio change, never from the `fitAddon.fit()`/resize that
+  follows it, so a settle that bakes spacing BEFORE fit() leaves it stale
+  against the post-fit column count until an unrelated later event happens to
+  force another remeasure. This asserts the measured rendered geometry
+  invariant (baked letter-spacing == 0) using a xterm-internals-accurate model,
+  not a re-assertion of the FN-7561 call-count/CSS-property checks; it fails on
+  pre-fix code and passes once the settle re-bakes spacing AFTER fit().
+  */
+  it("renders contiguous monospace cells (zero baked letter-spacing) once the mobile web font settles after xterm's initial fit", async () => {
+    let resolveLoad: (() => void) | undefined;
+    let resolveReady: (() => void) | undefined;
+    Object.defineProperty(document, "fonts", {
+      value: {
+        load: vi.fn(
+          () =>
+            new Promise<void>((resolve) => {
+              resolveLoad = resolve;
+            }),
+        ),
+        ready: new Promise<void>((resolve) => {
+          resolveReady = resolve;
+        }),
+      },
+      configurable: true,
+    });
+
+    render(<SessionTerminal sessionId="s1" />);
+
+    await waitFor(() => {
+      expect(FakeWS.instances.length).toBe(1);
+    });
+    resetFontRemeasureCount();
+
+    // Simulate the real recurrence: the custom web font finishes downloading
+    // AFTER xterm's initial fallback-font measurement/fit already ran and
+    // baked a letter-spacing value that was internally consistent for the
+    // FALLBACK font at that (stale) column count.
+    settleMockTerminalFontForCharSize();
+
+    await act(async () => {
+      resolveLoad?.();
+      resolveReady?.();
+      await Promise.resolve();
+      await Promise.resolve();
+      await Promise.resolve();
+    });
+
+    await waitFor(() => {
+      expect(getFontRemeasureCount()).toBeGreaterThan(0);
+    });
+
+    // The measured geometry invariant: once font metrics settle and xterm
+    // refits to the correct column count for the SETTLED font, the baked
+    // letter-spacing compensation must be recomputed against that FINAL
+    // column count, not the stale pre-fit one.
+    await waitFor(() => {
+      expect(getMockBakedLetterSpacingPx()).toBeCloseTo(0, 5);
+    });
+  });
+
   it("applies validated terminal preferences at xterm init", async () => {
     const { Terminal } = await import("@xterm/xterm");
     window.localStorage.setItem(
diff --git a/packages/dashboard/app/components/__tests__/TerminalModal.test.tsx b/packages/dashboard/app/components/__tests__/TerminalModal.test.tsx
index 5153399c89..40d96c86ce 100644
--- a/packages/dashboard/app/components/__tests__/TerminalModal.test.tsx
+++ b/packages/dashboard/app/components/__tests__/TerminalModal.test.tsx
@@ -60,7 +60,73 @@ vi.mock("../../api", () => ({
 }));
 
 // Mock xterm modules to prevent DOM errors in jsdom
-const mockFitAddonFit = vi.fn();
+/*
+FNXC:Terminal 2026-07-04-11:05:
+FN-7567 recurrence #4: forcing a genuine fontFamily/fontSize transition
+(FN-7561's `forceTerminalFontRemeasure`) is necessary but not sufficient. Real
+xterm's `DomRenderer._setDefaultSpacing()` — the letter-spacing compensation
+baked onto `.xterm-rows` (`spacing = dimensions.css.cell.width -
+widthCache.get('W')`) — is recomputed on `CharSizeService.onCharSizeChange`
+(any genuine option change) and on `handleDevicePixelRatioChange`, but NOT on
+`handleResize()` (the path `fitAddon.fit()` -> `terminal.resize(cols, rows)`
+takes; see `@xterm/xterm` `src/browser/renderer/dom/DomRenderer.ts`). Both
+settle sites call `forceTerminalFontRemeasure()` (which bakes spacing against
+the column count that predates `fit()`) and only THEN call `fitAddon.fit()`
+(which changes cols/cell-width but never re-bakes spacing), leaving a stale,
+oversized letter-spacing baked in until an unrelated later event happens to
+force another genuine option/DPR change. `mockFitAddonFit`/`mockTerminalInstance.cols`
+model this ordering-sensitive geometry (measured char width, cell width
+derived from cols, and the baked letter-spacing) directly, mirroring xterm's
+real internals, so the regression asserts actual geometry instead of a
+CSS-property or call-count check.
+*/
+const MOCK_CONTAINER_WIDTH_PX = 728;
+const MOCK_FALLBACK_CHAR_WIDTH_PX = 9;
+const MOCK_SETTLED_CHAR_WIDTH_PX = 7;
+let mockFontsSettledForCharSize = false;
+let mockMeasuredCharWidthPx = MOCK_FALLBACK_CHAR_WIDTH_PX;
+let mockBakedLetterSpacingPx = 0;
+
+function resetMockTerminalGeometry(): void {
+  mockFontsSettledForCharSize = false;
+  mockMeasuredCharWidthPx = MOCK_FALLBACK_CHAR_WIDTH_PX;
+  mockBakedLetterSpacingPx = 0;
+  mockTerminalInstance.cols = 80;
+}
+
+/** Mirrors the real web font finishing its network load/paint settle. */
+function settleMockTerminalFontForCharSize(): void {
+  mockFontsSettledForCharSize = true;
+}
+
+/** The rendered cell/advance-width geometry invariant under test: 0 == tight contiguous monospace. */
+function getMockBakedLetterSpacingPx(): number {
+  return mockBakedLetterSpacingPx;
+}
+
+// Mirrors xterm's CharSizeService.measure() -> onCharSizeChange ->
+// DomRenderer.handleCharSizeChanged() -> _updateDimensions() +
+// _setDefaultSpacing(): runs on every GENUINE fontFamily/fontSize option
+// transition, using the CURRENT (possibly stale, pre-fit) column count.
+function mockHandleCharSizeChanged(): void {
+  mockMeasuredCharWidthPx = mockFontsSettledForCharSize
+    ? MOCK_SETTLED_CHAR_WIDTH_PX
+    : MOCK_FALLBACK_CHAR_WIDTH_PX;
+  const cols = (mockTerminalInstance.cols as number) || 1;
+  const cellWidthPx = MOCK_CONTAINER_WIDTH_PX / cols;
+  mockBakedLetterSpacingPx = cellWidthPx - mockMeasuredCharWidthPx;
+}
+
+// Mirrors FitAddon.fit() -> terminal.resize(cols, rows) ->
+// DomRenderer.handleResize(): recomputes cols/cell-width from the CURRENT
+// measured char width but deliberately does NOT touch letter-spacing (real
+// xterm's handleResize() never calls _setDefaultSpacing()).
+const mockFitAddonFit = vi.fn(() => {
+  mockTerminalInstance.cols = Math.max(
+    1,
+    Math.floor(MOCK_CONTAINER_WIDTH_PX / mockMeasuredCharWidthPx),
+  );
+});
 
 let terminalKeyEventHandler: ((event: KeyboardEvent) => boolean) | null = null;
 let terminalDataHandler: ((data: string) => void) | null = null;
@@ -106,6 +172,7 @@ function createMockTerminalOptions(): Record<string, unknown> {
           store[key] = value;
           if (key === "fontFamily" || key === "fontSize") {
             fontRemeasureCount += 1;
+            mockHandleCharSizeChanged();
           }
         }
       },
@@ -286,6 +353,7 @@ describe("TerminalModal", () => {
     mockTerminalInstance.options.cursorStyle = "block";
     mockTerminalInstance.options.cursorBlink = true;
     resetFontRemeasureCount();
+    resetMockTerminalGeometry();
     mockCreateTerminalSession.mockResolvedValue({
       sessionId: "test-session-123",
       shell: "/bin/bash",
@@ -7151,6 +7219,7 @@ describe("TerminalModal — FN-7561 mobile inter-character spacing (xterm no-op
   beforeEach(() => {
     vi.clearAllMocks();
     resetFontRemeasureCount();
+    resetMockTerminalGeometry();
     vi.spyOn(window, "matchMedia").mockImplementation((query: string) => ({
       matches: false,
       media: query,
@@ -7171,6 +7240,7 @@ describe("TerminalModal — FN-7561 mobile inter-character spacing (xterm no-op
     mockTerminalInstance.options.cursorStyle = "block";
     mockTerminalInstance.options.cursorBlink = true;
     resetFontRemeasureCount();
+    resetMockTerminalGeometry();
     mockUseTerminal.mockReturnValue(createMockTerminalState());
     mockUseTerminalSessions.mockReturnValue(defaultSessionState);
     mockUseWorkspaces.mockReturnValue({
@@ -7231,6 +7301,7 @@ describe("TerminalModal — FN-7561 mobile inter-character spacing (xterm no-op
     // application done during xterm construction/effect setup — reset it and
     // isolate exactly what happens once the deferred font-load settles.
     resetFontRemeasureCount();
+    resetMockTerminalGeometry();
 
     await act(async () => {
       resolveLoad?.();
@@ -7297,6 +7368,7 @@ describe("TerminalModal — FN-7561 mobile inter-character spacing (xterm no-op
 
     await waitFor(() => expect(mockTerminalInstance.open).toHaveBeenCalled());
     resetFontRemeasureCount();
+    resetMockTerminalGeometry();
 
     await act(async () => {
       resolveLoad?.();
@@ -7313,3 +7385,263 @@ describe("TerminalModal — FN-7561 mobile inter-character spacing (xterm no-op
     Object.defineProperty(window, "visualViewport", { value: undefined, writable: true, configurable: true });
   });
 });
+
+/*
+FNXC:Terminal 2026-07-04-11:20:
+FN-7567 (recurrence #4 of mobile terminal inter-character spacing, after
+FN-7456's DOM glyph-fallback fix, FN-7460's `text-size-adjust: none`, and
+FN-7561's `forceTerminalFontRemeasure`) root cause: real xterm.js's
+`DomRenderer._setDefaultSpacing()` bakes the letter-spacing compensation used
+to correct rounding drift between the measured character width and the
+computed cell width (`dimensions.css.cell.width`, which is itself derived from
+the container width divided by the CURRENT column count). That bake only runs
+from `handleCharSizeChanged()` (wired to `CharSizeService.onCharSizeChange`,
+i.e. any genuine `fontFamily`/`fontSize` option transition) and from
+`handleDevicePixelRatioChange()` \u2014 NEVER from `handleResize()`, which is what
+`fitAddon.fit()` -> `terminal.resize(cols, rows)` triggers. Both mobile
+settle sites (`remeasureAfterTerminalFontLoad` in TerminalModal.tsx and its
+SessionTerminal.tsx sibling, plus the live-preferences-apply settle path in
+both files) call `forceTerminalFontRemeasure()` \u2014 which correctly forces a
+genuine option transition and DOES bake letter-spacing \u2014 but they bake it
+using the STALE column count that predates `fitAddon.fit()`. `fitAddon.fit()`
+then changes the column count (and therefore the true cell width) but never
+re-bakes the letter-spacing, so the terminal keeps rendering with a spacing
+value computed against a column count that no longer matches reality. This
+produces genuinely excessive inter-character gaps that persist until an
+unrelated later event (device-pixel-ratio change, orientation, reconnect)
+happens to force another *genuine* option/DPR-triggered remeasure \u2014 exactly
+matching the "only repairs itself after an incidental refit" report. See
+`docs/solutions/ui-bugs/xterm-options-noop-remeasure-after-font-settle.md`
+recurrence-#4 addendum.
+
+This suite asserts the actual rendered geometry invariant (baked letter-spacing
+== 0, i.e. cell width matches the settled glyph advance width) using a
+xterm-internals-accurate model (`mockHandleCharSizeChanged`/`mockFitAddonFit`),
+not a re-assertion of the FN-7456/FN-7460/FN-7561 CSS-property/call-count
+checks. It fails on pre-fix code (stale pre-fit letter-spacing survives the
+settle) and passes once the fix re-bakes spacing AFTER `fitAddon.fit()`
+settles the column count.
+*/
+describe("TerminalModal — FN-7567 mobile inter-character spacing (stale post-fit letter-spacing bake)", () => {
+  const mockOnClose = vi.fn();
+  const mockSendInput = vi.fn();
+  const mockResize = vi.fn();
+  const mockReconnect = vi.fn();
+
+  const createMockTerminalState = (overrides = {}) => ({
+    connectionStatus: "connected" as const,
+    sendInput: mockSendInput,
+    resize: mockResize,
+    onData: vi.fn(() => vi.fn()),
+    onExit: vi.fn(() => vi.fn()),
+    onConnect: vi.fn(() => vi.fn()),
+    onScrollback: vi.fn(() => vi.fn()),
+    reconnect: mockReconnect,
+    onSessionInvalid: vi.fn(() => vi.fn()),
+    ...overrides,
+  });
+
+  let previousInnerWidth: number;
+  let previousOntouchstart: unknown;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    resetFontRemeasureCount();
+    resetMockTerminalGeometry();
+    vi.spyOn(window, "matchMedia").mockImplementation((query: string) => ({
+      matches: false,
+      media: query,
+      onchange: null,
+      addListener: vi.fn(),
+      removeListener: vi.fn(),
+      addEventListener: vi.fn(),
+      removeEventListener: vi.fn(),
+      dispatchEvent: vi.fn(),
+    }));
+    previousInnerWidth = window.innerWidth;
+    previousOntouchstart = window.ontouchstart;
+    // Real reported device: a narrow touch-primary mobile viewport.
+    Object.defineProperty(window, "innerWidth", { value: 390, configurable: true });
+    Object.defineProperty(window, "ontouchstart", { value: null, configurable: true });
+    mockTerminalInstance.options.fontFamily = XTERM_FONT_FAMILY;
+    mockTerminalInstance.options.fontSize = 12;
+    mockTerminalInstance.options.cursorStyle = "block";
+    mockTerminalInstance.options.cursorBlink = true;
+    resetFontRemeasureCount();
+    resetMockTerminalGeometry();
+    mockUseTerminal.mockReturnValue(createMockTerminalState());
+    mockUseTerminalSessions.mockReturnValue(defaultSessionState);
+    mockUseWorkspaces.mockReturnValue({
+      projectName: "kb",
+      workspaces: [],
+      loading: false,
+      error: null,
+    });
+    mockCreateTerminalSession.mockResolvedValue({
+      sessionId: "test-session-123",
+      shell: "/bin/bash",
+      cwd: "/project",
+    });
+  });
+
+  afterEach(() => {
+    Object.defineProperty(window, "innerWidth", { value: previousInnerWidth, configurable: true });
+    if (previousOntouchstart === undefined) {
+      delete (window as unknown as { ontouchstart?: unknown }).ontouchstart;
+    } else {
+      Object.defineProperty(window, "ontouchstart", { value: previousOntouchstart, configurable: true });
+    }
+    vi.useRealTimers();
+    vi.restoreAllMocks();
+  });
+
+  it("renders contiguous monospace cells (zero baked letter-spacing) once the mobile web font settles after xterm's initial fit", async () => {
+    let resolveLoad: (() => void) | undefined;
+    let resolveReady: (() => void) | undefined;
+    Object.defineProperty(document, "fonts", {
+      value: {
+        load: vi.fn(
+          () =>
+            new Promise<void>((resolve) => {
+              resolveLoad = resolve;
+            }),
+        ),
+        ready: new Promise<void>((resolve) => {
+          resolveReady = resolve;
+        }),
+      },
+      configurable: true,
+    });
+
+    render(<TerminalModal isOpen={true} onClose={mockOnClose} />);
+
+    await waitFor(() => expect(mockTerminalInstance.open).toHaveBeenCalled());
+    resetFontRemeasureCount();
+
+    // Simulate the real recurrence: the custom web font finishes downloading
+    // AFTER xterm's initial fallback-font measurement/fit already ran and
+    // baked a letter-spacing value that was internally consistent for the
+    // FALLBACK font at that (stale) column count.
+    settleMockTerminalFontForCharSize();
+
+    await act(async () => {
+      resolveLoad?.();
+      resolveReady?.();
+      await Promise.resolve();
+      await Promise.resolve();
+      await Promise.resolve();
+    });
+
+    await waitFor(() => {
+      expect(getFontRemeasureCount()).toBeGreaterThan(0);
+    });
+
+    // The measured geometry invariant: once font metrics settle and xterm
+    // refits to the correct column count for the SETTLED font, the baked
+    // letter-spacing compensation must be recomputed against that FINAL
+    // column count, not the stale pre-fit one. A nonzero value here means
+    // rendered cells are wider (or narrower) than the glyph advance width \u2014
+    // exactly the reported "characters spread across cells" symptom \u2014 and
+    // this assertion fails on pre-fix code, which bakes spacing only BEFORE
+    // `fitAddon.fit()` runs and never re-bakes it afterward.
+    await waitFor(() => {
+      expect(getMockBakedLetterSpacingPx()).toBeCloseTo(0, 5);
+    });
+  });
+
+  it("also settles to zero baked letter-spacing at persisted 10px with the mobile keyboard already open at initial render", async () => {
+    window.localStorage.setItem(TERMINAL_FONT_SIZE_KEY, "10");
+
+    const mockVV = {
+      width: 375,
+      height: 300,
+      offsetTop: 0,
+      offsetLeft: 0,
+      addEventListener: vi.fn(),
+      removeEventListener: vi.fn(),
+    };
+    Object.defineProperty(window, "visualViewport", {
+      value: mockVV,
+      writable: true,
+      configurable: true,
+    });
+    Object.defineProperty(window, "innerHeight", { value: 300, writable: true, configurable: true });
+
+    let resolveLoad: (() => void) | undefined;
+    let resolveReady: (() => void) | undefined;
+    Object.defineProperty(document, "fonts", {
+      value: {
+        load: vi.fn(
+          () =>
+            new Promise<void>((resolve) => {
+              resolveLoad = resolve;
+            }),
+        ),
+        ready: new Promise<void>((resolve) => {
+          resolveReady = resolve;
+        }),
+      },
+      configurable: true,
+    });
+
+    render(<TerminalModal isOpen={true} onClose={mockOnClose} />);
+
+    await waitFor(() => expect(mockTerminalInstance.open).toHaveBeenCalled());
+    resetFontRemeasureCount();
+    settleMockTerminalFontForCharSize();
+
+    await act(async () => {
+      resolveLoad?.();
+      resolveReady?.();
+      await Promise.resolve();
+      await Promise.resolve();
+      await Promise.resolve();
+    });
+
+    await waitFor(() => {
+      expect(getFontRemeasureCount()).toBeGreaterThan(0);
+    });
+
+    // Same measured geometry invariant, but with the keyboard already
+    // constraining the viewport at initial render and a persisted 10px font —
+    // the exact FN-7460 screenshot conditions — to prove the fix is not
+    // accidentally scoped to only the default font-size/no-keyboard case.
+    await waitFor(() => {
+      expect(getMockBakedLetterSpacingPx()).toBeCloseTo(0, 5);
+    });
+
+    Object.defineProperty(window, "visualViewport", { value: undefined, writable: true, configurable: true });
+  });
+
+  it("also settles to zero baked letter-spacing when a live font-size preference change resettles after fit", async () => {
+    Object.defineProperty(document, "fonts", {
+      value: {
+        load: vi.fn(() => Promise.resolve()),
+        ready: Promise.resolve(),
+      },
+      configurable: true,
+    });
+
+    render(<TerminalModal isOpen={true} onClose={mockOnClose} />);
+    await waitFor(() => expect(mockTerminalInstance.open).toHaveBeenCalled());
+
+    // Let the initial-open settle path finish and reach a consistent baseline.
+    await act(async () => {
+      await Promise.resolve();
+      await Promise.resolve();
+      await Promise.resolve();
+    });
+    settleMockTerminalFontForCharSize();
+    resetFontRemeasureCount();
+
+    fireEvent.click(await screen.findByTestId("terminal-font-size-increase"));
+
+    await waitFor(() => {
+      expect(getFontRemeasureCount()).toBeGreaterThan(0);
+    });
+
+    await waitFor(() => {
+      expect(getMockBakedLetterSpacingPx()).toBeCloseTo(0, 5);
+    });
+  });
+});

From 986e249bc1a825419ad8f5e544b886e4fdc66a04 Mon Sep 17 00:00:00 2001
From: gsxdsm <gsxdsm@users.noreply.github.com>
Date: Sat, 4 Jul 2026 23:54:09 -0700
Subject: [PATCH 18/65] FN-7555: surface bidirectional undo/source task links
 in dashboard UI

Adds a client-side helper and UI affordances so AI-undo tasks and their source tasks link to each other in the dashboard, without any new API or backend changes.

- Add packages/dashboard/app/utils/taskRevert.ts with getRevertOfId() (resolves the revertOf marker written by createAiUndoTask, with a defensive sourceType==="recovery" fallback to sourceParentTaskId) and findOpenUndoTaskForSource() (reverse lookup for the most recent open undo task pointing at a source task)
- TaskCard and TaskDetailModal now render "Undo of <id>" / "Undo task: <id>" provenance links using the shared helper, keeping forward and reverse affordances consistent
- Add TaskCard.css styling for the new undo-link affordance
- Add/extend tests: TaskCard.test.tsx and TaskDetailModal.rendering.test.tsx cover the new undo/source link rendering
- Update docs/task-management.md and packages/i18n/locales/en/app.json for the new UI copy

Files changed:
 docs/task-management.md                            |   2 +-
 packages/dashboard/app/components/TaskCard.css     |  37 +++++
 packages/dashboard/app/components/TaskCard.tsx     |  29 +++-
 .../dashboard/app/components/TaskDetailModal.tsx   |  46 ++++++
 .../app/components/__tests__/TaskCard.test.tsx     |  46 ++++++
 .../__tests__/TaskDetailModal.rendering.test.tsx   | 160 +++++++++++++++++++++
 packages/dashboard/app/utils/taskRevert.ts         |  80 +++++++++++
 packages/i18n/locales/en/app.json                  |   7 +-
 8 files changed, 403 insertions(+), 4 deletions(-)

Fusion-Task-Id: FN-7555

Fusion-Task-Lineage: c3d2dbd2-4d86-40b5-afce-0ca7a6dfc73d

Co-authored-by: Fusion (runfusion.ai) <noreply@runfusion.ai>
---
 docs/task-management.md                       |   2 +-
 .../dashboard/app/components/TaskCard.css     |  37 ++++
 .../dashboard/app/components/TaskCard.tsx     |  29 +++-
 .../app/components/TaskDetailModal.tsx        |  46 +++++
 .../components/__tests__/TaskCard.test.tsx    |  46 +++++
 .../TaskDetailModal.rendering.test.tsx        | 160 ++++++++++++++++++
 packages/dashboard/app/utils/taskRevert.ts    |  80 +++++++++
 packages/i18n/locales/en/app.json             |   7 +-
 8 files changed, 403 insertions(+), 4 deletions(-)
 create mode 100644 packages/dashboard/app/utils/taskRevert.ts

diff --git a/docs/task-management.md b/docs/task-management.md
index 4aad65d790..6af1f9b47f 100644
--- a/docs/task-management.md
+++ b/docs/task-management.md
@@ -686,7 +686,7 @@ Recovery/backfill guidance:
 - AI-undo response contract: `{ mode: "ai", createdTaskId: "FN-YYYY", alreadyOpen?: true }`. The created task is an ordinary `triage`-column board task (via the normal `store.createTask` path) that references the source task's id, mission, and landed files, and instructs undoing the source task's behavior while preserving unrelated later changes to the same files, using a `revert(FN-xxxx): ...` commit convention. It carries NO dependency on the (already done/archived) source task. A `sourceMetadata.revertOf` marker makes repeated fallback calls idempotent — while an AI-undo task for that source is still open, a further call returns the same `createdTaskId` with `alreadyOpen: true` instead of creating a duplicate; a prior undo task that itself reached `done`/`archived` does not suppress a fresh one.
 - **Workspace (multi-repo) tasks (FN-7547):** tasks with `workspaceWorktrees` populated (`isWorkspaceTask`) are revertable too — the route dispatches to a dedicated workspace path that reasons about every sub-repo's integration branch as ONE all-or-nothing unit. It resolves each sub-repo's attributable commit(s), dry-run classifies every sub-repo first, and only commits a `revert(FN-xxxx): ...` commit on EACH sub-repo when every sub-repo classifies clean/already-reverted; if any sub-repo conflicts, no sub-repo is committed and every touched sub-repo worktree is rolled back to its pre-call state. Response contract for workspace tasks: `{ mode: "git", clean, workspace: { repos: [{ repo, classification, revertCommitSha?, conflicts?, alreadyReverted? }] }, conflicts?: {repo, file, ...}[] }`. A conflicting workspace result still falls back to the AI-undo task under `"auto"` mode, same as a single-repo conflicting result.
 - `autoMerge:false` projects return `needsHuman` and never trigger the AI-undo fallback (a human/future UI decides).
-- No dashboard UI affordance ships with this yet (see the Done/Archived card action follow-up task).
+- **Dashboard auto-linking (FN-7555):** the AI-undo task's card shows an "Undo of FN-xxxx" chip and its detail view shows a clickable "Created to undo FN-xxxx" link back to the source task. The source task's detail view shows an "Undo task: FN-YYYY" link whenever an OPEN undo task referencing it exists in the loaded tasks (matching `TaskStore.findOpenRevertTaskForSource`'s open-only semantics — a `done`/`archived`/soft-deleted undo task is never surfaced as active). Both directions are derived client-side from `sourceMetadata.revertOf`; no new API. A dedicated Done/Archived card revert-trigger action is still a separate follow-up (see FN-7525).
 
 
 ## GitHub Issue Import and PR Creation
diff --git a/packages/dashboard/app/components/TaskCard.css b/packages/dashboard/app/components/TaskCard.css
index e667dccee8..5d3a5983ee 100644
--- a/packages/dashboard/app/components/TaskCard.css
+++ b/packages/dashboard/app/components/TaskCard.css
@@ -1039,6 +1039,43 @@ The execution-time badge is part of the footer's bottom-right chip cluster, so i
   .card-duplicate-chip {
     max-width: 100%;
   }
+
+  .card-undo-chip {
+    max-width: 100%;
+  }
+}
+
+/*
+FNXC:TaskRevert 2026-07-04-00:00:
+FN-7555's "Undo of <id>" chip is purely informational (not a warning/error), so it
+reuses the neutral `.card-time-indicator` token pair instead of the near-duplicate
+chip's `--color-warning` tokens. Layout (padding/height/radius/font) still matches
+`.card-duplicate-chip` for visual consistency in the footer row.
+*/
+.card-undo-chip {
+  display: inline-flex;
+  align-items: center;
+  gap: var(--space-xs);
+  flex-shrink: 0;
+  padding: var(--space-xs) var(--space-sm);
+  height: var(--card-chip-height);
+  min-height: var(--card-chip-height);
+  border: var(--btn-border-width) solid color-mix(in srgb, var(--text-muted) 30%, transparent);
+  border-radius: var(--radius-pill);
+  background: color-mix(in srgb, var(--text-muted) 12%, transparent);
+  color: var(--text-muted);
+  font-size: 0.6875rem;
+  font-weight: 600;
+  font-family: var(--font-mono);
+  line-height: 1;
+  white-space: nowrap;
+}
+
+.card-undo-chip > span {
+  display: inline-flex;
+  align-items: center;
+  line-height: 1;
+  transform: translateY(1px);
 }
 
 .card-github-tracking-chip .provider-icon svg {
diff --git a/packages/dashboard/app/components/TaskCard.tsx b/packages/dashboard/app/components/TaskCard.tsx
index 03d0e9be82..256876340d 100644
--- a/packages/dashboard/app/components/TaskCard.tsx
+++ b/packages/dashboard/app/components/TaskCard.tsx
@@ -33,6 +33,7 @@ import { getFreshBatchData } from "../hooks/useBatchBadgeFetch";
 import { useTaskDiffStats } from "../hooks/useTaskDiffStats";
 import { useAgentsMapCache } from "../hooks/useAgentsMapCache";
 import { isTaskStuck } from "../utils/taskStuck";
+import { getRevertOfId } from "../utils/taskRevert";
 import { getStalledReviewSignal } from "../utils/taskStalledReview";
 import { getInReviewStallCopy, shouldShowInReviewStallBadge } from "../utils/inReviewStallCopy";
 import { getStalePausedReviewCopy, shouldShowStalePausedReviewBadge } from "../utils/stalePausedReviewCopy";
@@ -792,6 +793,10 @@ function areTaskCardPropsEqual(previous: TaskCardProps, next: TaskCardProps): bo
     previousTask.sourceMetadata?.agentName === nextTask.sourceMetadata?.agentName &&
     previousTask.sourceMetadata?.nearDuplicateOf === nextTask.sourceMetadata?.nearDuplicateOf &&
     previousTask.sourceMetadata?.nearDuplicateDismissed === nextTask.sourceMetadata?.nearDuplicateDismissed &&
+    // FNXC:TaskRevert 2026-07-04-00:00: repaint the "Undo of <id>" footer chip
+    // (FN-7555) when the revert-of marker changes.
+    previousTask.sourceMetadata?.revertOf === nextTask.sourceMetadata?.revertOf &&
+    previousTask.sourceParentTaskId === nextTask.sourceParentTaskId &&
     previousTask.stalledReview?.reason === nextTask.stalledReview?.reason &&
     previousTask.stalledReview?.heuristic === nextTask.stalledReview?.heuristic &&
     previousTask.stalledReview?.matchCount === nextTask.stalledReview?.matchCount &&
@@ -1313,6 +1318,17 @@ function TaskCardComponent({
     && task.column !== "archived"
     && task.column !== "done"
     && nearDuplicateCanonicalInactive !== true;
+  /**
+   * FNXC:TaskRevert 2026-07-04-00:00:
+   * FN-7555 forward affordance: an AI-undo task (`sourceMetadata.revertOf` set by
+   * `createAiUndoTask`) shows a compact "Undo of <sourceId>" footer chip regardless
+   * of this card's own column, mirroring the detail view's provenance line. The
+   * reverse ("source has an open undo task") chip is intentionally NOT rendered
+   * here — TaskCard does not receive the full `tasks` list, so a per-card reverse
+   * scan is unavailable; that direction is covered by TaskDetailModal only.
+   */
+  const revertOfId = getRevertOfId(task.sourceMetadata, task.sourceParentTaskId, task.sourceType);
+  const showUndoOfChip = Boolean(revertOfId);
   const branchMetadata = useMemo(() => getVisibleTaskCardBranches(task), [task.id, task.branch, task.baseBranch]);
   const hasBranchMetadata = Boolean(branchMetadata.branch || branchMetadata.baseBranch);
   const isAgentCreated = isAgentCreatedTask(task);
@@ -3164,7 +3180,7 @@ function TaskCardComponent({
           </>
         );
       })()}
-      {(filesChangedButton || isGitHubImportedTask || timeIndicator || showNearDuplicateChip || ((showTrackingIndicator || showLinkedIssueChipForImport) && githubTrackedIssue) || (task.retrySummary?.total ?? 0) > 0) && (
+      {(filesChangedButton || isGitHubImportedTask || timeIndicator || showNearDuplicateChip || showUndoOfChip || ((showTrackingIndicator || showLinkedIssueChipForImport) && githubTrackedIssue) || (task.retrySummary?.total ?? 0) > 0) && (
         <div className={`card-footer-row${chipFarRight ? " card-footer-row--chip-far-right" : ""}`}>
           {filesChangedButton}
           {isGitHubImportedTask && !showLinkedIssueChipForImport && (
@@ -3176,8 +3192,17 @@ function TaskCardComponent({
               <ProviderIcon provider="github" size="sm" />
             </span>
           )}
-          {(timeIndicator || showNearDuplicateChip || ((showTrackingIndicator || showLinkedIssueChipForImport) && githubTrackedIssue) || (task.retrySummary?.total ?? 0) > 0) && (
+          {(timeIndicator || showNearDuplicateChip || showUndoOfChip || ((showTrackingIndicator || showLinkedIssueChipForImport) && githubTrackedIssue) || (task.retrySummary?.total ?? 0) > 0) && (
             <div className="card-footer-row-right">
+              {showUndoOfChip && (
+                <span
+                  className="card-undo-chip"
+                  title={t("tasks.undoOfTitle", "Created to undo {{id}}", { id: String(revertOfId) })}
+                  aria-label={t("tasks.undoOfTitle", "Created to undo {{id}}", { id: String(revertOfId) })}
+                >
+                  <span>{t("tasks.undoOf", "Undo of {{id}}", { id: String(revertOfId) })}</span>
+                </span>
+              )}
               {showNearDuplicateChip && (
                 <>
                   <span
diff --git a/packages/dashboard/app/components/TaskDetailModal.tsx b/packages/dashboard/app/components/TaskDetailModal.tsx
index 015bbcda71..3bac1a6738 100644
--- a/packages/dashboard/app/components/TaskDetailModal.tsx
+++ b/packages/dashboard/app/components/TaskDetailModal.tsx
@@ -21,6 +21,7 @@ import {
 } from "@fusion/core";
 import { resolveEffectivePlannerOversightLevel } from "../../../core/src/workflow-settings-resolver";
 import { isNearDuplicateCanonicalInactive } from "../../../core/src/near-duplicate-canonical";
+import { getRevertOfId, findOpenUndoTaskForSource } from "../utils/taskRevert";
 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, fetchWorkflowSettingValues, nudgeOverseer, stopOverseer, explainOverseer, api } from "../api";
 import type { BoardWorkflowsPayload, WorkflowFieldDefinition, CustomFieldRejection } from "../api";
@@ -772,6 +773,21 @@ export function TaskDetailContent({
     sourceAgentName: sourceAgent?.name,
     t,
   });
+  /**
+   * FNXC:TaskRevert 2026-07-04-00:00:
+   * Forward direction (FN-7555): when this task IS an AI-undo task (`sourceMetadata.revertOf`
+   * set by `createAiUndoTask`), surface a "Created to undo <sourceId>" provenance clause with
+   * a clickable link to the source task, alongside — not replacing — the base provenance label.
+   */
+  const revertOfId = getRevertOfId(workingTask.sourceMetadata, workingTask.sourceParentTaskId, workingTask.sourceType);
+  /**
+   * FNXC:TaskRevert 2026-07-04-00:00:
+   * Reverse direction (FN-7555): scan the loaded `tasks` list for the most recent OPEN undo
+   * task pointing back at this task via `revertOf`. Mirrors `TaskStore.findOpenRevertTaskForSource`
+   * (open board columns only) so a done/archived/soft-deleted prior undo attempt never renders as
+   * an active "Undo task" link — that would be a stale/leftover affordance.
+   */
+  const openUndoTask = findOpenUndoTaskForSource(tasks, workingTask.id);
 
   // Sync activeTab when the caller changes initialTab (e.g. opening a different tab)
   useEffect(() => {
@@ -4179,6 +4195,36 @@ export function TaskDetailContent({
                     </span>
                   </div>
                 )}
+                {revertOfId && (
+                  <div className="detail-provenance detail-revert-of-row">
+                    <GitBranch aria-hidden="true" />
+                    <span>
+                      {t("taskDetail.provenance.createdToUndo", "Created to undo")}{" "}
+                      <button
+                        type="button"
+                        className="detail-provenance-link"
+                        onClick={() => handleDepClick(revertOfId)}
+                      >
+                        {revertOfId}
+                      </button>
+                    </span>
+                  </div>
+                )}
+                {openUndoTask && (
+                  <div className="detail-provenance detail-undo-task-row">
+                    <GitBranch aria-hidden="true" />
+                    <span>
+                      {t("taskDetail.provenance.undoTask", "Undo task")}:{" "}
+                      <button
+                        type="button"
+                        className="detail-provenance-link"
+                        onClick={() => handleDepClick(openUndoTask.id)}
+                      >
+                        {openUndoTask.id}
+                      </button>
+                    </span>
+                  </div>
+                )}
                 {(task.prInfo?.number || task.mergeDetails?.prNumber) && (
                   <div className="detail-provenance detail-pr-link-row">
                     <GitBranch aria-hidden="true" />
diff --git a/packages/dashboard/app/components/__tests__/TaskCard.test.tsx b/packages/dashboard/app/components/__tests__/TaskCard.test.tsx
index 01e6b965cd..2c2fbe1707 100644
--- a/packages/dashboard/app/components/__tests__/TaskCard.test.tsx
+++ b/packages/dashboard/app/components/__tests__/TaskCard.test.tsx
@@ -5366,6 +5366,52 @@ describe("TaskCard near-duplicate chip", () => {
   });
 });
 
+/**
+ * FNXC:TaskRevert 2026-07-04-00:00:
+ * FN-7555 forward affordance coverage. Mirrors the near-duplicate chip test shape
+ * above: an AI-undo task (`sourceMetadata.revertOf` set by `createAiUndoTask`) shows
+ * an "Undo of <id>" footer chip; an ordinary task without that marker renders no chip
+ * and no empty footer shell.
+ */
+describe("TaskCard undo-of chip", () => {
+  it("renders undo-of chip when sourceMetadata.revertOf is present", () => {
+    render(
+      <TaskCard
+        task={makeTask({ sourceMetadata: { revertOf: "FN-1234" } })}
+        onOpenDetail={noop}
+        addToast={noop}
+      />,
+    );
+
+    expect(screen.getByText("Undo of FN-1234")).toBeInTheDocument();
+  });
+
+  it("renders no undo-of chip and no empty footer shell for an ordinary task", () => {
+    render(
+      <TaskCard
+        task={makeTask({ sourceMetadata: undefined })}
+        onOpenDetail={noop}
+        addToast={noop}
+      />,
+    );
+
+    expect(screen.queryByText(/Undo of/)).toBeNull();
+    expect(document.querySelector(".card-undo-chip")).toBeNull();
+  });
+
+  it("does not throw and renders nothing for malformed sourceMetadata.revertOf", () => {
+    render(
+      <TaskCard
+        task={makeTask({ sourceMetadata: { revertOf: 12345 as any } })}
+        onOpenDetail={noop}
+        addToast={noop}
+      />,
+    );
+
+    expect(screen.queryByText(/Undo of/)).toBeNull();
+  });
+});
+
 describe("TaskCard memo comparator provenance behavior", () => {
   it("returns false when prAuthAvailable changes", () => {
     const task = makeTask({ column: "in-review" });
diff --git a/packages/dashboard/app/components/__tests__/TaskDetailModal.rendering.test.tsx b/packages/dashboard/app/components/__tests__/TaskDetailModal.rendering.test.tsx
index c5ae75c86b..e63acd3a39 100644
--- a/packages/dashboard/app/components/__tests__/TaskDetailModal.rendering.test.tsx
+++ b/packages/dashboard/app/components/__tests__/TaskDetailModal.rendering.test.tsx
@@ -474,6 +474,166 @@ describe("TaskDetailModal", () => {
       expect(screen.queryByText(/Created via/)).not.toBeInTheDocument();
     });
 
+    /**
+     * FNXC:TaskRevert 2026-07-04-00:00:
+     * FN-7555 bidirectional undo→source affordance coverage. Forward: an AI-undo
+     * task (`sourceMetadata.revertOf` set by `createAiUndoTask`) shows a clickable
+     * "Created to undo <id>" link. Reverse: a source task shows an "Undo task: <id>"
+     * link only when an OPEN undo task referencing it exists in the loaded `tasks`
+     * list — mirroring `TaskStore.findOpenRevertTaskForSource`'s open-only semantics
+     * (done/archived/soft-deleted undo tasks must not surface as an active link).
+     */
+    describe("undo/revert provenance", () => {
+      it("renders a clickable 'Created to undo <id>' link for an AI-undo task", async () => {
+        render(
+          <TaskDetailModal
+            initialTab="definition"
+            task={makeTask({ id: "FN-200", sourceType: "recovery", sourceMetadata: { revertOf: "FN-100" } })}
+            onClose={noop}
+            onMoveTask={noopMove}
+            onDeleteTask={noopDelete}
+            onMergeTask={noopMerge}
+            onOpenDetail={noopOpenDetail}
+            addToast={noop}
+          />,
+        );
+
+        expect(screen.getByText(/Created to undo/)).toBeInTheDocument();
+        const link = screen.getByRole("button", { name: "FN-100" });
+        expect(link).toBeInTheDocument();
+        await userEvent.click(link);
+        await waitFor(() => {
+          expect(noopOpenDetail).toHaveBeenCalled();
+        });
+      });
+
+      it("renders nothing for the forward link when sourceMetadata.revertOf is absent", () => {
+        render(
+          <TaskDetailModal
+            initialTab="definition"
+            task={makeTask({ id: "FN-200", sourceType: "recovery", sourceMetadata: {} })}
+            onClose={noop}
+            onMoveTask={noopMove}
+            onDeleteTask={noopDelete}
+            onMergeTask={noopMerge}
+            onOpenDetail={noopOpenDetail}
+            addToast={noop}
+          />,
+        );
+
+        expect(screen.queryByText(/Created to undo/)).not.toBeInTheDocument();
+      });
+
+      it("does not throw and renders nothing for malformed revertOf metadata", () => {
+        render(
+          <TaskDetailModal
+            initialTab="definition"
+            task={makeTask({ id: "FN-200", sourceMetadata: { revertOf: 999 as any } })}
+            onClose={noop}
+            onMoveTask={noopMove}
+            onDeleteTask={noopDelete}
+            onMergeTask={noopMerge}
+            onOpenDetail={noopOpenDetail}
+            addToast={noop}
+          />,
+        );
+
+        expect(screen.queryByText(/Created to undo/)).not.toBeInTheDocument();
+      });
+
+      it("renders an 'Undo task: <id>' link when an OPEN undo task references this source task", async () => {
+        const sourceTask = makeTask({ id: "FN-100", column: "done" });
+        const undoTask = makeTask({ id: "FN-201", column: "todo", sourceType: "recovery", sourceMetadata: { revertOf: "FN-100" }, createdAt: "2026-07-04T00:00:00.000Z" });
+
+        render(
+          <TaskDetailModal
+            initialTab="definition"
+            task={sourceTask}
+            tasks={[sourceTask, undoTask]}
+            onClose={noop}
+            onMoveTask={noopMove}
+            onDeleteTask={noopDelete}
+            onMergeTask={noopMerge}
+            onOpenDetail={noopOpenDetail}
+            addToast={noop}
+          />,
+        );
+
+        const link = screen.getByRole("button", { name: "FN-201" });
+        expect(link).toBeInTheDocument();
+        await userEvent.click(link);
+        await waitFor(() => {
+          expect(noopOpenDetail).toHaveBeenCalled();
+        });
+      });
+
+      it("renders no reverse link when the only undo task for this source is done/archived (open-only invariant)", () => {
+        const sourceTask = makeTask({ id: "FN-100", column: "done" });
+        const doneUndoTask = makeTask({ id: "FN-202", column: "done", sourceType: "recovery", sourceMetadata: { revertOf: "FN-100" } });
+        const archivedUndoTask = makeTask({ id: "FN-203", column: "archived", sourceType: "recovery", sourceMetadata: { revertOf: "FN-100" } });
+
+        render(
+          <TaskDetailModal
+            initialTab="definition"
+            task={sourceTask}
+            tasks={[sourceTask, doneUndoTask, archivedUndoTask]}
+            onClose={noop}
+            onMoveTask={noopMove}
+            onDeleteTask={noopDelete}
+            onMergeTask={noopMerge}
+            onOpenDetail={noopOpenDetail}
+            addToast={noop}
+          />,
+        );
+
+        expect(screen.queryByRole("button", { name: "FN-202" })).not.toBeInTheDocument();
+        expect(screen.queryByRole("button", { name: "FN-203" })).not.toBeInTheDocument();
+      });
+
+      it("renders no reverse link and no empty shell when no undo task exists for this source", () => {
+        const sourceTask = makeTask({ id: "FN-100", column: "done" });
+
+        const { container } = render(
+          <TaskDetailModal
+            initialTab="definition"
+            task={sourceTask}
+            tasks={[sourceTask]}
+            onClose={noop}
+            onMoveTask={noopMove}
+            onDeleteTask={noopDelete}
+            onMergeTask={noopMerge}
+            onOpenDetail={noopOpenDetail}
+            addToast={noop}
+          />,
+        );
+
+        expect(container.querySelector(".detail-undo-task-row")).toBeNull();
+      });
+
+      it("picks the most recently created open undo task when multiple exist", async () => {
+        const sourceTask = makeTask({ id: "FN-100", column: "done" });
+        const olderUndo = makeTask({ id: "FN-204", column: "todo", sourceMetadata: { revertOf: "FN-100" }, createdAt: "2026-07-01T00:00:00.000Z" });
+        const newerUndo = makeTask({ id: "FN-205", column: "todo", sourceMetadata: { revertOf: "FN-100" }, createdAt: "2026-07-03T00:00:00.000Z" });
+
+        render(
+          <TaskDetailModal
+            initialTab="definition"
+            task={sourceTask}
+            tasks={[sourceTask, olderUndo, newerUndo]}
+            onClose={noop}
+            onMoveTask={noopMove}
+            onDeleteTask={noopDelete}
+            onMergeTask={noopMerge}
+            onOpenDetail={noopOpenDetail}
+            addToast={noop}
+          />,
+        );
+
+        expect(screen.getByRole("button", { name: "FN-205" })).toBeInTheDocument();
+        expect(screen.queryByRole("button", { name: "FN-204" })).not.toBeInTheDocument();
+      });
+    });
+
     it("FN-3755 renders provenance before created-updated timestamps", () => {
       const { container } = render(
         <TaskDetailModal
diff --git a/packages/dashboard/app/utils/taskRevert.ts b/packages/dashboard/app/utils/taskRevert.ts
new file mode 100644
index 0000000000..3d08fc59c3
--- /dev/null
+++ b/packages/dashboard/app/utils/taskRevert.ts
@@ -0,0 +1,80 @@
+import type { Task } from "@fusion/core";
+
+/**
+ * FNXC:TaskRevert 2026-07-04-00:00:
+ * FN-7524 stamps an AI-undo task with `sourceMetadata.revertOf = <sourceTaskId>`
+ * (see `REVERT_OF_METADATA_KEY` in `packages/engine/src/task-revert.ts`) — this is
+ * the sole authoritative undo→source pointer written by `createAiUndoTask`. The
+ * backend deliberately does NOT set `sourceParentTaskId` for undo tasks (that field
+ * is owned by refine/duplicate lineage and child-task counting), so this helper only
+ * falls back to `sourceParentTaskId` defensively for forward-compatibility with a
+ * future backend shape; today it always resolves via `revertOf`.
+ *
+ * The `sourceParentTaskId` fallback is gated to `sourceType === "recovery"` (the
+ * sourceType `createAiUndoTask` stamps). `task_refine`/`task_duplicate` tasks also
+ * set `sourceParentTaskId`, but for an UNRELATED lineage relationship that already
+ * renders its own "Created via Refinement/Duplicate of <id>" provenance clause
+ * (`getProvenanceLabel` in TaskDetailModal.tsx) — without this gate, an undo-of
+ * clause would double-render alongside it for the same id.
+ *
+ * FN-7555 (this task) surfaces this marker bi-directionally in the dashboard only —
+ * no new API, no backend changes. Both `TaskCard` and `TaskDetailModal` import this
+ * helper (and `findOpenUndoTaskForSource` below) so the forward/reverse affordances
+ * never disagree about what counts as "an undo relationship".
+ */
+export function getRevertOfId(
+  sourceMetadata: Task["sourceMetadata"] | undefined,
+  sourceParentTaskId?: string | null,
+  sourceType?: string,
+): string | undefined {
+  const revertOf = sourceMetadata?.revertOf;
+  if (typeof revertOf === "string" && revertOf.trim().length > 0) {
+    return revertOf.trim();
+  }
+
+  if (
+    sourceType === "recovery"
+    && typeof sourceParentTaskId === "string"
+    && sourceParentTaskId.trim().length > 0
+  ) {
+    return sourceParentTaskId.trim();
+  }
+
+  return undefined;
+}
+
+/**
+ * FNXC:TaskRevert 2026-07-04-00:00:
+ * Reverse lookup: given the full loaded `tasks` list and a source task id, find the
+ * most recently created OPEN undo task that points back at it via `revertOf`. This
+ * mirrors `TaskStore.findOpenRevertTaskForSource` (packages/core/src/store.ts)
+ * client-side: `done`/`archived`/soft-deleted undo tasks are intentionally excluded
+ * so a completed or discarded undo attempt never renders as an active "Undo task"
+ * link (no stale/leftover affordance). When multiple open undo tasks exist (should
+ * not normally happen given the route's own dedup guard, but the UI must stay
+ * defensive), the most recently created one wins.
+ */
+export function findOpenUndoTaskForSource(tasks: readonly Task[], sourceTaskId: string): Task | undefined {
+  const trimmedSourceId = sourceTaskId.trim();
+  if (trimmedSourceId.length === 0) {
+    return undefined;
+  }
+
+  let best: Task | undefined;
+  for (const candidate of tasks) {
+    if (candidate.deletedAt) {
+      continue;
+    }
+    if (candidate.column === "done" || candidate.column === "archived") {
+      continue;
+    }
+    if (getRevertOfId(candidate.sourceMetadata) !== trimmedSourceId) {
+      continue;
+    }
+    if (!best || new Date(candidate.createdAt).getTime() > new Date(best.createdAt).getTime()) {
+      best = candidate;
+    }
+  }
+
+  return best;
+}
diff --git a/packages/i18n/locales/en/app.json b/packages/i18n/locales/en/app.json
index 2324b4d85b..fdecb3d516 100644
--- a/packages/i18n/locales/en/app.json
+++ b/packages/i18n/locales/en/app.json
@@ -7658,7 +7658,9 @@
     "provenance": {
       "createdBy": "Created by",
       "createdVia": "Created via",
-      "parentTaskOf": "of"
+      "parentTaskOf": "of",
+      "createdToUndo": "Created to undo",
+      "undoTask": "Undo task"
     },
     "recoveryState": "Recovery state",
     "refine": {
@@ -8233,6 +8235,9 @@
     "unarchived": "Unarchived {{taskId}}",
     "unarchiveFailed": "Failed to unarchive {{taskId}}: {{error}}",
     "unarchiveTask": "Unarchive task",
+    "undoOf": "Undo of {{id}}",
+    "undoOfTitle": "Created to undo {{id}}",
+    "undoTask": "Undo task: {{id}}",
     "updated": "Updated {{taskId}}",
     "updateFailed": "Failed to update {{taskId}}: {{error}}",
     "uploadFailed": "Failed to upload: {{files}}",

From 92ba45cc011776a434e2cd33431728f1a1deb65e Mon Sep 17 00:00:00 2001
From: gsxdsm <gsxdsm@users.noreply.github.com>
Date: Sun, 5 Jul 2026 07:41:49 -0700
Subject: [PATCH 19/65] fix: normalize Anthropic subscription callback URLs

---
 .../src/__tests__/routes-auth.test.ts         | 50 ++++++++++++++++
 .../src/routes/register-auth-routes.ts        | 58 +++++++++++++++++--
 2 files changed, 104 insertions(+), 4 deletions(-)

diff --git a/packages/dashboard/src/__tests__/routes-auth.test.ts b/packages/dashboard/src/__tests__/routes-auth.test.ts
index df21e6d5d6..9283925c0b 100644
--- a/packages/dashboard/src/__tests__/routes-auth.test.ts
+++ b/packages/dashboard/src/__tests__/routes-auth.test.ts
@@ -2189,6 +2189,7 @@ describe("POST /auth/login", () => {
   });
 
   it.each([
+    ["http query", "http://localhost:53692/callback?code=http-code&state=expected-state", "code=http-code&state=expected-state"],
     ["fragment", "http://localhost:53692/callback#code=fragment-code&state=expected-state", "code=fragment-code&state=expected-state"],
     ["schemeless", "localhost:53692/callback?code=schemeless-code&state=expected-state", "code=schemeless-code&state=expected-state"],
   ])("normalizes Anthropic subscription pasted callback URLs with %s parameters", async (_case, callbackUrl, expectedInput) => {
@@ -2496,6 +2497,55 @@ describe("POST /auth/manual-code", () => {
     });
   });
 
+  it("delivers pasted Anthropic callback URLs to the local OAuth listener", async () => {
+    const originalFetch = globalThis.fetch;
+    const fetchMock = vi.fn().mockResolvedValue({ ok: true, status: 200, text: async () => "ok" });
+    globalThis.fetch = fetchMock as unknown as typeof fetch;
+    let submittedCode: string | undefined;
+    (authStorage.login as ReturnType<typeof vi.fn>).mockImplementation(
+      async (_provider: string, callbacks: {
+        onAuth: (info: { url: string; instructions?: string }) => void;
+        onManualCodeInput?: () => Promise<string>;
+      }) => {
+        callbacks.onAuth({
+          url: "https://claude.ai/oauth/authorize?state=anthropic-state&redirect_uri=http%3A%2F%2Flocalhost%3A53692%2Fcallback",
+        });
+        submittedCode = await callbacks.onManualCodeInput?.();
+      },
+    );
+
+    try {
+      const app = buildApp();
+      const loginRes = await REQUEST(
+        app,
+        "POST",
+        "/api/auth/login",
+        JSON.stringify({ provider: "anthropic-subscription", origin: "https://remote.example.com" }),
+        { "Content-Type": "application/json" },
+      );
+
+      expect(loginRes.status).toBe(200);
+
+      const submitRes = await REQUEST(
+        app,
+        "POST",
+        "/api/auth/manual-code",
+        JSON.stringify({ provider: "anthropic-subscription", code: "http://localhost:53692/callback?code=anthropic-code&state=anthropic-state" }),
+        { "Content-Type": "application/json" },
+      );
+
+      expect(submitRes.status).toBe(200);
+      expect(fetchMock).toHaveBeenCalledTimes(1);
+      expect(String(fetchMock.mock.calls[0]?.[0])).toBe("http://127.0.0.1:53692/callback?code=anthropic-code&state=anthropic-state");
+      expect(fetchMock.mock.calls[0]?.[1]).toEqual(expect.objectContaining({ method: "GET" }));
+      await vi.waitFor(() => {
+        expect(submittedCode).toBe("code=anthropic-code&state=anthropic-state");
+      });
+    } finally {
+      globalThis.fetch = originalFetch;
+    }
+  });
+
   it("submits pasted manual code for anthropic login", async () => {
     let submittedCode: string | undefined;
     (authStorage.login as ReturnType<typeof vi.fn>).mockImplementation(
diff --git a/packages/dashboard/src/routes/register-auth-routes.ts b/packages/dashboard/src/routes/register-auth-routes.ts
index 35a29ff173..503b3c30fc 100644
--- a/packages/dashboard/src/routes/register-auth-routes.ts
+++ b/packages/dashboard/src/routes/register-auth-routes.ts
@@ -251,6 +251,23 @@ export const registerAuthRoutes: ApiRouteRegistrar = (ctx) => {
     return providerId === "github-copilot";
   }
 
+  function parseManualOAuthCallbackUrl(input: string): URL | undefined {
+    const trimmed = input.trim();
+    const candidates = [trimmed];
+    if (/^(?:localhost|127\.0\.0\.1|\[::1\])(?::|\/)/i.test(trimmed)) {
+      candidates.unshift(`http://${trimmed}`);
+    }
+
+    for (const candidate of candidates) {
+      try {
+        return new URL(candidate);
+      } catch {
+        // Try the next representation.
+      }
+    }
+    return undefined;
+  }
+
   function normalizeManualOAuthInputForProvider(providerId: string, input: string): string {
     if (providerId !== "anthropic" && providerId !== "openai-codex") {
       return input.trim();
@@ -262,10 +279,13 @@ export const registerAuthRoutes: ApiRouteRegistrar = (ctx) => {
     }
 
     try {
-      const url = new URL(trimmed);
+      const url = parseManualOAuthCallbackUrl(trimmed);
+      if (!url) {
+        throw new Error("not a URL");
+      }
       const searchCode = url.searchParams.get("code");
       if (searchCode) {
-        if (url.protocol === "http:" || url.protocol === "https:") {
+        if (providerId === "openai-codex" && (url.protocol === "http:" || url.protocol === "https:")) {
           return trimmed;
         }
         const normalized = new URLSearchParams();
@@ -291,6 +311,7 @@ export const registerAuthRoutes: ApiRouteRegistrar = (ctx) => {
       FNXC:ProviderAuth 2026-07-04-00:00:
       Anthropic subscription and Codex pasted-login flows must accept the exact browser address bar after redirect, including providers/browsers that place OAuth `code` and `state` in the URL fragment or omit the URL scheme.
       The upstream CLI parser treats a syntactically valid URL as search-only and schemeless localhost text as raw parameters, so normalize callback inputs to query-param text before resolving the pending manual-code prompt.
+      Also keep the raw callback URL parseable for server-side callback delivery when the browser cannot reach the local OAuth listener itself.
       */
       const normalized = new URLSearchParams();
       normalized.set("code", hashCode);
@@ -320,6 +341,33 @@ export const registerAuthRoutes: ApiRouteRegistrar = (ctx) => {
     }
   }
 
+  async function deliverManualOAuthCallbackToLocalListener(providerId: string, input: string): Promise<void> {
+    if (providerId !== "anthropic") {
+      return;
+    }
+
+    const url = parseManualOAuthCallbackUrl(input);
+    if (!url || !["localhost", "127.0.0.1", "[::1]"].includes(url.hostname)) {
+      return;
+    }
+
+    const code = url.searchParams.get("code");
+    const state = url.searchParams.get("state");
+    if (!code || !state || !url.port) {
+      return;
+    }
+
+    const callbackUrl = new URL(`http://127.0.0.1:${url.port}${url.pathname}`);
+    callbackUrl.searchParams.set("code", code);
+    callbackUrl.searchParams.set("state", state);
+
+    try {
+      await fetch(callbackUrl, { method: "GET", signal: AbortSignal.timeout(3_000) });
+    } catch {
+      // Fall back to resolving the pending manual-code prompt below.
+    }
+  }
+
   function selectOauthOption(
     providerId: string,
     prompt: { options: Array<{ id: string; label?: string }> },
@@ -1206,7 +1254,7 @@ export const registerAuthRoutes: ApiRouteRegistrar = (ctx) => {
    * Body: { provider: string, code: string }
    * Response: { success: true, submitted: boolean }
    */
-  router.post("/auth/manual-code", (req, res) => {
+  router.post("/auth/manual-code", async (req, res) => {
     try {
       const { provider, code } = req.body;
       if (!provider || typeof provider !== "string") {
@@ -1226,8 +1274,10 @@ export const registerAuthRoutes: ApiRouteRegistrar = (ctx) => {
         return;
       }
 
+      const storageProvider = toOauthLoginProviderId(provider);
       activeLogin.inputSubmitted = true;
-      activeLogin.resolveInput(normalizeManualOAuthInputForProvider(toOauthLoginProviderId(provider), code));
+      await deliverManualOAuthCallbackToLocalListener(storageProvider, code);
+      activeLogin.resolveInput(normalizeManualOAuthInputForProvider(storageProvider, code));
       res.json({ success: true, submitted: true });
     } catch (err: unknown) {
       if (err instanceof ApiError) {

From ce9df297eb00c602293025280d847db24c17438f Mon Sep 17 00:00:00 2001
From: gsxdsm <gsxdsm@users.noreply.github.com>
Date: Sun, 5 Jul 2026 09:00:59 -0700
Subject: [PATCH 20/65] FN-7574: fix OAuth token expiry detection and add
 proactive auto-refresh

Unifies OAuth expiry detection so expired Claude subscription logins correctly show as disconnected with a re-login prompt, and adds a proactive engine-side scheduler that refreshes tokens before they expire.

- Share expiry-detection logic between OAuthExpiryMonitor and the /api/auth/status route so both agree on when a token is expired.
- Add engine-side oauth-refresh-scheduler that proactively refreshes OAuth tokens ahead of expiry, wired into project-engine (guarded by skipNotifier).
- Extend auth-storage with the helpers needed for expiry checks/refresh.
- Add tests covering routes-auth status detection, auth-storage expiry helpers, and the new refresh scheduler.
- Document the new behavior in dashboard-guide.md and settings-reference.md.
- Add changeset for the user-facing fix.

Files changed:
 .../fn-7574-oauth-expiry-detection-refresh.md      |   7 +
 docs/dashboard-guide.md                            |   4 +
 docs/settings-reference.md                         |   4 +
 .../dashboard/src/__tests__/routes-auth.test.ts    |  76 +++++++++++
 .../dashboard/src/routes/register-auth-routes.ts   |  25 +++-
 packages/engine/src/__tests__/auth-storage.test.ts |  60 +++++++++
 packages/engine/src/auth-storage.ts                |  14 +-
 .../__tests__/oauth-refresh-scheduler.test.ts      | 141 ++++++++++++++++++++
 packages/engine/src/notification/index.ts          |   3 +
 .../src/notification/oauth-refresh-scheduler.ts    | 143 +++++++++++++++++++++
 packages/engine/src/project-engine.ts              |  14 +-
 11 files changed, 488 insertions(+), 3 deletions(-)

Fusion-Task-Id: FN-7574

Fusion-Task-Lineage: 59996eac-c070-4992-9727-d066c6934b69

Co-authored-by: Fusion (runfusion.ai) <noreply@runfusion.ai>
---
 .../fn-7574-oauth-expiry-detection-refresh.md |   7 +
 docs/dashboard-guide.md                       |   4 +
 docs/settings-reference.md                    |   4 +
 .../src/__tests__/routes-auth.test.ts         |  76 ++++++++++
 .../src/routes/register-auth-routes.ts        |  25 ++-
 .../engine/src/__tests__/auth-storage.test.ts |  60 ++++++++
 packages/engine/src/auth-storage.ts           |  14 +-
 .../__tests__/oauth-refresh-scheduler.test.ts | 141 +++++++++++++++++
 packages/engine/src/notification/index.ts     |   3 +
 .../notification/oauth-refresh-scheduler.ts   | 143 ++++++++++++++++++
 packages/engine/src/project-engine.ts         |  14 +-
 11 files changed, 488 insertions(+), 3 deletions(-)
 create mode 100644 .changeset/fn-7574-oauth-expiry-detection-refresh.md
 create mode 100644 packages/engine/src/notification/__tests__/oauth-refresh-scheduler.test.ts
 create mode 100644 packages/engine/src/notification/oauth-refresh-scheduler.ts

diff --git a/.changeset/fn-7574-oauth-expiry-detection-refresh.md b/.changeset/fn-7574-oauth-expiry-detection-refresh.md
new file mode 100644
index 0000000000..1624b75079
--- /dev/null
+++ b/.changeset/fn-7574-oauth-expiry-detection-refresh.md
@@ -0,0 +1,7 @@
+---
+"@runfusion/fusion": patch
+---
+
+summary: Expired Claude subscription logins now show disconnected with a re-login prompt; tokens auto-refresh before expiry.
+category: fix
+dev: Unifies OAuth expiry detection between OAuthExpiryMonitor and /api/auth/status, and adds an engine-side proactive OAuth refresh scheduler wired in project-engine (guarded by skipNotifier). No token material logged.
diff --git a/docs/dashboard-guide.md b/docs/dashboard-guide.md
index 07e9d30bdb..37a2e8cfff 100644
--- a/docs/dashboard-guide.md
+++ b/docs/dashboard-guide.md
@@ -705,6 +705,10 @@ For Claude/Anthropic OAuth credentials, the same `/auth/status` poll also attemp
 
 If the OAuth credential has no refresh token, the refresh request fails, or the provider is not Anthropic, the provider stays expired and the banner remains visible. Re-authenticate with manual re-login from **Settings → Authentication** or Model Onboarding. On Fusion desktop, OAuth login URLs open in the operating system browser rather than an in-app Electron child window; the Settings/Onboarding UI keeps polling until the provider authenticates or the login truly stops.
 
+<!-- FNXC:ProviderAuth 2026-07-05-00:00: FN-7574 — the status route and the engine's OAuthExpiryMonitor previously diverged: a subscription OAuth credential with a past or missing/non-numeric `expires` could still read authenticated:true from /api/auth/status even though the monitor had already fired an oauth-token-expired notification for it. `/api/auth/status` now treats any OAuth credential lacking a usable numeric `expires` — and any credential whose numeric `expires` is in the past and cannot be refreshed — as expired:true/authenticated:false, for both the legacy anthropic-row and separated anthropic-subscription-row storage permutations. Settings → Authentication and the global re-login banner both read this corrected status, so an expired-and-unrefreshable subscription now consistently shows as not connected everywhere. -->
+
+<!-- FNXC:ClaudeOAuth 2026-07-05-00:00: FN-7574 — beyond the reactive best-effort refresh on the /auth/status poll, the engine now runs an independent background OAuthRefreshScheduler (packages/engine/src/notification/oauth-refresh-scheduler.ts) on a 5-minute interval, guarded by the same `skipNotifier` option as OAuthExpiryMonitor. It proactively calls the existing refresh-if-due logic in auth-storage.ts for every known OAuth provider (plus the anthropic-subscription alias) so a healthy subscription's access token is renewed well ahead of expiry via the stored refresh token, instead of only refreshing reactively when something happens to request a runtime API key. Only providerId/providerName/expiresAt are ever logged — never token material. -->
+
 Anthropic also supports a raw `ANTHROPIC_API_KEY` from a separate **Anthropic API Key** card in **Settings → Authentication** and Model Onboarding. Claude subscription OAuth remains on the **Anthropic Subscription** card for auth status, usage/subscription checks, and banner clearing; it also drives direct agent execution on the `anthropic` provider — a subscription/OAuth token runs `anthropic/*` selections against `https://api.anthropic.com/v1` with Claude Code identity headers, no API key required. CLI-backed execution remains the distinct, explicit **Claude CLI** provider (`pi-claude-cli`); subscription OAuth does not require it. When Anthropic Subscription is expired but Anthropic API Key or Anthropic — via Claude CLI is already authenticated, the global banner suppresses only the urgent subscription re-login entry so it does not imply agents are blocked; Settings still shows the subscription OAuth card as expired/not connected and re-login remains available. A configured API key takes precedence over OAuth on the direct provider. Saving or clearing an API key does not affect the OAuth sign-in path or turn OAuth tokens into raw API-key material. The dashboard only displays masked key hints after a key is saved.
 
 ## Setup Warning Banner
diff --git a/docs/settings-reference.md b/docs/settings-reference.md
index 3443cc6f53..a6054519a3 100644
--- a/docs/settings-reference.md
+++ b/docs/settings-reference.md
@@ -761,8 +761,12 @@ Recovery entrypoints in the dashboard:
 
 Fusion automatically refreshes Claude/Anthropic OAuth credentials before reporting auth status when the stored OAuth credential includes a refresh token and the access token is expired or within the refresh buffer. For Anthropic, this status path is the `anthropic-subscription` surface (including legacy `anthropic` OAuth rows), not Claude CLI state. A successful refresh updates auth storage and prevents `oauth-token-expired` notifications or startup warnings for that provider, so users usually do not need manual re-login after the initial Claude OAuth login.
 
+<!-- FNXC:ClaudeOAuth 2026-07-05-00:00: FN-7574 — the proactive-refresh buffer was widened from 60s to 5 minutes (`OAUTH_REFRESH_BUFFER_MS` in packages/engine/src/auth-storage.ts) so a credential nearing expiry is treated as due-for-refresh earlier, without needlessly refreshing well-valid tokens. An engine-side background `OAuthRefreshScheduler` also polls every 5 minutes and reuses this same refresh-if-due logic against every known OAuth provider (plus the anthropic-subscription alias), so healthy subscriptions renew ahead of expiry even if nothing else happens to request a runtime API key in that window. In-flight refresh dedupe and the 30s post-failure cooldown (`OAUTH_REFRESH_FAILURE_COOLDOWN_MS`) still apply. -->
+
 Manual re-login is still required when no refresh token is stored, the refresh request fails, or the expired OAuth credential belongs to a non-Anthropic provider. In those cases the credential remains expired, `oauth-token-expired` notifications/startup warnings may fire subject to their 12-hour provider throttle, and users should re-authenticate from **Settings → Authentication** or Model Onboarding. The top-level dashboard re-login banner suppresses only the urgent **Anthropic Subscription** entry when **Anthropic API Key** or **Anthropic — via Claude CLI** is already authenticated, so the banner does not imply all Anthropic agent execution is blocked; Settings still shows the subscription OAuth state as expired/not connected until it is refreshed or re-logged-in.
 
+<!-- FNXC:ProviderAuth 2026-07-05-00:00: FN-7574 — `/api/auth/status` and the engine's OAuthExpiryMonitor previously diverged on what counted as "expired": an oauth-typed credential with a past or missing/non-numeric `expires` could still read authenticated:true from the status route, even after the monitor's oauth-token-expired notification fired. The status route now fails safe: any OAuth credential lacking a usable numeric `expires`, or whose numeric `expires` is in the past and cannot be refreshed, reports expired:true/authenticated:false for both the legacy anthropic-row and separated anthropic-subscription-row storage permutations. -->
+
 ### Anthropic API-key authentication
 
 Anthropic has three independent authentication/routing paths:
diff --git a/packages/dashboard/src/__tests__/routes-auth.test.ts b/packages/dashboard/src/__tests__/routes-auth.test.ts
index 9283925c0b..a0de003484 100644
--- a/packages/dashboard/src/__tests__/routes-auth.test.ts
+++ b/packages/dashboard/src/__tests__/routes-auth.test.ts
@@ -1184,6 +1184,82 @@ describe("GET /auth/status", () => {
     expect(anthropic).toMatchObject({ authenticated: false, expired: true });
   });
 
+  /*
+  FNXC:ProviderAuth 2026-07-05-00:00:
+  FN-7574 symptom verification: an expired, unrefreshable Anthropic Subscription OAuth
+  credential must report authenticated:false/expired:true across BOTH the legacy
+  pre-split `anthropic`-row storage permutation and the separated `anthropic-subscription`-
+  row permutation, so the settings card and OAuthReloniBanner never show a lapsed
+  subscription as connected. Covers the exact reproduction from the task's Symptom
+  Verification section.
+  */
+  it("FN-7574: reports expired-and-unrefreshable subscription OAuth as not-connected (separated anthropic-subscription row)", async () => {
+    const now = Date.now();
+    (authStorage.getOAuthProviders as ReturnType<typeof vi.fn>).mockReturnValue([
+      { id: "anthropic", name: "Anthropic" },
+    ]);
+    (authStorage.hasAuth as ReturnType<typeof vi.fn>).mockImplementation((provider: string) => provider === "anthropic-subscription");
+    (authStorage.get as ReturnType<typeof vi.fn>).mockImplementation((provider: string) => provider === "anthropic-subscription" ? ({
+      type: "oauth",
+      access: "expired-token",
+      refresh: "revoked-refresh-token",
+      expires: now - 60_000,
+    }) : undefined);
+    // Simulate a revoked refresh token: the best-effort refresh attempt inside the
+    // status route fails (non-200 from the OAuth token endpoint), so getApiKey resolves
+    // to undefined without throwing.
+    (authStorage.getApiKey as ReturnType<typeof vi.fn>).mockResolvedValue(undefined);
+
+    const res = await GET(app, "/api/auth/status");
+
+    expect(res.status).toBe(200);
+    const anthropic = res.body.providers.find((p: any) => p.id === "anthropic-subscription");
+    expect(authStorage.getApiKey).toHaveBeenCalledWith("anthropic-subscription");
+    expect(anthropic).toMatchObject({ authenticated: false, expired: true });
+  });
+
+  it("FN-7574: reports expired-and-unrefreshable subscription OAuth as not-connected (legacy anthropic row)", async () => {
+    const now = Date.now();
+    (authStorage.getOAuthProviders as ReturnType<typeof vi.fn>).mockReturnValue([
+      { id: "anthropic", name: "Anthropic" },
+    ]);
+    (authStorage.hasAuth as ReturnType<typeof vi.fn>).mockImplementation((provider: string) => provider === "anthropic-subscription");
+    (authStorage.get as ReturnType<typeof vi.fn>).mockImplementation((provider: string) => provider === "anthropic" ? ({
+      type: "oauth",
+      access: "expired-legacy-token",
+      refresh: "revoked-refresh-token",
+      expires: now - 60_000,
+    }) : undefined);
+    (authStorage.getApiKey as ReturnType<typeof vi.fn>).mockResolvedValue(undefined);
+
+    const res = await GET(app, "/api/auth/status");
+
+    expect(res.status).toBe(200);
+    const anthropic = res.body.providers.find((p: any) => p.id === "anthropic-subscription");
+    expect(authStorage.getApiKey).toHaveBeenCalledWith("anthropic-subscription");
+    expect(anthropic).toMatchObject({ authenticated: false, expired: true });
+  });
+
+  it("FN-7574: treats an oauth credential missing a numeric expires as expired, not authenticated", async () => {
+    (authStorage.getOAuthProviders as ReturnType<typeof vi.fn>).mockReturnValue([
+      { id: "anthropic", name: "Anthropic" },
+    ]);
+    (authStorage.hasAuth as ReturnType<typeof vi.fn>).mockImplementation((provider: string) => provider === "anthropic-subscription");
+    (authStorage.get as ReturnType<typeof vi.fn>).mockImplementation((provider: string) => provider === "anthropic-subscription" ? ({
+      type: "oauth",
+      access: "token-without-expiry",
+      refresh: "refresh",
+      // expires intentionally omitted — a partially-hydrated/corrupted credential.
+    }) : undefined);
+    (authStorage.getApiKey as ReturnType<typeof vi.fn>).mockResolvedValue(undefined);
+
+    const res = await GET(app, "/api/auth/status");
+
+    expect(res.status).toBe(200);
+    const anthropic = res.body.providers.find((p: any) => p.id === "anthropic-subscription");
+    expect(anthropic).toMatchObject({ authenticated: false, expired: true });
+  });
+
   it("reports loginInProgress for oauth providers with active logins", async () => {
     let releaseLogin: (() => void) | undefined;
     (authStorage.login as ReturnType<typeof vi.fn>).mockImplementation(
diff --git a/packages/dashboard/src/routes/register-auth-routes.ts b/packages/dashboard/src/routes/register-auth-routes.ts
index 503b3c30fc..2e04baf7ff 100644
--- a/packages/dashboard/src/routes/register-auth-routes.ts
+++ b/packages/dashboard/src/routes/register-auth-routes.ts
@@ -82,11 +82,34 @@ export const registerAuthRoutes: ApiRouteRegistrar = (ctx) => {
     return undefined;
   }
 
+  /*
+  FNXC:ProviderAuth 2026-07-05-00:00:
+  FN-7574: an expired-and-unrefreshable subscription OAuth credential was reported as
+  `authenticated:true` on the settings card and never surfaced the re-login banner,
+  even though OAuthExpiryMonitor (engine side) had already fired the oauth-token-expired
+  notification for the same credential. Root cause enumerated in task notes: a stored
+  OAuth-typed credential with a missing/non-numeric `expires` field was previously
+  treated as "not expired" here, while `resolveOAuthApiKey`/`getApiKey` in
+  packages/engine/src/auth-storage.ts already treat a missing numeric `expires` as
+  unusable (never yields a runtime key). Make the status predicate fail-safe: a stored
+  OAuth credential without a usable numeric expiry now reports `expired:true` (shows as
+  not-connected) rather than silently claiming a live session it cannot actually use.
+  OAuthExpiryMonitor intentionally keeps its separate skip-and-don't-notify behavior for
+  unknown-expiry credentials (see oauth-expiry-monitor.ts) — the notification channel
+  should stay conservative about spamming, while this "are you logged in" status surface
+  should stay conservative about claiming a live session.
+  */
   function isExpiredOauthCredential(providerId: string, storage: AuthStorageLike): boolean {
     const credential = getOauthStatusCredential(providerId, storage);
-    if (!credential || typeof credential.expires !== "number") {
+    if (!credential) {
       return false;
     }
+    if (typeof credential.expires !== "number" || !Number.isFinite(credential.expires)) {
+      // A stored OAuth credential with no usable expiry can never mint a runtime API
+      // key (see resolveOAuthApiKey in auth-storage.ts), so treat it as expired rather
+      // than authenticated.
+      return true;
+    }
 
     return Date.now() >= credential.expires;
   }
diff --git a/packages/engine/src/__tests__/auth-storage.test.ts b/packages/engine/src/__tests__/auth-storage.test.ts
index 01875d737a..168254e7d4 100644
--- a/packages/engine/src/__tests__/auth-storage.test.ts
+++ b/packages/engine/src/__tests__/auth-storage.test.ts
@@ -392,6 +392,66 @@ describe("createFusionAuthStorage", () => {
       expect(persisted.anthropic).toBeUndefined();
     });
 
+    /*
+    FNXC:ClaudeOAuth 2026-07-05-00:00:
+    FN-7574 symptom verification: a healthy subscription OAuth credential that is still
+    within its validity window but nearing expiry must be refreshed proactively —
+    BEFORE it actually expires — the first time something reads it (e.g. the periodic
+    OAuthRefreshScheduler tick), not only reactively once it has already lapsed.
+    */
+    it("proactively refreshes subscription OAuth nearing expiry, ahead of actual expiration", async () => {
+      const now = Date.now();
+      writeFusionAuth(homeDir, {
+        "anthropic-subscription": {
+          type: "oauth",
+          access: "soon-to-expire-access-token",
+          refresh: "subscription-refresh-token",
+          // Still valid for another 2 minutes — inside the widened proactive-refresh
+          // window, but not yet actually expired.
+          expires: now + 120_000,
+        },
+      });
+
+      const fetchMock = vi.fn().mockResolvedValue({
+        ok: true,
+        json: async () => ({
+          access_token: "proactively-refreshed-access-token",
+          refresh_token: "rotated-refresh-token",
+          expires_in: 3600,
+        }),
+      } as Response);
+      globalThis.fetch = fetchMock as typeof fetch;
+
+      const authStorage = createFusionAuthStorage();
+
+      expect(await authStorage.getApiKey("anthropic-subscription")).toBe("proactively-refreshed-access-token");
+      expect(fetchMock).toHaveBeenCalledTimes(1);
+      const refreshed = authStorage.get("anthropic-subscription");
+      expect(refreshed).toMatchObject({ access: "proactively-refreshed-access-token" });
+      expect((refreshed as { expires: number }).expires).toBeGreaterThan(now + 120_000);
+    });
+
+    it("does not proactively refresh subscription OAuth that is not yet within the refresh window", async () => {
+      const now = Date.now();
+      writeFusionAuth(homeDir, {
+        "anthropic-subscription": {
+          type: "oauth",
+          access: "still-fresh-access-token",
+          refresh: "subscription-refresh-token",
+          // Comfortably outside the proactive-refresh buffer.
+          expires: now + 3_600_000,
+        },
+      });
+
+      const fetchMock = vi.fn();
+      globalThis.fetch = fetchMock as unknown as typeof fetch;
+
+      const authStorage = createFusionAuthStorage();
+
+      expect(await authStorage.getApiKey("anthropic-subscription")).toBe("still-fresh-access-token");
+      expect(fetchMock).not.toHaveBeenCalled();
+    });
+
     it("does not resurrect stale Anthropic subscription OAuth after failed refresh", async () => {
       writeFusionAuth(homeDir, {
         "anthropic-subscription": {
diff --git a/packages/engine/src/auth-storage.ts b/packages/engine/src/auth-storage.ts
index 7a185e1ba3..d8d1486c79 100644
--- a/packages/engine/src/auth-storage.ts
+++ b/packages/engine/src/auth-storage.ts
@@ -16,7 +16,19 @@ import type { OAuthCredentials } from "@earendil-works/pi-ai/oauth";
 
 type StoredCredential = StoredAuthCredential;
 
-const OAUTH_REFRESH_BUFFER_MS = 60_000;
+/*
+FNXC:ClaudeOAuth 2026-07-05-00:00:
+FN-7574: a 60s reactive refresh buffer meant a healthy Anthropic subscription token was
+only ever refreshed a few seconds before (or after) it actually expired — too late to
+reliably beat a slow/failed network round trip, so subscriptions routinely lapsed and
+forced a manual re-login even though the refresh token was still valid. Widen the
+proactive-refresh window to 5 minutes so both the reactive getApiKey() path AND the new
+background OAuthRefreshScheduler (see notification/oauth-refresh-scheduler.ts) renew the
+access token well ahead of expiry, without refreshing needlessly often (the scheduler
+runs on a multi-minute interval, and the in-flight dedupe + failure cooldown below still
+apply so a single stuck token doesn't get hammered).
+*/
+const OAUTH_REFRESH_BUFFER_MS = 5 * 60_000;
 const ANTHROPIC_PROVIDER_ID = "anthropic";
 const ANTHROPIC_SUBSCRIPTION_PROVIDER_ID = "anthropic-subscription";
 const ANTHROPIC_TOKEN_ENDPOINT = "https://platform.claude.com/v1/oauth/token";
diff --git a/packages/engine/src/notification/__tests__/oauth-refresh-scheduler.test.ts b/packages/engine/src/notification/__tests__/oauth-refresh-scheduler.test.ts
new file mode 100644
index 0000000000..fcabc23dd9
--- /dev/null
+++ b/packages/engine/src/notification/__tests__/oauth-refresh-scheduler.test.ts
@@ -0,0 +1,141 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { OAuthRefreshScheduler } from "../oauth-refresh-scheduler.js";
+
+describe("OAuthRefreshScheduler", () => {
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it("proactively refreshes an OAuth credential nearing expiry via getApiKey", async () => {
+    const now = Date.now();
+    const credentials: Record<string, { type: string; access: string; refresh: string; expires: number }> = {
+      anthropic: { type: "oauth", access: "old-token", refresh: "refresh", expires: now + 60_000 },
+    };
+
+    const getApiKey = vi.fn(async (providerId: string) => {
+      const cred = credentials[providerId];
+      if (!cred) return undefined;
+      // Simulate the real auth-storage.ts refresh-if-due behavior: rotates the token
+      // and pushes expiry forward when getApiKey is called while near expiry.
+      credentials[providerId] = { ...cred, access: "rotated-token", expires: now + 3_600_000 };
+      return "rotated-token";
+    });
+
+    const authStorage = {
+      reload: vi.fn(),
+      getOAuthProviders: vi.fn(() => [{ id: "anthropic", name: "Anthropic" }]),
+      get: vi.fn((providerId: string) => credentials[providerId]),
+      getApiKey,
+    };
+
+    const scheduler = new OAuthRefreshScheduler({ authStorage, clock: () => now });
+    await scheduler.start();
+    scheduler.stop();
+
+    expect(getApiKey).toHaveBeenCalledWith("anthropic");
+    expect(getApiKey).toHaveBeenCalledWith("anthropic-subscription");
+    expect(credentials.anthropic.expires).toBe(now + 3_600_000);
+  });
+
+  it("also attempts refresh for the anthropic-subscription alias even though it is never returned by getOAuthProviders", async () => {
+    const now = Date.now();
+    const credentials: Record<string, { type: string; access: string; refresh: string; expires: number }> = {
+      "anthropic-subscription": { type: "oauth", access: "old-token", refresh: "refresh", expires: now + 30_000 },
+    };
+
+    const getApiKey = vi.fn(async (providerId: string) => {
+      const cred = credentials[providerId];
+      if (!cred) return undefined;
+      credentials[providerId] = { ...cred, access: "rotated", expires: now + 3_600_000 };
+      return "rotated";
+    });
+
+    const authStorage = {
+      reload: vi.fn(),
+      getOAuthProviders: vi.fn(() => [{ id: "anthropic", name: "Anthropic" }]),
+      get: vi.fn((providerId: string) => credentials[providerId]),
+      getApiKey,
+    };
+
+    const scheduler = new OAuthRefreshScheduler({ authStorage, clock: () => now });
+    await scheduler.start();
+    scheduler.stop();
+
+    expect(getApiKey).toHaveBeenCalledWith("anthropic-subscription");
+    expect(credentials["anthropic-subscription"].expires).toBe(now + 3_600_000);
+  });
+
+  it("attempts a cheap no-op refresh for a provider with no stored oauth credential", async () => {
+    const authStorage = {
+      reload: vi.fn(),
+      getOAuthProviders: vi.fn(() => [{ id: "github-copilot", name: "GitHub Copilot" }]),
+      get: vi.fn(() => undefined),
+      getApiKey: vi.fn(async () => undefined),
+    };
+
+    const scheduler = new OAuthRefreshScheduler({ authStorage });
+    await scheduler.start();
+    scheduler.stop();
+
+    // getApiKey() is a cheap no-op for a provider with no stored credential, so the
+    // scheduler still calls it (rather than special-casing "no credential yet") but
+    // there's nothing to refresh.
+    expect(authStorage.getApiKey).toHaveBeenCalledWith("github-copilot");
+  });
+
+  it("swallows per-provider refresh failures and continues with other providers", async () => {
+    const now = Date.now();
+    const credentials: Record<string, { type: string; access: string; refresh: string; expires: number }> = {
+      "anthropic-subscription": { type: "oauth", access: "old-token", refresh: "refresh", expires: now + 30_000 },
+      github: { type: "oauth", access: "gh-token", refresh: "gh-refresh", expires: now + 30_000 },
+    };
+
+    const getApiKey = vi.fn(async (providerId: string) => {
+      if (providerId === "anthropic" || providerId === "anthropic-subscription") {
+        throw new Error("revoked refresh token");
+      }
+      const cred = credentials[providerId];
+      if (!cred) return undefined;
+      credentials[providerId] = { ...cred, expires: now + 3_600_000 };
+      return "rotated";
+    });
+
+    const authStorage = {
+      reload: vi.fn(),
+      getOAuthProviders: vi.fn(() => [
+        { id: "anthropic", name: "Anthropic" },
+        { id: "github", name: "GitHub" },
+      ]),
+      get: vi.fn((providerId: string) => credentials[providerId]),
+      getApiKey,
+    };
+
+    const scheduler = new OAuthRefreshScheduler({ authStorage, clock: () => now });
+    await expect(scheduler.start()).resolves.toBeUndefined();
+    scheduler.stop();
+
+    expect(credentials.github.expires).toBe(now + 3_600_000);
+  });
+
+  it("reloads auth storage and repeats on its interval", async () => {
+    vi.useFakeTimers();
+    const now = Date.now();
+    const authStorage = {
+      reload: vi.fn(),
+      getOAuthProviders: vi.fn(() => [{ id: "github-copilot", name: "GitHub Copilot" }]),
+      get: vi.fn(() => undefined),
+      getApiKey: vi.fn(async () => undefined),
+    };
+
+    const scheduler = new OAuthRefreshScheduler({ authStorage, intervalMs: 1_000, clock: () => now });
+    await scheduler.start();
+    expect(authStorage.reload).toHaveBeenCalledTimes(1);
+
+    await vi.advanceTimersByTimeAsync(1_000);
+    expect(authStorage.reload).toHaveBeenCalledTimes(2);
+
+    scheduler.stop();
+    await vi.advanceTimersByTimeAsync(5_000);
+    expect(authStorage.reload).toHaveBeenCalledTimes(2);
+  });
+});
diff --git a/packages/engine/src/notification/index.ts b/packages/engine/src/notification/index.ts
index 549020023d..91d13128f2 100644
--- a/packages/engine/src/notification/index.ts
+++ b/packages/engine/src/notification/index.ts
@@ -14,3 +14,6 @@ export { OAuthExpiryMonitor } from "./oauth-expiry-monitor.js";
 export type { AuthStorageLike as OAuthExpiryAuthStorageLike, OAuthExpiryMonitorOptions } from "./oauth-expiry-monitor.js";
 
 export { OAuthValidityLogger } from "./oauth-validity-logger.js";
+
+export { OAuthRefreshScheduler } from "./oauth-refresh-scheduler.js";
+export type { OAuthRefreshAuthStorageLike, OAuthRefreshSchedulerOptions } from "./oauth-refresh-scheduler.js";
diff --git a/packages/engine/src/notification/oauth-refresh-scheduler.ts b/packages/engine/src/notification/oauth-refresh-scheduler.ts
new file mode 100644
index 0000000000..df4529ee6c
--- /dev/null
+++ b/packages/engine/src/notification/oauth-refresh-scheduler.ts
@@ -0,0 +1,143 @@
+import { schedulerLog } from "../logger.js";
+
+/*
+FNXC:ClaudeOAuth 2026-07-05-00:00:
+FN-7574: healthy subscriptions must not lapse waiting for a reactive refresh. A stored
+OAuth credential's access token was previously only ever refreshed when something
+actively requested a runtime API key (model execution, or the dashboard's best-effort
+refresh-on-expiry check) — if nothing asked for a key in the window between "about to
+expire" and "expired", the token simply expired and forced a manual re-login.
+
+OAuthRefreshScheduler runs as an independent, engine-side background loop (separate from
+OAuthExpiryMonitor's detect-and-notify concern, per the task's File Scope "pick ONE and
+justify": keeping detection/notification and refresh as separate, independently
+toggleable responsibilities is easier to test and reason about than folding a refresh
+side effect into the monitor's `check()`). On each tick it reloads auth storage and asks
+for a fresh API key for every known OAuth provider (plus the Anthropic subscription
+alias); `authStorage.getApiKey(id)` already contains the refresh-if-due logic — see
+`shouldRefreshOAuthCredential`/`refreshProviderOAuthCredential` in `auth-storage.ts` — so
+this scheduler deliberately reuses that instead of duplicating the token HTTP call.
+
+Never logs or persists access/refresh token material: only `providerId`, `providerName`,
+and `expiresAt` (ISO) are ever referenced for observability.
+*/
+
+const DEFAULT_INTERVAL_MS = 5 * 60_000;
+
+const ANTHROPIC_OAUTH_PROVIDER_ID = "anthropic";
+const ANTHROPIC_SUBSCRIPTION_PROVIDER_ID = "anthropic-subscription";
+
+interface OAuthProviderInfo {
+  id: string;
+  name: string;
+}
+
+interface OAuthCredential {
+  type?: string;
+  expires?: number;
+}
+
+export interface OAuthRefreshAuthStorageLike {
+  reload?(): void;
+  getOAuthProviders?(): OAuthProviderInfo[];
+  get?(providerId: string): OAuthCredential | undefined;
+  getApiKey?(providerId: string): Promise<string | null | undefined> | string | null | undefined;
+}
+
+export interface OAuthRefreshSchedulerOptions {
+  authStorage: OAuthRefreshAuthStorageLike;
+  intervalMs?: number;
+  clock?: () => number;
+}
+
+export class OAuthRefreshScheduler {
+  private readonly intervalMs: number;
+  private readonly clock: () => number;
+  private timer: NodeJS.Timeout | null = null;
+
+  constructor(private readonly opts: OAuthRefreshSchedulerOptions) {
+    this.intervalMs = opts.intervalMs ?? DEFAULT_INTERVAL_MS;
+    this.clock = opts.clock ?? Date.now;
+  }
+
+  async start(): Promise<void> {
+    if (this.timer) {
+      return;
+    }
+
+    await this.tick();
+    this.timer = setInterval(() => {
+      void this.tick();
+    }, this.intervalMs);
+    this.timer.unref?.();
+  }
+
+  stop(): void {
+    if (!this.timer) {
+      return;
+    }
+
+    clearInterval(this.timer);
+    this.timer = null;
+  }
+
+  private getRefreshCandidateIds(providers: OAuthProviderInfo[]): string[] {
+    const ids = new Set<string>();
+    for (const provider of providers) {
+      ids.add(provider.id);
+      if (provider.id === ANTHROPIC_OAUTH_PROVIDER_ID) {
+        // The dashboard-facing subscription alias is stored/refreshed under its own id
+        // (see selectAnthropicSubscriptionCredential in auth-storage.ts) and is never
+        // returned by getOAuthProviders() itself, so it must be attempted explicitly.
+        ids.add(ANTHROPIC_SUBSCRIPTION_PROVIDER_ID);
+      }
+    }
+    return Array.from(ids);
+  }
+
+  private async tick(): Promise<void> {
+    this.opts.authStorage.reload?.();
+
+    const providers = this.opts.authStorage.getOAuthProviders?.();
+    if (!providers?.length || !this.opts.authStorage.getApiKey) {
+      return;
+    }
+
+    for (const providerId of this.getRefreshCandidateIds(providers)) {
+      try {
+        const before = this.opts.authStorage.get?.(providerId);
+        const beforeExpires = before?.type === "oauth" && typeof before.expires === "number" && Number.isFinite(before.expires)
+          ? before.expires
+          : undefined;
+
+        /*
+        FNXC:ClaudeOAuth 2026-07-05-00:00:
+        Always attempt getApiKey() for every known oauth-provider id (rather than
+        pre-filtering on whether this scheduler's own `get()` snapshot already shows a
+        credential): the Anthropic subscription alias legitimately resolves through a
+        legacy-row fallback inside auth-storage.ts's own selection logic, so a naive
+        "skip if this exact id has no direct row" check would silently skip refreshing
+        a legacy-row subscription credential. getApiKey() is a cheap no-op when no
+        credential exists for that id (see resolveStoredCredentialApiKey/getApiKey).
+        */
+        await this.opts.authStorage.getApiKey(providerId);
+
+        const after = this.opts.authStorage.get?.(providerId);
+        if (
+          after?.type === "oauth"
+          && typeof after.expires === "number"
+          && Number.isFinite(after.expires)
+          && (beforeExpires === undefined || after.expires > beforeExpires)
+        ) {
+          const providerName = providers.find((p) => p.id === providerId)?.name ?? providerId;
+          schedulerLog.log(
+            `OAuth credential proactively refreshed provider=${providerId} name=${providerName} expiresAt=${new Date(after.expires).toISOString()}`,
+          );
+        }
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        schedulerLog.warn(`OAuth proactive refresh failed provider=${providerId}: ${message}`);
+      }
+    }
+  }
+}
diff --git a/packages/engine/src/project-engine.ts b/packages/engine/src/project-engine.ts
index 2ee050dbd5..6e87f913c9 100644
--- a/packages/engine/src/project-engine.ts
+++ b/packages/engine/src/project-engine.ts
@@ -48,7 +48,7 @@ import type { PrNodeGithubOps } from "./pr-nodes.js";
 import { PrReconciler, type PrReconcileGithubOps } from "./pr-reconcile.js";
 import { PrCommentHandler } from "./pr-comment-handler.js";
 import { NtfyNotifier } from "./notifier.js";
-import { NotificationService, OAuthAlertStateStore, OAuthExpiryMonitor, OAuthValidityLogger } from "./notification/index.js";
+import { NotificationService, OAuthAlertStateStore, OAuthExpiryMonitor, OAuthRefreshScheduler, OAuthValidityLogger } from "./notification/index.js";
 import type { NotificationChatStore } from "./notification/notification-service.js";
 import { GridlockDetector } from "./gridlock-detector.js";
 import { createFusionAuthStorage, getFusionOAuthAlertStatePath } from "./auth-storage.js";
@@ -396,6 +396,7 @@ export class ProjectEngine {
   private notifier?: NtfyNotifier;
   private notificationService?: NotificationService;
   private oauthExpiryMonitor?: OAuthExpiryMonitor;
+  private oauthRefreshScheduler?: OAuthRefreshScheduler;
   private oauthValidityLogger?: OAuthValidityLogger;
   private gridlockDetector?: GridlockDetector;
   private cronRunner?: CronRunner;
@@ -721,6 +722,16 @@ export class ProjectEngine {
         alertState: oauthAlertState,
       });
       await this.oauthExpiryMonitor.start();
+      /*
+      FNXC:ClaudeOAuth 2026-07-05-00:00:
+      FN-7574: proactively refresh OAuth access tokens ahead of expiry (widened window,
+      see OAUTH_REFRESH_BUFFER_MS in auth-storage.ts) so a healthy subscription session
+      never lapses waiting for something else to request a runtime API key. Reuses the
+      same authStorage instance as OAuthExpiryMonitor above so detection/notification and
+      proactive refresh observe a consistent, single credential source.
+      */
+      this.oauthRefreshScheduler = new OAuthRefreshScheduler({ authStorage });
+      await this.oauthRefreshScheduler.start();
       this.oauthValidityLogger = new OAuthValidityLogger({
         authStorage,
         alertState: oauthAlertState,
@@ -954,6 +965,7 @@ export class ProjectEngine {
     this.prReconciler?.stopAll();
     this.prReconciler = undefined;
     this.oauthExpiryMonitor?.stop();
+    this.oauthRefreshScheduler?.stop();
     this.oauthValidityLogger?.stop();
     this.notificationService?.stop();
     this.notifier?.stop();

From 196abb5af96dfb749526184bb03da31719d79f71 Mon Sep 17 00:00:00 2001
From: gsxdsm <gsxdsm@users.noreply.github.com>
Date: Sun, 5 Jul 2026 09:14:03 -0700
Subject: [PATCH 21/65] FN-7576: delegate anthropic-subscription getApiKey to
 engine authStorage

Reads for the anthropic-subscription provider now delegate to the real engine authStorage so expired OAuth tokens are refreshed instead of silently failing.

- mergeAuthStorageReads getApiKey("anthropic-subscription") now calls target.getApiKey(providerId) directly, triggering the engine's refresh-token HTTP round trip, instead of a local static Date.now() >= credential.expires check
- Falls back to the read-only fallback storages' local resolution only when the primary engine call yields no key
- Added regression tests exercising the wrapper directly against the engine delegation and fallback behavior
- Added a patch changeset documenting the fix for @runfusion/fusion

Files changed:
 .changeset/fn-7576-cli-wrapper-subscription-getapikey-delegation.md               |   7 +
 packages/cli/src/commands/__tests__/provider-auth.test.ts                         | 148 +++++++++++++++++++++
 packages/cli/src/commands/provider-auth.ts                                        |  12 +-
 3 files changed, 166 insertions(+), 1 deletion(-)

Fusion-Task-Id: FN-7576

Fusion-Task-Lineage: 31e495ec-8487-468b-9b80-36e8d0f53806

Co-authored-by: Fusion (runfusion.ai) <noreply@runfusion.ai>
---
 ...apper-subscription-getapikey-delegation.md |   7 +
 .../commands/__tests__/provider-auth.test.ts  | 148 ++++++++++++++++++
 packages/cli/src/commands/provider-auth.ts    |  12 +-
 3 files changed, 166 insertions(+), 1 deletion(-)
 create mode 100644 .changeset/fn-7576-cli-wrapper-subscription-getapikey-delegation.md

diff --git a/.changeset/fn-7576-cli-wrapper-subscription-getapikey-delegation.md b/.changeset/fn-7576-cli-wrapper-subscription-getapikey-delegation.md
new file mode 100644
index 0000000000..c0cd7d259c
--- /dev/null
+++ b/.changeset/fn-7576-cli-wrapper-subscription-getapikey-delegation.md
@@ -0,0 +1,7 @@
+---
+"@runfusion/fusion": patch
+---
+
+summary: Anthropic subscription reads now refresh the OAuth token automatically instead of silently failing when expired.
+category: fix
+dev: mergeAuthStorageReads getApiKey("anthropic-subscription") now delegates to the underlying engine authStorage.getApiKey (the only refresh-token HTTP round trip) instead of a local static expiry check; regression tests drive the wrapper directly. No token material logged.
diff --git a/packages/cli/src/commands/__tests__/provider-auth.test.ts b/packages/cli/src/commands/__tests__/provider-auth.test.ts
index e46157e65c..d706cb825a 100644
--- a/packages/cli/src/commands/__tests__/provider-auth.test.ts
+++ b/packages/cli/src/commands/__tests__/provider-auth.test.ts
@@ -585,4 +585,152 @@ describe("wrapAuthStorageWithApiKeyProviders", () => {
       expect(merged.has("anthropic")).toBe(false);
     });
   });
+
+  describe("anthropic-subscription getApiKey delegation (FN-7576)", () => {
+    /*
+    FNXC:ProviderAuth 2026-07-05-09:15:
+    These tests drive `wrapAuthStorageWithApiKeyProviders`/`mergeAuthStorageReads` directly against an instrumented fake engine `authStorage.getApiKey`, not a mocked dashboard/engine `AuthStorageLike`, per FN-7576's "fix the invariant, not the repro" requirement. They assert the wrapper actually DELEGATES the anthropic-subscription read to the real engine authStorage (so the refresh HTTP round trip in packages/engine/src/auth-storage.ts executes) rather than short-circuiting to a local static `Date.now() >= credential.expires` check.
+    */
+    const PAST_EXPIRY = Date.now() - 60_000;
+
+    it("delegates to the underlying engine authStorage.getApiKey and returns the refreshed key even when the stored credential is expired", async () => {
+      const fusionAuth = makeAuthStorage({
+        "anthropic-subscription": {
+          type: "oauth",
+          access: "stale-oauth-access",
+          refresh: "stale-oauth-refresh",
+          expires: PAST_EXPIRY,
+        },
+      });
+      fusionAuth.getApiKey = vi.fn(async (provider: string) =>
+        provider === "anthropic-subscription" ? "refreshed-oauth-access" : undefined,
+      );
+      const modelRegistry = { getAll: vi.fn(() => []) } as any;
+
+      const wrapped = wrapAuthStorageWithApiKeyProviders(fusionAuth, modelRegistry);
+      const apiKey = await wrapped.getApiKey("anthropic-subscription");
+
+      expect(fusionAuth.getApiKey).toHaveBeenCalledWith("anthropic-subscription");
+      expect(apiKey).toBe("refreshed-oauth-access");
+    });
+
+    it("delegates via the mergeAuthStorageReads proxy directly", async () => {
+      const fusionAuth = makeAuthStorage({
+        "anthropic-subscription": {
+          type: "oauth",
+          access: "stale-oauth-access",
+          refresh: "stale-oauth-refresh",
+          expires: PAST_EXPIRY,
+        },
+      });
+      fusionAuth.getApiKey = vi.fn(async (provider: string) =>
+        provider === "anthropic-subscription" ? "refreshed-oauth-access" : undefined,
+      );
+
+      const merged = mergeAuthStorageReads(fusionAuth);
+      const apiKey = await merged.getApiKey("anthropic-subscription");
+
+      expect(fusionAuth.getApiKey).toHaveBeenCalledWith("anthropic-subscription");
+      expect(apiKey).toBe("refreshed-oauth-access");
+    });
+
+    it("delegates and returns the refreshed key when OAuth is stored under the legacy anthropic row", async () => {
+      const fusionAuth = makeAuthStorage({
+        anthropic: {
+          type: "oauth",
+          access: "legacy-stale-oauth-access",
+          refresh: "legacy-stale-oauth-refresh",
+          expires: PAST_EXPIRY,
+        },
+      });
+      fusionAuth.getApiKey = vi.fn(async (provider: string) =>
+        provider === "anthropic-subscription" ? "refreshed-oauth-access" : undefined,
+      );
+      const modelRegistry = { getAll: vi.fn(() => []) } as any;
+
+      const wrapped = wrapAuthStorageWithApiKeyProviders(fusionAuth, modelRegistry);
+      const apiKey = await wrapped.getApiKey("anthropic-subscription");
+
+      expect(fusionAuth.getApiKey).toHaveBeenCalledWith("anthropic-subscription");
+      expect(apiKey).toBe("refreshed-oauth-access");
+    });
+
+    it("does not call the delegated engine getApiKey and returns undefined once the subscription is logged out", async () => {
+      const fusionAuth = makeAuthStorage({
+        "anthropic-subscription": {
+          type: "oauth",
+          access: "oauth-access",
+          refresh: "oauth-refresh",
+          expires: Date.now() + 60_000,
+        },
+      });
+      fusionAuth.getApiKey = vi.fn(async (provider: string) =>
+        provider === "anthropic-subscription" ? "refreshed-oauth-access" : undefined,
+      );
+      const modelRegistry = { getAll: vi.fn(() => []) } as any;
+
+      const wrapped = wrapAuthStorageWithApiKeyProviders(fusionAuth, modelRegistry);
+      wrapped.logout("anthropic-subscription");
+      fusionAuth.getApiKey.mockClear();
+
+      const apiKey = await wrapped.getApiKey("anthropic-subscription");
+
+      expect(apiKey).toBeUndefined();
+      expect(fusionAuth.getApiKey).not.toHaveBeenCalledWith("anthropic-subscription");
+    });
+
+    it("returns undefined when no credential is stored and the engine authStorage has nothing to refresh", async () => {
+      const fusionAuth = makeAuthStorage();
+      const modelRegistry = { getAll: vi.fn(() => []) } as any;
+
+      const wrapped = wrapAuthStorageWithApiKeyProviders(fusionAuth, modelRegistry);
+      const apiKey = await wrapped.getApiKey("anthropic-subscription");
+
+      expect(apiKey).toBeUndefined();
+    });
+
+    it("falls back to a read-only fallback storage's local resolution only when the primary engine yields no key", async () => {
+      const fusionAuth = makeAuthStorage({
+        "anthropic-subscription": {
+          type: "oauth",
+          access: "stale-oauth-access",
+          refresh: "stale-oauth-refresh",
+          expires: PAST_EXPIRY,
+        },
+      });
+      // Primary engine authStorage genuinely cannot refresh (e.g. refresh token invalid/absent upstream).
+      fusionAuth.getApiKey = vi.fn(async () => undefined);
+      const fallbackAuth = makeAuthStorage({
+        "anthropic-subscription": {
+          type: "oauth",
+          access: "fallback-still-valid-access",
+          refresh: "fallback-refresh",
+          expires: Date.now() + 60_000,
+        },
+      });
+      fallbackAuth.getApiKey = vi.fn(async (provider: string) =>
+        provider === "anthropic-subscription" ? "fallback-still-valid-access" : undefined,
+      );
+      const modelRegistry = { getAll: vi.fn(() => []) } as any;
+
+      const wrapped = wrapAuthStorageWithApiKeyProviders(fusionAuth, modelRegistry, [fallbackAuth]);
+      const apiKey = await wrapped.getApiKey("anthropic-subscription");
+
+      expect(fusionAuth.getApiKey).toHaveBeenCalledWith("anthropic-subscription");
+      expect(apiKey).toBe("fallback-still-valid-access");
+    });
+
+    it("still resolves non-subscription providers exactly as before (no regression)", async () => {
+      const fusionAuth = makeAuthStorage({
+        openrouter: { type: "api_key", key: "fusion-openrouter-key" },
+        anthropic: { type: "api_key", key: "sk-ant-api03-raw-key" },
+      });
+      const modelRegistry = { getAll: vi.fn(() => []) } as any;
+
+      const wrapped = wrapAuthStorageWithApiKeyProviders(fusionAuth, modelRegistry);
+
+      expect(await wrapped.getApiKey("openrouter")).toBe("fusion-openrouter-key");
+      expect(await wrapped.getApiKey("anthropic-api-key")).toBe("sk-ant-api03-raw-key");
+    });
+  });
 });
diff --git a/packages/cli/src/commands/provider-auth.ts b/packages/cli/src/commands/provider-auth.ts
index ace07aee83..2f7d445905 100644
--- a/packages/cli/src/commands/provider-auth.ts
+++ b/packages/cli/src/commands/provider-auth.ts
@@ -415,7 +415,17 @@ export function mergeAuthStorageReads(
             return credential?.type === "api_key" ? resolveStoredApiKey(credential.key) : undefined;
           }
           if (providerId === ANTHROPIC_SUBSCRIPTION_STORAGE_PROVIDER_ID && credential) {
-            return resolveStoredCredentialApiKey(providerId, credential);
+            /*
+            FNXC:ProviderAuth 2026-07-05-09:10:
+            Reading `anthropic-subscription` through this merge proxy must delegate to the underlying real engine `authStorage.getApiKey(...)` (the `target` primary storage) so the refresh-token HTTP round trip in packages/engine/src/auth-storage.ts actually runs. The prior local static `Date.now() >= credential.expires` check (`resolveStoredCredentialApiKey`/`resolveOAuthApiKey`) never called the real engine and silently no-oped the refresh in production, e.g. the dashboard status route's best-effort refresh-on-expiry read (register-auth-routes.ts). `target.getApiKey` internally handles both the separated `anthropic-subscription` row and the legacy `anthropic` OAuth row, so this single delegated call covers both storage permutations without duplicating that logic here. Only fall back to the read-only fallback storages' local (non-refreshing) resolution when the primary engine yields no key; a logged-out subscription is already excluded above and must never reach this delegated call.
+            */
+            const engineApiKey = await target.getApiKey(providerId);
+            if (engineApiKey) return engineApiKey;
+            for (const fallbackStorage of readFallbackAuthStorages) {
+              const fallbackApiKey = await fallbackStorage.getApiKey(providerId);
+              if (fallbackApiKey) return fallbackApiKey;
+            }
+            return undefined;
           }
           for (const storage of readAuthStorages) {
             const apiKey = await storage.getApiKey(providerId);

From b471aece6a96099d7367bc734ba5fa67ea01dc06 Mon Sep 17 00:00:00 2001
From: gsxdsm <gsxdsm@users.noreply.github.com>
Date: Sun, 5 Jul 2026 09:25:51 -0700
Subject: [PATCH 22/65] fix(FN-7560): stop release-auth gate flagging tasks
 that disclaim releasing
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The release-authorization classifier substring-matched release signals
(notably `scripts/release.mjs`) even inside disclaimer clauses that
explicitly say the task performs NO release/publish. AI-authored specs
routinely append such disclaimers, so revert/undo/UI tasks (FN-7525,
FN-7554, FN-7556) were parked in awaiting-release-authorization with no
in-band exit — their non-user sources (agent_heartbeat/api) make the
authorization marker inert.

classifyReleaseTask now strips negated release-disclaimer clauses before
signal matching. Genuine "run pnpm release"/"publish @runfusion/fusion"
intent lives in a non-negated clause and still trips the gate. Tests
cover all three real repro shapes plus every documented signal in both
its negated (not release-class) and actionable (still release-class) form.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 ...-release-gate-disclaimer-false-positive.md |  7 ++
 .../triage-release-authorization.test.ts      | 75 +++++++++++++++++++
 .../src/triage-release-authorization.ts       | 39 +++++++++-
 3 files changed, 119 insertions(+), 2 deletions(-)
 create mode 100644 .changeset/fn-7560-release-gate-disclaimer-false-positive.md

diff --git a/.changeset/fn-7560-release-gate-disclaimer-false-positive.md b/.changeset/fn-7560-release-gate-disclaimer-false-positive.md
new file mode 100644
index 0000000000..6ddbecef94
--- /dev/null
+++ b/.changeset/fn-7560-release-gate-disclaimer-false-positive.md
@@ -0,0 +1,7 @@
+---
+"@runfusion/fusion": patch
+---
+
+summary: Stop the release-authorization gate from holding tasks that merely disclaim releasing.
+category: fix
+dev: classifyReleaseTask now strips negated release-disclaimer clauses (e.g. "this task performs no release/publish; releases are owned by scripts/release.mjs") before signal matching in packages/engine/src/triage-release-authorization.ts, so revert/undo/UI specs are no longer false-flagged as release-class. Genuine "run pnpm release"/"publish @runfusion/fusion" intent still trips the gate.
diff --git a/packages/engine/src/__tests__/triage-release-authorization.test.ts b/packages/engine/src/__tests__/triage-release-authorization.test.ts
index bd7638eaea..8e43a08b23 100644
--- a/packages/engine/src/__tests__/triage-release-authorization.test.ts
+++ b/packages/engine/src/__tests__/triage-release-authorization.test.ts
@@ -4,6 +4,7 @@ import {
   evaluateReleaseAuthorizationGate,
   isUserAuthoredSource,
   parseReleaseAuthorizationMarker,
+  stripNegatedReleaseClauses,
 } from "../triage-release-authorization.js";
 
 const releasePrompt = `# Task: FN-6469 - Release @runfusion/fusion patch
@@ -123,6 +124,80 @@ describe("triage release authorization gate", () => {
     }
   });
 
+  /*
+   * FN-7560 regression: release disclaimers must not self-incriminate.
+   * Symptom: FN-7525/FN-7554/FN-7556 (revert/undo/UI tasks) were parked in
+   * awaiting-release-authorization solely because their AI-authored specs said
+   * they perform NO release while naming `scripts/release.mjs` as the owner.
+   * Surface enumeration below covers every documented signal in both its negated
+   * (disclaimer → not release-class) and actionable (intent → still release-class)
+   * form so the invariant holds across all known signal surfaces, not just the repro.
+   */
+  describe("negated release disclaimers are not classified as release-class (FN-7560)", () => {
+    const disclaimerRepros = [
+      // FN-7525
+      "This task does not perform any package release or publish (releases are owned by `scripts/release.mjs`).",
+      // FN-7554
+      "This task's delivery is the changeset FILE only — it performs no release/publish (`scripts/release.mjs` owns releases).",
+      // FN-7556
+      "Delivery is the changeset FILE only; this task performs no package release or publish (releases are owned by `scripts/release.mjs`).",
+    ];
+
+    for (const promptText of disclaimerRepros) {
+      it(`does not flag disclaimer: ${promptText.slice(0, 48)}…`, () => {
+        const classification = classifyReleaseTask({ promptText });
+        expect(classification.isReleaseClass, promptText).toBe(false);
+        expect(classification.signals, promptText).toEqual([]);
+      });
+    }
+
+    it("clears the awaiting-release-authorization hold for the real FN-7525 shape", () => {
+      const decision = evaluateReleaseAuthorizationGate({
+        sourceType: "agent_heartbeat",
+        title: "Add Revert/Undo affordance to Done and Archived task cards",
+        promptText:
+          "## Scope\nThis task does not perform any package release or publish (releases are owned by `scripts/release.mjs`).\n\n## Git Commit Convention\nCommits at step boundaries.",
+      });
+      expect(decision.action).toBe("allow");
+      expect(decision.isReleaseClass).toBe(false);
+    });
+  });
+
+  it("still flags genuine release intent even alongside a disclaimer clause", () => {
+    // A real release instruction lives in its own non-negated clause and must survive stripping.
+    const classification = classifyReleaseTask({
+      promptText:
+        "Run pnpm release --yes to publish @runfusion/fusion. This other task performs no release.",
+    });
+    expect(classification.isReleaseClass).toBe(true);
+    expect(classification.signals).toContain("pnpm release");
+  });
+
+  it("still flags every documented signal when phrased as an actionable instruction", () => {
+    const actionable = [
+      "Run pnpm release --yes now.",
+      "Execute node scripts/release.mjs to cut the build.",
+      "Run pnpm changeset publish to ship.",
+      "Then npm publish the @runfusion/fusion tarball.",
+      "Run pnpm publish @runfusion/fusion.",
+      "Publish the package to npm as the final step.",
+      "Create git tag v1.2.3 for the release.",
+      "Author a version bump release commit for v1.2.3.",
+    ];
+    for (const promptText of actionable) {
+      expect(classifyReleaseTask({ promptText }).isReleaseClass, promptText).toBe(true);
+    }
+  });
+
+  it("stripNegatedReleaseClauses drops disclaimer clauses but keeps actionable ones", () => {
+    const stripped = stripNegatedReleaseClauses(
+      "Run pnpm release to publish. This task performs no other release; releases are owned by scripts/release.mjs.",
+    );
+    expect(stripped).toMatch(/pnpm release/);
+    expect(stripped).not.toMatch(/scripts\/release\.mjs/);
+    expect(stripped).not.toMatch(/performs no/);
+  });
+
   it("handles empty and undefined inputs without throwing or flagging", () => {
     expect(classifyReleaseTask({})).toEqual({ isReleaseClass: false, signals: [] });
     expect(evaluateReleaseAuthorizationGate({ sourceType: undefined }).action).toBe("allow");
diff --git a/packages/engine/src/triage-release-authorization.ts b/packages/engine/src/triage-release-authorization.ts
index 0027b29fa6..c7e98307f8 100644
--- a/packages/engine/src/triage-release-authorization.ts
+++ b/packages/engine/src/triage-release-authorization.ts
@@ -42,19 +42,54 @@ const RELEASE_SIGNAL_PATTERNS: ReleaseSignalPattern[] = [
   { label: "version-bump release commit", pattern: /\b(?:version\s*bump|bump\s+version|release\s+commit|release\s+version)\b[\s\S]{0,120}\bv\d+\.\d+\.\d+\b|\bv\d+\.\d+\.\d+\b[\s\S]{0,120}\b(?:version\s*bump|bump\s+version|release\s+commit|release\s+version)\b/i },
 ];
 
+/*
+FNXC:ReleaseAuthorizationGate 2026-07-05-15:40:
+FN-7560: classifyReleaseTask matched a bare mention of a release signal (e.g. `scripts/release.mjs`) even when it appeared inside a disclaimer clause that explicitly states the task does NOT release — "this task performs no release/publish (releases are owned by `scripts/release.mjs`)". AI-authored specs routinely append such disclaimers, so revert/undo/UI tasks (FN-7525, FN-7554, FN-7556) were false-flagged as release-class and parked in awaiting-release-authorization with no in-band exit (their non-user sources make the authorization marker inert). Strip negated release-disclaimer clauses before signal matching so a spec that disclaims releasing does not self-incriminate. Genuine release intent survives because "run pnpm release" / "publish @runfusion/fusion" lives in a non-negated clause and is evaluated normally.
+*/
+const RELEASE_NEGATION_PATTERNS: RegExp[] = [
+  // "performs no release", "performs no package release/publish"
+  /\bperforms?\s+no\s+(?:[\w-]+\s+){0,3}?(?:release|publish)/i,
+  // "does not perform any package release", "will not publish", "doesn't release"
+  /\b(?:does|do|did|will|would|shall|can|could|should)(?:\s+not|n['’]?t)\b\s+(?:[\w-]+\s+){0,4}?(?:release|publish)/i,
+  // "no release/publish", "no package/actual release"
+  /\bno\s+(?:[\w-]+\s+){0,2}?(?:release|publish)\b/i,
+  // "releases are owned by scripts/release.mjs" — ownership disclaimer, not intent
+  /\breleases?\s+are\s+owned\s+by\b/i,
+  // "never release/publish"
+  /\bnever\s+(?:[\w-]+\s+){0,3}?(?:release|publish)/i,
+];
+
+/**
+ * FNXC:ReleaseAuthorizationGate 2026-07-05-15:40:
+ * Split into clause-sized segments (sentence terminators and line breaks) and
+ * drop any segment carrying a release-negation cue, keeping segments small so
+ * removing one disclaimer clause never discards an adjacent genuine release
+ * instruction. Returns the surviving text for signal matching.
+ */
+export function stripNegatedReleaseClauses(text: string): string {
+  return text
+    .split(/(?<=[.!?;])\s+|\n+/)
+    .filter((clause) => !RELEASE_NEGATION_PATTERNS.some((pattern) => pattern.test(clause)))
+    .join("\n");
+}
+
 export function isUserAuthoredSource(sourceType: string | null | undefined): boolean {
   return typeof sourceType === "string" && USER_AUTHORED_SOURCE_TYPES.has(sourceType);
 }
 
 export function classifyReleaseTask(input: ReleaseTaskClassificationInput): ReleaseTaskClassification {
-  const text = [input.title, input.description, input.promptText]
+  const rawText = [input.title, input.description, input.promptText]
     .filter((value): value is string => typeof value === "string" && value.length > 0)
     .join("\n\n");
 
-  if (!text.trim()) {
+  if (!rawText.trim()) {
     return { isReleaseClass: false, signals: [] };
   }
 
+  // Evaluate signals only against clauses that are not release disclaimers, so a
+  // spec that says "this task performs no release" is not flagged as one.
+  const text = stripNegatedReleaseClauses(rawText);
+
   const signals: string[] = [];
   for (const { label, pattern } of RELEASE_SIGNAL_PATTERNS) {
     if (pattern.test(text)) {

From 4b530a65de9c3643c8abe382873e4fa64b5464ef Mon Sep 17 00:00:00 2001
From: gsxdsm <gsxdsm@users.noreply.github.com>
Date: Sun, 5 Jul 2026 09:36:53 -0700
Subject: [PATCH 23/65] fix: restore Anthropic subscription card after
 in-session logout + re-login

Subscription OAuth is aliased across the legacy `anthropic` id (where login
persists the credential) and `anthropic-subscription` (where the settings card
and status read are keyed). After an in-session logout, re-login wrote only
`anthropic` and never cleared the in-memory `anthropic-subscription` logged-out
flag, so the card reported "Login did not complete" despite a valid stored
credential until the process restarted.

auth-storage's proxy now clears the logged-out suppression on both aliases when
either is re-authenticated (new `login` trap + hardened `set` trap via
clearReauthenticatedLogoutState); raw api_key writes stay scoped to their own
card. Also surface previously-swallowed background OAuth login failures on
GET /auth/status (`loginError`) plus server logs and a settings toast, so real
paste-callback failures are diagnosable instead of a generic error.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 ...ropic-subscription-relogin-after-logout.md |  7 +++
 packages/dashboard/app/api/legacy.ts          |  9 ++++
 .../app/components/SettingsModal.tsx          | 22 ++++++++
 .../src/routes/register-auth-routes.ts        | 23 ++++++++-
 .../engine/src/__tests__/auth-storage.test.ts | 50 +++++++++++++++++++
 packages/engine/src/auth-storage.ts           | 42 +++++++++++++++-
 6 files changed, 150 insertions(+), 3 deletions(-)
 create mode 100644 .changeset/fix-anthropic-subscription-relogin-after-logout.md

diff --git a/.changeset/fix-anthropic-subscription-relogin-after-logout.md b/.changeset/fix-anthropic-subscription-relogin-after-logout.md
new file mode 100644
index 0000000000..e6c3bb56b3
--- /dev/null
+++ b/.changeset/fix-anthropic-subscription-relogin-after-logout.md
@@ -0,0 +1,7 @@
+---
+"@runfusion/fusion": patch
+---
+
+summary: Fix Claude/Anthropic subscription re-login showing "Login did not complete" after logging out.
+category: fix
+dev: Anthropic subscription OAuth is aliased across the legacy `anthropic` row (where interactive login persists the credential) and the `anthropic-subscription` id (where the settings card's in-memory logged-out suppression and status read are keyed). Re-login wrote only `anthropic`, so `loggedOutProviders` kept suppressing `anthropic-subscription` and the card reported failure despite a valid stored credential until process restart. auth-storage's proxy now clears the logged-out state on both aliases when either is re-authenticated (new `login` trap + hardened `set` trap via `clearReauthenticatedLogoutState`; raw api_key writes stay scoped to their own card). Also surfaces background OAuth login failures on `GET /auth/status` (`loginError`) + server logs so future paste-callback failures are diagnosable instead of a generic error.
diff --git a/packages/dashboard/app/api/legacy.ts b/packages/dashboard/app/api/legacy.ts
index b7dde38529..b83b9a43cb 100644
--- a/packages/dashboard/app/api/legacy.ts
+++ b/packages/dashboard/app/api/legacy.ts
@@ -1773,6 +1773,15 @@ export interface AuthProvider {
   expired?: boolean;
   /** True when the redirect cannot reach this dashboard host and the user must paste the URL/code back manually. */
   requiresManualCode?: boolean;
+  /**
+   * Reason the most recent background OAuth login attempt failed, if any.
+   * Interactive logins resolve the auth URL immediately and finish in the
+   * background; when that background flow rejects (bad/expired code, token
+   * exchange rejection, redirect_uri mismatch) this carries the cause so the
+   * UI can show why login failed instead of a generic error. Cleared when a
+   * fresh login for the provider starts.
+   */
+  loginError?: string;
   /**
    * How this provider authenticates / is activated.
    * - "oauth": OAuth flow (user clicks Login → redirect)
diff --git a/packages/dashboard/app/components/SettingsModal.tsx b/packages/dashboard/app/components/SettingsModal.tsx
index 5737f86e5b..df4fe43bb0 100644
--- a/packages/dashboard/app/components/SettingsModal.tsx
+++ b/packages/dashboard/app/components/SettingsModal.tsx
@@ -1807,6 +1807,28 @@ export function SettingsModal({
     return () => clearInterval(interval);
   }, [activeSection, authProviders, loadAuthStatus]);
 
+  /*
+  FNXC:ProviderAuth 2026-07-05-00:00:
+  Interactive OAuth login finishes in the background after the auth URL/paste box is shown, so a failure (bad/expired pasted code, token-exchange rejection) only appears in the polled `/auth/status` as `loginError`. Surface that cause to the user once per distinct error instead of leaving login silently stuck, so paste-callback failures are diagnosable from the UI rather than only "it fails".
+  */
+  const shownLoginErrorsRef = useRef<Record<string, string>>({});
+  useEffect(() => {
+    for (const provider of authProviders) {
+      const error = provider.loginError;
+      if (!error) {
+        if (provider.id in shownLoginErrorsRef.current) {
+          delete shownLoginErrorsRef.current[provider.id];
+        }
+        continue;
+      }
+      if (shownLoginErrorsRef.current[provider.id] === error) {
+        continue;
+      }
+      shownLoginErrorsRef.current[provider.id] = error;
+      addToast(`${provider.name} login failed: ${error}`, "error");
+    }
+  }, [authProviders, addToast]);
+
   const scrollSettingsToTop = useCallback(() => {
     settingsContentRef.current?.scrollTo({ top: 0, behavior: "smooth" });
   }, []);
diff --git a/packages/dashboard/src/routes/register-auth-routes.ts b/packages/dashboard/src/routes/register-auth-routes.ts
index 2e04baf7ff..dd72663774 100644
--- a/packages/dashboard/src/routes/register-auth-routes.ts
+++ b/packages/dashboard/src/routes/register-auth-routes.ts
@@ -135,6 +135,13 @@ export const registerAuthRoutes: ApiRouteRegistrar = (ctx) => {
    */
   const loginInProgress = new Map<string, PendingLogin>();
 
+  /*
+  FNXC:ProviderAuth 2026-07-05-00:00:
+  Interactive OAuth login (e.g. Anthropic subscription paste-callback flow) resolves the auth URL to the client immediately, then the real login continues in the background. When the background `storage.login` rejects — bad/expired code, token-exchange rejection, redirect_uri mismatch — that error was previously dropped on the floor: `rejectAuthInfo` is a no-op once the auth URL has been sent, and nothing logged or surfaced it. The UI (which only polls `/auth/status`) then showed a generic "login failed" with no cause, making the failure undiagnosable for both users and maintainers.
+  Retain the last background login error per provider so `/auth/status` can report why it failed, and always log it server-side. Cleared when a fresh login for the same provider starts.
+  */
+  const lastLoginError = new Map<string, string>();
+
   const OAUTH_SESSION_TTL_MS = 5 * 60 * 1000;
   const oauthSessions = new Map<string, { port: number; path: string; originalRedirectUri: string; expiresAt: number }>();
 
@@ -474,6 +481,7 @@ export const registerAuthRoutes: ApiRouteRegistrar = (ctx) => {
         keyHint?: string;
         loginInProgress?: boolean;
         requiresManualCode?: boolean;
+        loginError?: string;
       }[] = await Promise.all(oauthProviders.map(async (p) => {
         const statusProvider = toAuthStatusProvider(p);
         const storageProviderId = toOauthCredentialProviderId(statusProvider.id);
@@ -501,6 +509,7 @@ export const registerAuthRoutes: ApiRouteRegistrar = (ctx) => {
           expired,
           loginInProgress: loginInProgress.has(statusProvider.id),
           requiresManualCode: getManualCodeConfig(toOauthLoginProviderId(statusProvider.id), origin) !== undefined || undefined,
+          loginError: lastLoginError.get(statusProvider.id),
         };
       }));
 
@@ -1082,6 +1091,9 @@ export const registerAuthRoutes: ApiRouteRegistrar = (ctx) => {
         throw conflict(`Login already in progress for ${provider}`);
       }
 
+      // Fresh login attempt clears any prior background failure for this provider.
+      lastLoginError.delete(provider);
+
       const storage = getAuthStorage();
       const oauthProviders = storage.getOAuthProviders();
       const found = oauthProviders.find((p) => p.id === provider || p.id === storageProvider);
@@ -1201,7 +1213,16 @@ export const registerAuthRoutes: ApiRouteRegistrar = (ctx) => {
         })
         .catch((err: unknown) => {
           // Login failed — also reject auth URL if not yet received
-          rejectAuthInfo(err instanceof Error ? err : new Error(String(err)));
+          const error = err instanceof Error ? err : new Error(String(err));
+          // Surface the real cause: reject the auth-URL promise if it hasn't
+          // resolved yet, and always retain + log the error. Once the auth URL
+          // is already sent, rejectAuthInfo is a no-op, so this retained error
+          // is the only channel by which the client learns why login failed.
+          rejectAuthInfo(error);
+          if (error.message !== "cancelled") {
+            lastLoginError.set(provider, error.message);
+            console.error(`[auth/login] background login failed for ${provider}: ${error.message}`);
+          }
         })
         .finally(() => {
           clearTimeout(timeout);
diff --git a/packages/engine/src/__tests__/auth-storage.test.ts b/packages/engine/src/__tests__/auth-storage.test.ts
index 168254e7d4..bbbfd3ac19 100644
--- a/packages/engine/src/__tests__/auth-storage.test.ts
+++ b/packages/engine/src/__tests__/auth-storage.test.ts
@@ -262,6 +262,56 @@ describe("createFusionAuthStorage", () => {
       expect(await authStorage.getApiKey("anthropic-subscription")).toBe("legacy-subscription-access-token");
     });
 
+    it("restores the subscription card when re-login writes the credential under the legacy anthropic id", async () => {
+      // Repro of FN: interactive subscription login persists OAuth under `anthropic`,
+      // but the settings card / status read is keyed on `anthropic-subscription`.
+      // After an in-session logout the subscription id is suppressed; a successful
+      // re-login must clear that suppression on BOTH aliases or the card is stuck
+      // reporting "Login did not complete" despite a valid stored credential.
+      const authStorage = createFusionAuthStorage();
+
+      authStorage.logout("anthropic-subscription");
+      expect(authStorage.hasAuth("anthropic-subscription")).toBe(false);
+
+      // `set` under the legacy id mirrors what interactive login persists.
+      authStorage.set("anthropic", {
+        type: "oauth",
+        access: "relogin-access-token",
+        refresh: "relogin-refresh-token",
+        expires: Date.now() + 3_600_000,
+      });
+
+      expect(authStorage.hasAuth("anthropic-subscription")).toBe(true);
+      expect(await authStorage.getApiKey("anthropic-subscription")).toBe("relogin-access-token");
+    });
+
+    it("restores the subscription card when re-auth writes under the subscription id", async () => {
+      const authStorage = createFusionAuthStorage();
+
+      authStorage.logout("anthropic-subscription");
+      expect(authStorage.hasAuth("anthropic-subscription")).toBe(false);
+
+      authStorage.set("anthropic-subscription", {
+        type: "oauth",
+        access: "subscription-relogin-token",
+        refresh: "subscription-relogin-refresh",
+        expires: Date.now() + 3_600_000,
+      });
+
+      expect(authStorage.hasAuth("anthropic-subscription")).toBe(true);
+    });
+
+    it("does not revive a logged-out subscription card from a raw anthropic API key", async () => {
+      // A raw `anthropic` API key belongs to its own card and must not alias into
+      // the subscription's logged-out state — only OAuth credentials do.
+      const authStorage = createFusionAuthStorage();
+
+      authStorage.logout("anthropic-subscription");
+      authStorage.set("anthropic", { type: "api_key", key: "sk-ant-api03-raw-key" });
+
+      expect(authStorage.hasAuth("anthropic-subscription")).toBe(false);
+    });
+
     it("refreshes legacy Anthropic OAuth in place for direct runtime auth", async () => {
       writeFusionAuth(homeDir, {
         anthropic: {
diff --git a/packages/engine/src/auth-storage.ts b/packages/engine/src/auth-storage.ts
index d8d1486c79..da3fb15595 100644
--- a/packages/engine/src/auth-storage.ts
+++ b/packages/engine/src/auth-storage.ts
@@ -349,6 +349,26 @@ export function createFusionAuthStorage(): AuthStorage {
   // Cleared when the user re-authenticates via set().
   const loggedOutProviders = new Set<string>();
 
+  /*
+  FNXC:ProviderAuth 2026-07-05-00:00:
+  Re-authenticating a provider must clear its in-memory logged-out suppression so the settings card flips back to connected.
+  Anthropic subscription OAuth is aliased across the legacy `anthropic` row — where interactive login persists the credential — and the separated `anthropic-subscription` id, where the card's logged-out flag and status read are keyed. Because a re-login only writes `anthropic`, clearing just the written id left `anthropic-subscription` suppressed: a user who logged out of the subscription earlier in the same dashboard session saw every successful re-login reported as "Login did not complete. Please try again." until the process restarted (the credential was valid on disk the whole time). Clear BOTH aliases when either is re-authenticated. Only OAuth credentials alias this way; a raw `anthropic` API key stays scoped to its own card, so api_key writes never clear the subscription alias.
+  */
+  const clearReauthenticatedLogoutState = (
+    provider: string,
+    credentialType?: StoredCredential["type"],
+  ) => {
+    loggedOutProviders.delete(provider);
+    oauthRefreshCooldownUntil.delete(provider);
+    const isAnthropicAlias =
+      provider === ANTHROPIC_PROVIDER_ID || provider === ANTHROPIC_SUBSCRIPTION_PROVIDER_ID;
+    const aliasesSubscriptionOAuth = credentialType === undefined || credentialType === "oauth";
+    if (isAnthropicAlias && aliasesSubscriptionOAuth) {
+      loggedOutProviders.delete(ANTHROPIC_PROVIDER_ID);
+      loggedOutProviders.delete(ANTHROPIC_SUBSCRIPTION_PROVIDER_ID);
+    }
+  };
+
   const syncSupplementalOauthCredentials = () => {
     for (const [provider, credential] of Object.entries(supplementalCredentials)) {
       if (loggedOutProviders.has(provider)) {
@@ -629,11 +649,29 @@ export function createFusionAuthStorage(): AuthStorage {
         };
       }
 
+      if (prop === "login") {
+        // Preserve the original invocation semantics (bind `this` to the proxy so
+        // any internal credential writes still flow through the set/logout traps),
+        // and only ADD the alias-aware logged-out clearing on top.
+        const originalLogin = Reflect.get(target, prop, receiver) as (
+          provider: string,
+          callbacks: unknown,
+        ) => Promise<void>;
+        return async (provider: string, callbacks: unknown) => {
+          const result = await originalLogin.call(receiver, provider, callbacks);
+          /*
+          FNXC:ProviderAuth 2026-07-05-00:00:
+          A completed interactive login means the user re-authenticated this provider, so lift its logged-out suppression (and the Anthropic subscription alias) even though the credential is persisted under `anthropic`. Without this, subscription re-login after an in-session logout stays invisible to the status card. See clearReauthenticatedLogoutState.
+          */
+          clearReauthenticatedLogoutState(provider);
+          return result;
+        };
+      }
+
       if (prop === "set") {
         return (provider: string, credential: AuthCredential) => {
           target.set(provider, credential);
-          loggedOutProviders.delete(provider);
-          oauthRefreshCooldownUntil.delete(provider);
+          clearReauthenticatedLogoutState(provider, (credential as StoredCredential | undefined)?.type);
         };
       }
 

From a5ac3c331479644e497fe04d4cf8335142eaad1a Mon Sep 17 00:00:00 2001
From: gsxdsm <gsxdsm@users.noreply.github.com>
Date: Sun, 5 Jul 2026 09:43:52 -0700
Subject: [PATCH 24/65] fix(FN-7566): stop phantom-binding reclaim from killing
 live ephemeral executor tasks

isPhantomExecutorBinding's liveness gate (heartbeat/checkout/runAudit) is
structurally blind to ephemeral executor agents, leaving only the
age>graceMs*3 (~30 min) threshold, so any ephemeral-executor task running
longer than ~30 min was reclaimed to `todo` mid-flight and its worktree
destroyed. Add the in-process live-session veto (activeSessionRegistry path /
executingTaskLock / isTaskActive), mirroring the isWorkspaceTaskLive/sessionDead
predicate, and honor clearPhantomExecutorBinding's live-session refusal in
reclaimSelfOwnedBranchConflicts. Legitimate FN-6736 leaked-binding recovery is
preserved (empty registry / no lock / inactive task still reads as phantom).

Fusion-Task-Id: FN-7566

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 ...tom-executor-kills-live-ephemeral-tasks.md |  7 ++
 .../reclaim-phantom-executor-binding.test.ts  | 87 ++++++++++++++++++-
 packages/engine/src/self-healing.ts           | 34 +++++++-
 3 files changed, 124 insertions(+), 4 deletions(-)
 create mode 100644 .changeset/fix-phantom-executor-kills-live-ephemeral-tasks.md

diff --git a/.changeset/fix-phantom-executor-kills-live-ephemeral-tasks.md b/.changeset/fix-phantom-executor-kills-live-ephemeral-tasks.md
new file mode 100644
index 0000000000..6c3bde0dc3
--- /dev/null
+++ b/.changeset/fix-phantom-executor-kills-live-ephemeral-tasks.md
@@ -0,0 +1,7 @@
+---
+"@runfusion/fusion": patch
+---
+
+summary: Stop self-healing from killing actively-running tasks after ~30 minutes.
+category: fix
+dev: FN-7566. isPhantomExecutorBinding's liveness gate (heartbeat/checkout/runAudit) was blind to ephemeral executor agents, leaving only the age>graceMs*3 threshold, so any ephemeral-executor task running longer than ~30 min was reclaimed to `todo` mid-flight. Adds the in-process live-session veto (activeSessionRegistry path / executingTaskLock / isTaskActive), mirroring the isWorkspaceTaskLive/sessionDead predicate, and honors clearPhantomExecutorBinding's live-session refusal in reclaimSelfOwnedBranchConflicts.
diff --git a/packages/engine/src/__tests__/reliability-interactions/reclaim-phantom-executor-binding.test.ts b/packages/engine/src/__tests__/reliability-interactions/reclaim-phantom-executor-binding.test.ts
index 0f9dac0136..0bf14b9c36 100644
--- a/packages/engine/src/__tests__/reliability-interactions/reclaim-phantom-executor-binding.test.ts
+++ b/packages/engine/src/__tests__/reliability-interactions/reclaim-phantom-executor-binding.test.ts
@@ -5,7 +5,7 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 import type { Settings, Task, TaskStore } from "@fusion/core";
 import { SelfHealingManager, STALE_ACTIVE_BRANCH_EXECUTION_GRACE_MS } from "../../self-healing.js";
-import { activeSessionRegistry } from "../../active-session-registry.js";
+import { activeSessionRegistry, executingTaskLock } from "../../active-session-registry.js";
 import * as branchConflictModule from "../../branch-conflicts.js";
 import * as worktreePoolModule from "../../worktree-pool.js";
 
@@ -84,6 +84,12 @@ function makeHarness(overrides: Partial<Task> = {}, options: {
   recentAuditRows?: AuditRow[];
   activeHeartbeat?: boolean;
   missingWorktree?: boolean;
+  // FN-7566: liveness signals that DO track ephemeral executors (agentId: "executor"),
+  // which never emit heartbeat runs, never take a checkout lease, and write no runAuditEvents.
+  liveSessionPath?: boolean;
+  executingTaskLockHeld?: boolean;
+  isTaskActive?: boolean;
+  clearReturns?: boolean;
 } = {}): Harness {
   const rootDir = mkdtempSync(join(tmpdir(), "fn-6736-"));
   const worktree = join(rootDir, ".worktrees", "crisp-lotus");
@@ -92,15 +98,24 @@ function makeHarness(overrides: Partial<Task> = {}, options: {
   }
   const task = makeTask({ worktree, ...overrides });
   const store = makeStore(task, { recentAuditRows: options.recentAuditRows });
-  const clearPhantomExecutorBinding = vi.fn();
+  const clearPhantomExecutorBinding = options.clearReturns === undefined
+    ? vi.fn()
+    : vi.fn(() => options.clearReturns);
   const agentStore = options.activeHeartbeat
     ? { listActiveHeartbeatRuns: vi.fn(async () => [{ startedAt: new Date(NOW.getTime() - 60_000).toISOString(), contextSnapshot: { taskId: task.id } }]) }
     : { listActiveHeartbeatRuns: vi.fn(async () => []) };
+  if (options.liveSessionPath) {
+    activeSessionRegistry.registerPath(worktree, { taskId: task.id, kind: "executor", ownerKey: task.id });
+  }
+  if (options.executingTaskLockHeld) {
+    executingTaskLock.tryClaim(task.id);
+  }
   const manager = new SelfHealingManager(store as any, {
     rootDir,
     getExecutingTaskIds: () => new Set([task.id]),
     clearPhantomExecutorBinding,
     agentStore,
+    ...(options.isTaskActive !== undefined ? { isTaskActive: () => options.isTaskActive } : {}),
   } as any);
   return {
     rootDir,
@@ -126,12 +141,14 @@ describe("FN-6736: phantom executor binding reclaim", () => {
     vi.setSystemTime(NOW);
     vi.restoreAllMocks();
     activeSessionRegistry.clear();
+    executingTaskLock._clearForTest();
     vi.spyOn(worktreePoolModule, "isUsableTaskWorktree").mockResolvedValue(true);
     vi.spyOn(branchConflictModule, "inspectBranchConflict").mockResolvedValue({ kind: "stale" } as any);
   });
 
   afterEach(() => {
     activeSessionRegistry.clear();
+    executingTaskLock._clearForTest();
     vi.useRealTimers();
   });
 
@@ -230,6 +247,72 @@ describe("FN-6736: phantom executor binding reclaim", () => {
     h.cleanup();
   });
 
+  // FN-7566: the FN-6736 durable-agent liveness gate (heartbeat/checkout/runAudit) is
+  // structurally blind to ephemeral executors. A live ephemeral executor keeps its worktree
+  // registered in activeSessionRegistry / holds the executing lock / reports isTaskActive — those
+  // are the in-process signals that MUST veto the phantom verdict even past the age multiplier,
+  // otherwise any ephemeral executor task running >30 min is killed mid-flight. Surface
+  // enumeration: all three live-session signals + the clearPhantomExecutorBinding refusal path.
+  it("does NOT reclaim a live ephemeral executor whose worktree is registered as an active session", async () => {
+    const h = makeHarness({}, { liveSessionPath: true });
+    expect(existsSync(h.worktree)).toBe(true);
+
+    const recovered = await h.manager.reclaimSelfOwnedBranchConflicts();
+
+    expect(recovered).toBe(0);
+    expect(h.clearPhantomExecutorBinding).not.toHaveBeenCalled();
+    expect(h.store.moveTask).not.toHaveBeenCalled();
+    expect(findAudit(h.store, "task:reclaim-phantom-executor-binding")).toBeUndefined();
+    expect(findAudit(h.store, "task:reclaim-self-owned-branch-conflict-no-action")?.metadata).toEqual(
+      expect.objectContaining({ reason: "executor-active" }),
+    );
+    expect(h.task.column).toBe("in-progress");
+    h.cleanup();
+  });
+
+  it("does NOT reclaim a live ephemeral executor that still holds the executing lock", async () => {
+    const h = makeHarness({}, { executingTaskLockHeld: true });
+
+    await h.manager.reclaimSelfOwnedBranchConflicts();
+
+    expect(h.clearPhantomExecutorBinding).not.toHaveBeenCalled();
+    expect(h.store.moveTask).not.toHaveBeenCalled();
+    expect(findAudit(h.store, "task:reclaim-phantom-executor-binding")).toBeUndefined();
+    expect(h.task.column).toBe("in-progress");
+    h.cleanup();
+  });
+
+  it("does NOT reclaim a live ephemeral executor that reports isTaskActive", async () => {
+    const h = makeHarness({}, { isTaskActive: true });
+
+    await h.manager.reclaimSelfOwnedBranchConflicts();
+
+    expect(h.clearPhantomExecutorBinding).not.toHaveBeenCalled();
+    expect(h.store.moveTask).not.toHaveBeenCalled();
+    expect(findAudit(h.store, "task:reclaim-phantom-executor-binding")).toBeUndefined();
+    expect(h.task.column).toBe("in-progress");
+    h.cleanup();
+  });
+
+  it("honors clearPhantomExecutorBinding's live-session refusal instead of hard-cancelling to todo", async () => {
+    // Defense-in-depth: even if the phantom verdict slips past isPhantomExecutorBinding, a clear that
+    // refuses (returns false — a live session surface is still registered) must NOT be followed by the
+    // destructive moveTask(→todo). Mirrors reapLeakedConcurrencySlots' `released !== true` guard.
+    const h = makeHarness({}, { clearReturns: false });
+
+    const recovered = await h.manager.reclaimSelfOwnedBranchConflicts();
+
+    expect(recovered).toBe(0);
+    expect(h.clearPhantomExecutorBinding).toHaveBeenCalledWith(h.task.id, { preserveWorktrees: true });
+    expect(h.store.moveTask).not.toHaveBeenCalled();
+    expect(h.task.column).toBe("in-progress");
+    expect(findAudit(h.store, "task:reclaim-phantom-executor-binding")).toBeUndefined();
+    expect(findAudit(h.store, "task:reclaim-self-owned-branch-conflict-no-action")?.metadata).toEqual(
+      expect.objectContaining({ reason: "phantom-clear-refused-live-session" }),
+    );
+    h.cleanup();
+  });
+
   it("does not increment FN-5704 resume-limbo counters on the phantom-binding requeue", async () => {
     const h = makeHarness({ resumeLimboCount: 1 } as Partial<Task>);
 
diff --git a/packages/engine/src/self-healing.ts b/packages/engine/src/self-healing.ts
index 2545357c80..b4a1c7e423 100644
--- a/packages/engine/src/self-healing.ts
+++ b/packages/engine/src/self-healing.ts
@@ -1103,6 +1103,10 @@ export class SelfHealingManager {
   /**
    * FNXC:SelfHealingReclaim 2026-06-19-00:00:
    * FN-6736 requires self-healing to stop treating an in-memory `executor-active` binding as live when the owner is demonstrably dead. Preserve FN-4811 by requiring every live-owner signal to be absent, leave the FN-5219 missing-worktree path untouched, and avoid FN-5704 resume-limbo counters because this path only clears a stale binding and requeues once with progress/worktree preserved.
+   *
+   * FNXC:SelfHealingReclaim 2026-07-05-08:15:
+   * FN-7566: the FN-6736 liveness gate (`agentPresent` heartbeat, `checkedOutBy` lease, `hasRecentRunAudit`) is structurally blind to EPHEMERAL EXECUTOR agents (`agentId: "executor"`): they never emit heartbeat runs (so `activeHeartbeatTaskIds` never contains them), never acquire a checkout lease (`checkedOutBy` stays null), and normal execution activity (sandbox:run / task:log / verification) writes no `runAuditEvents` rows (so `getRecentRunAuditActivityAgeMs` stays null). With all three permanently false, the ONLY surviving gate was age > graceMs*3 (~30 min), so any ephemeral executor task running longer than 30 minutes — a heavy foreach workflow, a slow model — was killed mid-flight on the next self-healing sweep and hard-moved to `todo`, corrupting overlapping-worktree/task-link state.
+   * The fix adds the in-process live-session truth that DOES track ephemeral executors: a worktree path registered as active in `activeSessionRegistry` (the executor/step-session/workflow-step session holds it for the whole run), the `executingTaskLock`, or `isTaskActive`. This mirrors the canonical `isWorkspaceTaskLive` / `sessionDead` predicate. A genuinely leaked binding (FN-6736) still has an EMPTY registry / no lock / inactive task, so legitimate phantom recovery is preserved; a live ephemeral executor now vetoes the phantom verdict regardless of the durable-agent signals.
    */
   private isPhantomExecutorBinding(task: Task, options: {
     executionAgeMs: number | null;
@@ -1115,6 +1119,14 @@ export class SelfHealingManager {
     const checkedOutBy = typeof task.checkedOutBy === "string" && task.checkedOutBy.trim().length > 0 ? task.checkedOutBy : null;
     const worktreeExists = Boolean(task.worktree && existsSync(task.worktree));
     const hasRecentRunAudit = options.lastActivityMs !== null && options.lastActivityMs <= RUNNING_ON_INACTIVE_TASK_STALE_RUN_MS;
+    // FN-7566: in-process liveness that survives for ephemeral executors. The registered
+    // session path is the faithful proxy for the live session surfaces
+    // (`activeSessions`/`activeStepExecutors`/`activeWorkflowStepSessions`) that
+    // `clearPhantomExecutorBinding` itself refuses to detach.
+    const livePaths = activeSessionRegistry.pathsForTask(task.id).filter((path) => activeSessionRegistry.isPathActive(path));
+    const hasLiveInProcessSession = livePaths.length > 0
+      || executingTaskLock.has(task.id)
+      || this.options.isTaskActive?.(task.id) === true;
     const safeAgeMs = options.graceMs * PHANTOM_EXECUTOR_BINDING_AGE_MULTIPLIER;
     const metadata = {
       taskId: task.id,
@@ -1125,6 +1137,8 @@ export class SelfHealingManager {
       agentPresent,
       lastActivityMs: options.lastActivityMs,
       hasRecentRunAudit,
+      hasLiveInProcessSession,
+      liveSessionPaths: livePaths,
       worktree: task.worktree ?? null,
       branch: task.branch ?? null,
       worktreeExists,
@@ -1137,7 +1151,8 @@ export class SelfHealingManager {
         && options.executionAgeMs > safeAgeMs
         && !checkedOutBy
         && !agentPresent
-        && !hasRecentRunAudit,
+        && !hasRecentRunAudit
+        && !hasLiveInProcessSession,
       metadata,
     };
   }
@@ -3123,7 +3138,22 @@ export class SelfHealingManager {
               // FNXC:SelfHealingReclaim 2026-06-30-00:00: preserveWorktrees keeps the held worktree's
               // session-registry entry so the moveTask(preserveWorktree:true) re-dispatch reattaches to
               // the same worktree instead of orphaning it and acquiring a new one (FN-7249 regression).
-              this.options.clearPhantomExecutorBinding?.(task.id, { preserveWorktrees: true });
+              // FNXC:SelfHealingReclaim 2026-07-05-08:15: FN-7566 — honor clearPhantomExecutorBinding's
+              // live-session refusal (returns false when any session surface is still registered) as the
+              // last line of defense before the destructive moveTask(→todo), matching reapLeakedConcurrencySlots.
+              // Even if a future liveness signal slips past isPhantomExecutorBinding, a refused clear must NOT
+              // be followed by a hard-cancel of a live executor: fall through to the no-action audit instead.
+              const released = this.options.clearPhantomExecutorBinding?.(task.id, { preserveWorktrees: true });
+              if (released === false) {
+                await this.emitFalsePositiveRequeueNoAction(
+                  task,
+                  "reclaim-self-owned-branch-conflict",
+                  "task:reclaim-self-owned-branch-conflict-no-action",
+                  "phantom-clear-refused-live-session",
+                  { ...phantomBinding.metadata, signalReason: liveExecutionSignal.reason },
+                );
+                continue;
+              }
               await createRunAuditor(this.store, {
                 runId: generateSyntheticRunId("self-healing-phantom-executor-binding", task.id),
                 agentId: "self-healing",

From 2df6c356fc5ba38b867375fb2d39635bc2563ed6 Mon Sep 17 00:00:00 2001
From: gsxdsm <gsxdsm@users.noreply.github.com>
Date: Sun, 5 Jul 2026 10:10:34 -0700
Subject: [PATCH 25/65] FN-7554: add PR-based revert path for autoMerge:false
 projects

Adds a PR-based revert path for done/archived tasks in autoMerge:false projects instead of refusing outright.

- New engine export `prepareRevertPrBranch` (packages/engine/src/task-revert.ts) prepares a dedicated `fusion/revert-<id>` branch off the base branch's HEAD and applies the revert commit(s) there, never mutating the base branch itself.
- `POST /api/tasks/:id/revert` route gains an additive `{ mode: "pr", clean: true, prUrl, prNumber, revertBranch, existingPr? }` result for clean single-repo reverts under autoMerge:false, reusing GitHubClient.createPr, findPrForBranch idempotency, and the manual:true PR handoff.
- Existing `{ mode: "git" | "ai", ... }` result shapes and the autoMerge:true path are unchanged.
- Workspace (multi-repo) tasks are explicitly refused for PR-based revert (out of scope; single PR cannot represent a multi-repo revert).
- Adds real-git integration tests for the new branch-prep/apply/commit flow and expands the dashboard route test coverage.
- Adds a changeset for @runfusion/fusion (minor) and a small task-management doc update.

Files changed:
 .changeset/fn-7554-pr-based-revert.md              |   7 +
 docs/task-management.md                            |   2 +-
 .../src/__tests__/task-revert-route.test.ts        | 196 +++++++++++++++++++-
 .../src/routes/register-task-workflow-routes.ts    | 182 ++++++++++++++++++
 .../src/__tests__/task-revert-pr.real-git.test.ts  | 206 +++++++++++++++++++++
 packages/engine/src/index.ts                       |   3 +
 packages/engine/src/task-revert.ts                 | 154 +++++++++++++++
 7 files changed, 747 insertions(+), 3 deletions(-)

Fusion-Task-Id: FN-7554

Fusion-Task-Lineage: 9b1bfd82-2428-4cf7-9b36-77afe3517a14

Co-authored-by: Fusion (runfusion.ai) <noreply@runfusion.ai>
---
 .changeset/fn-7554-pr-based-revert.md         |   7 +
 docs/task-management.md                       |   2 +-
 .../src/__tests__/task-revert-route.test.ts   | 196 ++++++++++++++++-
 .../routes/register-task-workflow-routes.ts   | 182 ++++++++++++++++
 .../__tests__/task-revert-pr.real-git.test.ts | 206 ++++++++++++++++++
 packages/engine/src/index.ts                  |   3 +
 packages/engine/src/task-revert.ts            | 154 +++++++++++++
 7 files changed, 747 insertions(+), 3 deletions(-)
 create mode 100644 .changeset/fn-7554-pr-based-revert.md
 create mode 100644 packages/engine/src/__tests__/task-revert-pr.real-git.test.ts

diff --git a/.changeset/fn-7554-pr-based-revert.md b/.changeset/fn-7554-pr-based-revert.md
new file mode 100644
index 0000000000..5b164b3be2
--- /dev/null
+++ b/.changeset/fn-7554-pr-based-revert.md
@@ -0,0 +1,7 @@
+---
+"@runfusion/fusion": minor
+---
+
+summary: Open a revert PR for done/archived tasks when autoMerge is disabled instead of refusing.
+category: feature
+dev: `POST /api/tasks/:id/revert` gains an additive `{ mode: "pr", clean: true, prUrl, prNumber, revertBranch, existingPr? }` result for clean single-repo reverts under `autoMerge:false`, reusing `GitHubClient.createPr`, `findPrForBranch` idempotency, and the `manual:true` PR handoff. New engine export `prepareRevertPrBranch` (packages/engine/src/task-revert.ts) prepares the dedicated `fusion/revert-<id>` branch without ever mutating the base branch. Existing `{ mode: "git" | "ai", ... }` shapes and the `autoMerge:true` path are unchanged.
diff --git a/docs/task-management.md b/docs/task-management.md
index 6af1f9b47f..a3890b2ea8 100644
--- a/docs/task-management.md
+++ b/docs/task-management.md
@@ -685,7 +685,7 @@ Recovery/backfill guidance:
 - Git-path response contract (additive only): `{ mode: "git", clean, revertCommitSha?, revertCommitShas?, conflicts?, alreadyReverted?, unsupported?, needsHuman?, reason? }`. A clean revert lands a `revert(FN-xxxx): ...` commit carrying a `Fusion-Task-Id` trailer on the resolved base branch; `revertCommitShas` reports every commit created (all of them for `per-sha`, the single one for `squash`) alongside the existing `revertCommitSha`.
 - AI-undo response contract: `{ mode: "ai", createdTaskId: "FN-YYYY", alreadyOpen?: true }`. The created task is an ordinary `triage`-column board task (via the normal `store.createTask` path) that references the source task's id, mission, and landed files, and instructs undoing the source task's behavior while preserving unrelated later changes to the same files, using a `revert(FN-xxxx): ...` commit convention. It carries NO dependency on the (already done/archived) source task. A `sourceMetadata.revertOf` marker makes repeated fallback calls idempotent — while an AI-undo task for that source is still open, a further call returns the same `createdTaskId` with `alreadyOpen: true` instead of creating a duplicate; a prior undo task that itself reached `done`/`archived` does not suppress a fresh one.
 - **Workspace (multi-repo) tasks (FN-7547):** tasks with `workspaceWorktrees` populated (`isWorkspaceTask`) are revertable too — the route dispatches to a dedicated workspace path that reasons about every sub-repo's integration branch as ONE all-or-nothing unit. It resolves each sub-repo's attributable commit(s), dry-run classifies every sub-repo first, and only commits a `revert(FN-xxxx): ...` commit on EACH sub-repo when every sub-repo classifies clean/already-reverted; if any sub-repo conflicts, no sub-repo is committed and every touched sub-repo worktree is rolled back to its pre-call state. Response contract for workspace tasks: `{ mode: "git", clean, workspace: { repos: [{ repo, classification, revertCommitSha?, conflicts?, alreadyReverted? }] }, conflicts?: {repo, file, ...}[] }`. A conflicting workspace result still falls back to the AI-undo task under `"auto"` mode, same as a single-repo conflicting result.
-- `autoMerge:false` projects return `needsHuman` and never trigger the AI-undo fallback (a human/future UI decides).
+- **`autoMerge:false` PR-based revert (FN-7554):** for a single-repo task whose git revert classifies **clean**, `autoMerge:false` no longer dead-ends at `needsHuman`. The route prepares a dedicated `fusion/revert-<id>` branch off the resolved base branch (via the engine's `prepareRevertPrBranch`, which NEVER writes to the base branch itself), pushes it, and opens a GitHub PR through the same owner/repo resolution, `githubRateLimiter` gate, `findPrForBranch` idempotency, and `manual: true` handoff as `POST /tasks/:id/pr/create`. Response: `{ mode: "pr", clean: true, prUrl, prNumber, revertBranch, existingPr? }` — a second call while the PR is still open links the existing PR (`existingPr: true`) instead of re-pushing. GitHub unconfigured or rate-limited still degrades gracefully to `{ mode: "git", needsHuman: true, reason }`, and a conflicting/unsupported/already-reverted classification is unaffected (no PR is opened; `"auto"` mode still falls back to the AI-undo task on conflict/unsupported). Workspace (multi-repo) tasks are not yet covered by this PR path — they keep the existing `needsHuman` result under `autoMerge:false`.
 - **Dashboard auto-linking (FN-7555):** the AI-undo task's card shows an "Undo of FN-xxxx" chip and its detail view shows a clickable "Created to undo FN-xxxx" link back to the source task. The source task's detail view shows an "Undo task: FN-YYYY" link whenever an OPEN undo task referencing it exists in the loaded tasks (matching `TaskStore.findOpenRevertTaskForSource`'s open-only semantics — a `done`/`archived`/soft-deleted undo task is never surfaced as active). Both directions are derived client-side from `sourceMetadata.revertOf`; no new API. A dedicated Done/Archived card revert-trigger action is still a separate follow-up (see FN-7525).
 
 
diff --git a/packages/dashboard/src/__tests__/task-revert-route.test.ts b/packages/dashboard/src/__tests__/task-revert-route.test.ts
index 9684e863db..0e60955724 100644
--- a/packages/dashboard/src/__tests__/task-revert-route.test.ts
+++ b/packages/dashboard/src/__tests__/task-revert-route.test.ts
@@ -18,6 +18,7 @@ import { execFileSync } from "node:child_process";
 import type { Task, TaskStore } from "@fusion/core";
 import { createApiRoutes } from "../routes.js";
 import { request as performRequest } from "../test-request.js";
+import { githubRateLimiter } from "../github-poll.js";
 
 // FNXC:TaskRevert 2026-07-04-00:00: the route now guards against `rootDir`
 // (the shared user checkout) sitting on a branch other than the resolved
@@ -31,11 +32,18 @@ function makeGitRepoOnMain(): string {
   execFileSync("git", ["config", "user.email", "test@example.com"], { cwd: dir });
   execFileSync("git", ["config", "user.name", "Test"], { cwd: dir });
   execFileSync("git", ["commit", "--allow-empty", "-m", "init"], { cwd: dir });
+  // FN-7554: a local bare "origin" remote lets `mode:"pr"` tests exercise a
+  // REAL `git push -u origin <revertBranch>` without any network dependency.
+  const originDir = mkdtempSync(join(tmpdir(), "kb-task-revert-route-origin-"));
+  execFileSync("git", ["init", "--bare", "-b", "main"], { cwd: originDir });
+  execFileSync("git", ["remote", "add", "origin", originDir], { cwd: dir });
+  execFileSync("git", ["push", "-u", "origin", "main"], { cwd: dir });
   return dir;
 }
 
 const performTaskRevertMock = vi.fn();
 const revertWorkspaceTaskMock = vi.fn();
+const prepareRevertPrBranchMock = vi.fn();
 
 vi.mock("@fusion/engine", async (importOriginal) => {
   const actual = await importOriginal<typeof import("@fusion/engine")>();
@@ -43,9 +51,25 @@ vi.mock("@fusion/engine", async (importOriginal) => {
     ...actual,
     performTaskRevert: (...args: unknown[]) => performTaskRevertMock(...args),
     revertWorkspaceTask: (...args: unknown[]) => revertWorkspaceTaskMock(...args),
+    prepareRevertPrBranch: (...args: unknown[]) => prepareRevertPrBranchMock(...args),
   };
 });
 
+// FN-7554: stub GitHubClient at the route boundary — `findPrForBranch`/`createPr`
+// idempotency + push/create behavior is exercised here; real GitHubClient HTTP/gh-CLI
+// behavior is covered by github.test.ts.
+const findPrForBranchMock = vi.fn();
+const createPrMock = vi.fn();
+
+vi.mock("../github.js", () => ({
+  GitHubClient: vi.fn().mockImplementation(function (this: unknown) {
+    return {
+      findPrForBranch: (...args: unknown[]) => findPrForBranchMock(...args),
+      createPr: (...args: unknown[]) => createPrMock(...args),
+    };
+  }),
+}));
+
 // FNXC:TaskRevert 2026-07-04-00:00 (FN-7524): `createAiUndoTask` is NOT mocked —
 // these route tests exercise the real engine helper against a fake store
 // (`createTask`/`findOpenRevertTaskForSource`), proving the route wires the
@@ -84,7 +108,7 @@ function makeWorkspaceTask(overrides: Partial<Task>): Task {
 
 function createMockStore(
   task: Task,
-  opts?: { openUndoTask?: Task | null; createdUndoTask?: Task },
+  opts?: { openUndoTask?: Task | null; createdUndoTask?: Task; autoMerge?: boolean },
 ): TaskStore {
   let nextId = 800;
   const createTask = vi.fn().mockImplementation(async (input: { description: string; source?: { sourceParentTaskId?: string; sourceMetadata?: Record<string, unknown> } }) => {
@@ -104,12 +128,15 @@ function createMockStore(
   const findOpenRevertTaskForSource = vi.fn().mockResolvedValue(opts?.openUndoTask ?? null);
   return {
     getSettings: vi.fn().mockResolvedValue({}),
-    getSettingsFast: vi.fn().mockResolvedValue({ autoMerge: true }),
+    getSettingsFast: vi.fn().mockResolvedValue({ autoMerge: opts?.autoMerge ?? true }),
     getRootDir: vi.fn().mockReturnValue(makeGitRepoOnMain()),
     getTask: vi.fn().mockResolvedValue(task),
     getTaskCommitAssociationsByLineageId: vi.fn().mockResolvedValue([]),
     createTask,
     findOpenRevertTaskForSource,
+    updatePrInfo: vi.fn().mockResolvedValue(task),
+    addPrInfo: vi.fn().mockResolvedValue(task),
+    logEntry: vi.fn().mockResolvedValue(undefined),
     on: vi.fn(),
     off: vi.fn(),
   } as unknown as TaskStore;
@@ -459,3 +486,168 @@ describe("POST /tasks/:id/revert — FN-7524 mode + AI-undo fallback", () => {
     expect(performTaskRevertMock.mock.calls[0]?.[0]).toMatchObject({ granularity: "squash" });
   });
 });
+
+// FN-7554: mode:"pr" — PR-based revert for autoMerge:false projects.
+describe("POST /tasks/:id/revert — FN-7554 mode:'pr' (autoMerge:false)", () => {
+  const originalGithubRepository = process.env.GITHUB_REPOSITORY;
+
+  afterEach(() => {
+    vi.clearAllMocks();
+    vi.restoreAllMocks();
+    if (originalGithubRepository === undefined) {
+      delete process.env.GITHUB_REPOSITORY;
+    } else {
+      process.env.GITHUB_REPOSITORY = originalGithubRepository;
+    }
+  });
+
+  it("clean + autoMerge:false → mode:'pr', pushes and creates the PR with manual:true persistence", async () => {
+    process.env.GITHUB_REPOSITORY = "o/r";
+    const task = makeTask({ id: "FN-100", column: "done" });
+    const store = createMockStore(task, { autoMerge: false });
+    const rootDir = (store.getRootDir as () => string)();
+    // `prepareRevertPrBranch` is mocked (real branch-prep behavior is proven by
+    // task-revert-pr.real-git.test.ts), so create the branch it would have
+    // created locally, so the route's REAL `git push -u origin <branch>` has
+    // something to push.
+    execFileSync("git", ["branch", "fusion/revert-fn-100"], { cwd: rootDir });
+    vi.spyOn(githubRateLimiter, "canMakeRequest").mockReturnValue(true);
+    findPrForBranchMock.mockResolvedValue(null);
+    prepareRevertPrBranchMock.mockResolvedValue({
+      eligible: true,
+      revertBranch: "fusion/revert-fn-100",
+      revertCommitShas: ["abc"],
+    });
+    createPrMock.mockResolvedValue({ number: 7, url: "https://github.com/o/r/pull/7" });
+
+    const res = await REQUEST(createApp(store), "POST", `/api/tasks/${task.id}/revert`);
+    expect(res.status).toBe(200);
+    expect(res.body).toMatchObject({
+      mode: "pr",
+      clean: true,
+      prUrl: "https://github.com/o/r/pull/7",
+      prNumber: 7,
+      revertBranch: "fusion/revert-fn-100",
+    });
+    expect(createPrMock).toHaveBeenCalledTimes(1);
+    expect(createPrMock.mock.calls[0]?.[0]).toMatchObject({ head: "fusion/revert-fn-100" });
+    expect(typeof createPrMock.mock.calls[0]?.[0]?.body).toBe("string");
+    expect((createPrMock.mock.calls[0]?.[0]?.body as string).length).toBeGreaterThan(0);
+    expect(store.updatePrInfo as ReturnType<typeof vi.fn>).toHaveBeenCalledWith(
+      task.id,
+      expect.objectContaining({ manual: true, number: 7 }),
+    );
+    expect(performTaskRevertMock).not.toHaveBeenCalled();
+  });
+
+  it("existing PR idempotency: links the existing PR without re-preparing/re-pushing", async () => {
+    process.env.GITHUB_REPOSITORY = "o/r";
+    const task = makeTask({ id: "FN-100", column: "done" });
+    const store = createMockStore(task, { autoMerge: false });
+    vi.spyOn(githubRateLimiter, "canMakeRequest").mockReturnValue(true);
+    findPrForBranchMock.mockResolvedValue({ number: 9, url: "https://github.com/o/r/pull/9" });
+
+    const res = await REQUEST(createApp(store), "POST", `/api/tasks/${task.id}/revert`);
+    expect(res.status).toBe(200);
+    expect(res.body).toMatchObject({
+      mode: "pr",
+      clean: true,
+      prUrl: "https://github.com/o/r/pull/9",
+      prNumber: 9,
+      existingPr: true,
+    });
+    expect(prepareRevertPrBranchMock).not.toHaveBeenCalled();
+    expect(createPrMock).not.toHaveBeenCalled();
+  });
+
+  it("GitHub unconfigured degrade: no GITHUB_REPOSITORY and no git remote → needsHuman", async () => {
+    delete process.env.GITHUB_REPOSITORY;
+    const task = makeTask({ id: "FN-100", column: "done" });
+    const store = createMockStore(task, { autoMerge: false });
+
+    const res = await REQUEST(createApp(store), "POST", `/api/tasks/${task.id}/revert`);
+    expect(res.status).toBe(200);
+    expect(res.body).toMatchObject({ mode: "git", needsHuman: true });
+    expect(String((res.body as { reason?: string }).reason ?? "")).toMatch(/no GitHub repository/i);
+    expect(prepareRevertPrBranchMock).not.toHaveBeenCalled();
+    expect(createPrMock).not.toHaveBeenCalled();
+  });
+
+  it("rate-limited degrade: needsHuman without touching prepareRevertPrBranch/createPr", async () => {
+    process.env.GITHUB_REPOSITORY = "o/r";
+    const task = makeTask({ id: "FN-100", column: "done" });
+    const store = createMockStore(task, { autoMerge: false });
+    vi.spyOn(githubRateLimiter, "canMakeRequest").mockReturnValue(false);
+
+    const res = await REQUEST(createApp(store), "POST", `/api/tasks/${task.id}/revert`);
+    expect(res.status).toBe(200);
+    expect(res.body).toMatchObject({ mode: "git", needsHuman: true });
+    expect(String((res.body as { reason?: string }).reason ?? "")).toMatch(/rate limit/i);
+    expect(prepareRevertPrBranchMock).not.toHaveBeenCalled();
+    expect(createPrMock).not.toHaveBeenCalled();
+  });
+
+  it("conflicting under autoMerge:false, mode:'git' → { mode: 'git', clean: false, conflicts } without a PR", async () => {
+    process.env.GITHUB_REPOSITORY = "o/r";
+    const task = makeTask({ id: "FN-100", column: "done" });
+    const store = createMockStore(task, { autoMerge: false });
+    vi.spyOn(githubRateLimiter, "canMakeRequest").mockReturnValue(true);
+    findPrForBranchMock.mockResolvedValue(null);
+    prepareRevertPrBranchMock.mockResolvedValue({
+      eligible: false,
+      classification: "conflicting",
+      conflicts: [{ file: "foo.ts", status: "UU" }],
+    });
+
+    const res = await POST_JSON(createApp(store), `/api/tasks/${task.id}/revert`, { mode: "git" });
+    expect(res.status).toBe(200);
+    expect(res.body).toMatchObject({ mode: "git", clean: false, conflicts: [{ file: "foo.ts", status: "UU" }] });
+    expect(createPrMock).not.toHaveBeenCalled();
+  });
+
+  it("conflicting under autoMerge:false, mode:'auto' → falls back to the AI-undo task", async () => {
+    process.env.GITHUB_REPOSITORY = "o/r";
+    const task = makeTask({ id: "FN-960", column: "done" });
+    const store = createMockStore(task, { autoMerge: false });
+    vi.spyOn(githubRateLimiter, "canMakeRequest").mockReturnValue(true);
+    findPrForBranchMock.mockResolvedValue(null);
+    prepareRevertPrBranchMock.mockResolvedValue({
+      eligible: false,
+      classification: "conflicting",
+      conflicts: [{ file: "foo.ts", status: "UU" }],
+    });
+
+    const res = await POST_JSON(createApp(store), `/api/tasks/${task.id}/revert`, { mode: "auto" });
+    expect(res.status).toBe(200);
+    expect(res.body).toMatchObject({ mode: "ai" });
+    expect((res.body as { createdTaskId?: string }).createdTaskId).toBeTruthy();
+    expect(createPrMock).not.toHaveBeenCalled();
+  });
+
+  it("regression — autoMerge:true unchanged: still calls performTaskRevert and returns the existing shape", async () => {
+    process.env.GITHUB_REPOSITORY = "o/r";
+    const task = makeTask({ id: "FN-970", column: "done" });
+    const store = createMockStore(task, { autoMerge: true });
+    performTaskRevertMock.mockResolvedValue({ mode: "git", clean: true, revertCommitSha: "abc123", revertCommitShas: ["abc123"] });
+
+    const res = await REQUEST(createApp(store), "POST", `/api/tasks/${task.id}/revert`);
+    expect(res.status).toBe(200);
+    expect(res.body).toMatchObject({ mode: "git", clean: true, revertCommitSha: "abc123" });
+    expect(prepareRevertPrBranchMock).not.toHaveBeenCalled();
+    expect(createPrMock).not.toHaveBeenCalled();
+    expect(performTaskRevertMock).toHaveBeenCalledTimes(1);
+  });
+
+  it("regression — non-done/archived guard unchanged: still 4xx before any engine/GitHub call", async () => {
+    process.env.GITHUB_REPOSITORY = "o/r";
+    const task = makeTask({ id: "FN-971", column: "in-progress" });
+    const store = createMockStore(task, { autoMerge: false });
+
+    const res = await REQUEST(createApp(store), "POST", `/api/tasks/${task.id}/revert`);
+    expect(res.status).toBeGreaterThanOrEqual(400);
+    expect(res.status).toBeLessThan(500);
+    expect(prepareRevertPrBranchMock).not.toHaveBeenCalled();
+    expect(performTaskRevertMock).not.toHaveBeenCalled();
+    expect(createPrMock).not.toHaveBeenCalled();
+  });
+});
diff --git a/packages/dashboard/src/routes/register-task-workflow-routes.ts b/packages/dashboard/src/routes/register-task-workflow-routes.ts
index fd3d724078..ec268d558c 100644
--- a/packages/dashboard/src/routes/register-task-workflow-routes.ts
+++ b/packages/dashboard/src/routes/register-task-workflow-routes.ts
@@ -14,6 +14,7 @@ import type {
   DuplicateMatch,
   RunAuditEvent,
   ArtifactType,
+  PrInfo,
 } from "@fusion/core";
 import {
   COLUMNS,
@@ -47,6 +48,7 @@ import {
   type NearDuplicateCandidate,
 } from "@fusion/core";
 import { GitHubClient } from "../github.js";
+import { githubRateLimiter } from "../github-poll.js";
 import { createTrackingIssueForTask } from "../github-tracking-hook.js";
 import { parseGitHubBadgeUrl } from "./register-git-github.js";
 import {
@@ -56,7 +58,9 @@ import {
   revertWorkspaceTask,
   TaskRevertError,
   createAiUndoTask,
+  prepareRevertPrBranch,
   type AiUndoTaskResult,
+  type PrepareRevertPrBranchResult,
 } from "@fusion/engine";
 import { buildBoardWorkflowsPayload } from "./board-workflows.js";
 import { isBackwardMoveBlockedByOpenPr, PR_OPEN_BLOCKS_MOVE_BACK_MESSAGE } from "./register-pull-requests-routes.js";
@@ -1819,6 +1823,184 @@ export function registerTaskWorkflowRoutes(ctx: ApiRoutesContext, deps: TaskWork
         });
       }
 
+      /*
+      FNXC:TaskRevert 2026-07-05-00:00 (FN-7554 — mode:"pr" contract, additive over FN-7523/24/47/48):
+      `performTaskRevert` refuses (`needsHuman`) whenever autoMerge is
+      effectively off, because it would otherwise force-write a revert commit
+      directly onto `baseBranch` — a branch this project has opted out of
+      automated writes to. Instead of stopping at that dead end, open a real
+      revert PR: `prepareRevertPrBranch` (engine) applies the revert commit(s)
+      onto a DEDICATED `fusion/revert-<id>` branch off `baseBranch` HEAD
+      (never mutating `baseBranch` itself), then this route pushes that branch
+      and opens a PR via `GitHubClient.createPr` — reusing the exact
+      owner/repo resolution, `githubRateLimiter` gate, `findPrForBranch`
+      idempotency, and `manual: true` handoff that `/pr/create` already uses.
+      This ONLY applies to the single-repo git path (workspace tasks already
+      returned above) and ONLY for `mode !== "ai"` (the `mode === "ai"` case
+      already returned earlier in this handler). Every existing
+      `{ mode: "git" | "ai", ... }` result shape is unchanged — this adds a
+      new `{ mode: "pr", ... }` variant. Graceful `needsHuman` degrade (NOT a
+      thrown error) covers: GitHub unconfigured, and GitHub rate-limited —
+      both leave the caller with the same actionable `needsHuman` contract
+      the `autoMerge:true` code path never has to think about.
+      PR-based revert of WORKSPACE (multi-repo) tasks under autoMerge:false is
+      explicitly deferred (would require per-sub-repo branches + multiple
+      PRs) — see the FN-7554 follow-up task; workspace tasks above still get
+      the existing `needsHuman` result from `revertWorkspaceTask`.
+      */
+      const effectiveAutoMerge = task.autoMerge ?? settings.autoMerge ?? true;
+      if (effectiveAutoMerge === false) {
+        let owner: string;
+        let repo: string;
+        const envRepo = process.env.GITHUB_REPOSITORY;
+        if (envRepo) {
+          const [o, r] = envRepo.split("/");
+          owner = o;
+          repo = r;
+        } else {
+          const gitRepo = getCurrentRepo(rootDir);
+          if (!gitRepo) {
+            res.json({
+              mode: "git",
+              needsHuman: true,
+              reason: "autoMerge is disabled and no GitHub repository is configured; cannot open a revert PR",
+            });
+            return;
+          }
+          owner = gitRepo.owner;
+          repo = gitRepo.repo;
+        }
+
+        const repoKey = `${owner}/${repo}`;
+        if (!githubRateLimiter.canMakeRequest(repoKey)) {
+          res.json({
+            mode: "git",
+            needsHuman: true,
+            reason: "GitHub API rate limit exceeded; try again later",
+          });
+          return;
+        }
+
+        const revertBranch = `fusion/revert-${task.id.toLowerCase()}`;
+        const client = new GitHubClient();
+        let existingPr: Awaited<ReturnType<typeof client.findPrForBranch>>;
+        try {
+          existingPr = await client.findPrForBranch({ head: revertBranch, state: "all", owner, repo });
+        } catch (error) {
+          // FNXC:TaskRevert 2026-07-05-00:00 (FN-7554): GitHub reachability failure
+          // (network down, auth rejected, 5xx, etc.) degrades to needsHuman with an
+          // explicit reason rather than bubbling up as a 500 — mirrors the
+          // no-remote-configured / rate-limited degrade paths above.
+          res.json({
+            mode: "git",
+            needsHuman: true,
+            reason: `GitHub is unavailable; could not check for an existing revert PR (${error instanceof Error ? error.message : String(error)})`,
+          });
+          return;
+        }
+
+        const persistPrInfo = async (prInfo: PrInfo): Promise<void> => {
+          const existingPrs = task.prInfos ?? (task.prInfo ? [task.prInfo] : []);
+          if (existingPrs.length > 0) {
+            await scopedStore.addPrInfo(task.id, prInfo);
+          } else {
+            await scopedStore.updatePrInfo(task.id, prInfo);
+          }
+        };
+
+        if (existingPr) {
+          // Idempotency — mirrors `/pr/create`: never re-prepare/re-push when an
+          // open (or all-state) PR already exists for this branch, just link it.
+          const prInfo: PrInfo = { ...existingPr, manual: true };
+          await persistPrInfo(prInfo);
+          await scopedStore.logEntry(task.id, "Linked existing revert PR", `PR #${prInfo.number}: ${prInfo.url}`);
+          res.json({
+            mode: "pr",
+            clean: true,
+            prUrl: prInfo.url,
+            prNumber: prInfo.number,
+            revertBranch,
+            existingPr: true,
+          });
+          return;
+        }
+
+        const prepared: PrepareRevertPrBranchResult = await prepareRevertPrBranch({
+          task,
+          worktreePath: rootDir,
+          baseBranch,
+          revertBranch,
+          commitAssociationSource: {
+            getTaskCommitAssociationsByLineageId: (lineageId: string) =>
+              scopedStore.getTaskCommitAssociationsByLineageId(lineageId),
+          },
+        });
+
+        if (!prepared.eligible) {
+          if ("alreadyReverted" in prepared && prepared.alreadyReverted) {
+            res.json({ mode: "git", clean: true, alreadyReverted: true });
+            return;
+          }
+          if ("classification" in prepared && prepared.classification === "conflicting") {
+            if (mode === "auto") {
+              res.json(await createAiUndoResult());
+              return;
+            }
+            res.json({ mode: "git", clean: false, conflicts: prepared.conflicts });
+            return;
+          }
+          if ("unsupported" in prepared && prepared.unsupported) {
+            if (mode === "auto") {
+              res.json(await createAiUndoResult());
+              return;
+            }
+            res.json({ mode: "git", unsupported: true, reason: prepared.reason });
+            return;
+          }
+        }
+
+        if (prepared.eligible) {
+          // FNXC:TaskRevert 2026-07-05-00:00 (FN-7554): push/create-PR failures
+          // (network down, auth rejected, remote rejects push, GitHub 5xx, etc.)
+          // degrade to needsHuman with an explicit reason instead of a thrown 500 —
+          // the revert branch/commit(s) already prepared locally are left in place
+          // (never force-written to `baseBranch`) so a retry can reuse them.
+          try {
+            await runGitCommand(["push", "-u", "origin", prepared.revertBranch], rootDir, 60_000);
+            const prTitle = `revert(${task.id}): undo landed work`;
+            const prBody =
+              `This PR reverts the work landed by task ${task.id}.\n\n` +
+`See \`GET /api/tasks/${task.id}/diff\` for the landed diff being reverted.\n`;
+            const created = await client.createPr({
+              owner,
+              repo,
+              title: prTitle,
+              body: prBody,
+              head: prepared.revertBranch,
+              base: baseBranch,
+            });
+            const prInfo: PrInfo = { ...created, manual: true };
+            await persistPrInfo(prInfo);
+            await scopedStore.logEntry(task.id, "Created revert PR", `PR #${prInfo.number}: ${prInfo.url}`);
+            res.json({
+              mode: "pr",
+              clean: true,
+              prUrl: prInfo.url,
+              prNumber: prInfo.number,
+              revertBranch: prepared.revertBranch,
+            });
+            return;
+          } catch (error) {
+            res.json({
+              mode: "git",
+              needsHuman: true,
+              reason: `GitHub is unavailable; could not push the revert branch or open the PR (${error instanceof Error ? error.message : String(error)})`,
+            });
+            return;
+          }
+        }
+      }
+
       const result = await performTaskRevert({
         task,
         worktreePath: rootDir,
diff --git a/packages/engine/src/__tests__/task-revert-pr.real-git.test.ts b/packages/engine/src/__tests__/task-revert-pr.real-git.test.ts
new file mode 100644
index 0000000000..73fb72b3c1
--- /dev/null
+++ b/packages/engine/src/__tests__/task-revert-pr.real-git.test.ts
@@ -0,0 +1,206 @@
+import { execSync, spawnSync } from "node:child_process";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import { prepareRevertPrBranch } from "../task-revert.js";
+import type { Task } from "@fusion/core";
+
+const hasGit = spawnSync("git", ["--version"], { stdio: "pipe" }).status === 0;
+const describeIfGit = hasGit ? describe : describe.skip;
+
+function git(repo: string, command: string): string {
+  return execSync(command, { cwd: repo, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+}
+
+function makeTask(overrides: Partial<Task>): Task {
+  return {
+    id: "FN-A",
+    lineageId: "FN-A",
+    description: "",
+    column: "done",
+    dependencies: [],
+    steps: [],
+    currentStep: 0,
+    ...overrides,
+  } as Task;
+}
+
+// FN-7554: real-git regression coverage for the PR-based revert branch-prep
+// helper — clean → dedicated branch (base never mutated), conflicting/
+// already-reverted/unsupported pass-through, idempotent local branch reset,
+// and dirty-tree refusal.
+describeIfGit("prepareRevertPrBranch real-git scenarios", { timeout: 30_000 }, () => {
+  const dirs: string[] = [];
+  afterEach(() => {
+    for (const dir of dirs.splice(0)) rmSync(dir, { recursive: true, force: true });
+  });
+
+  function repoFixture() {
+    const repo = mkdtempSync(join(tmpdir(), "kb-revert-pr-"));
+    dirs.push(repo);
+    git(repo, "git init -b main");
+    git(repo, 'git config user.email "test@example.com"');
+    git(repo, 'git config user.name "Test User"');
+    git(repo, "git config commit.gpgsign false");
+    writeFileSync(join(repo, "foo.ts"), "line1\n");
+    git(repo, "git add foo.ts && git commit -m 'init'");
+    return repo;
+  }
+
+  it("clean → eligible: creates fusion/revert-<id> branch with revert commit, base untouched", async () => {
+    const repo = repoFixture();
+    writeFileSync(join(repo, "foo.ts"), "line1\nfeature-a\n");
+    git(repo, "git add foo.ts && git commit -m 'feat(FN-A): add feature a'");
+    const sha = git(repo, "git rev-parse HEAD");
+    const mainHeadBefore = git(repo, "git rev-parse main");
+
+    const task = makeTask({ mergeDetails: { commitSha: sha, mergeTargetBranch: "main" } });
+    const result = await prepareRevertPrBranch({
+      task,
+      worktreePath: repo,
+      baseBranch: "main",
+      revertBranch: "fusion/revert-fn-a",
+    });
+
+    expect(result).toMatchObject({ eligible: true, revertBranch: "fusion/revert-fn-a" });
+    if (result.eligible) {
+      expect(result.revertCommitShas.length).toBe(1);
+    }
+
+    // (a) revert branch exists, tip is a revert(FN-A): commit carrying the trailer.
+    const branchTipSubject = git(repo, "git log -1 --format=%s fusion/revert-fn-a");
+    expect(branchTipSubject).toMatch(/^revert\(FN-A\):/);
+    const branchTipBody = git(repo, "git log -1 --format=%B fusion/revert-fn-a");
+    expect(branchTipBody).toContain("Fusion-Task-Id: FN-A");
+    expect(git(repo, "git show fusion/revert-fn-a:foo.ts")).toBe("line1");
+
+    // (b) main HEAD is byte-identical to before the call — base never written.
+    expect(git(repo, "git rev-parse main")).toBe(mainHeadBefore);
+
+    // (c) checkout restored to main and clean.
+    expect(git(repo, "git rev-parse --abbrev-ref HEAD")).toBe("main");
+    expect(git(repo, "git status --porcelain")).toBe("");
+  });
+
+  it("conflicting → pass-through: no revert branch left behind, base + checkout unchanged", async () => {
+    const repo = repoFixture();
+    writeFileSync(join(repo, "foo.ts"), "line1\nfeature-a\n");
+    git(repo, "git add foo.ts && git commit -m 'feat(FN-A): add feature a'");
+    const shaA = git(repo, "git rev-parse HEAD");
+
+    // Task B later modifies the exact same region touched by task A.
+    writeFileSync(join(repo, "foo.ts"), "line1\nfeature-a-modified-by-b\n");
+    git(repo, "git commit -am 'feat(FN-B): modify same region'");
+
+    const mainHeadBefore = git(repo, "git rev-parse main");
+    const statusBefore = git(repo, "git status --porcelain");
+
+    const task = makeTask({ mergeDetails: { commitSha: shaA, mergeTargetBranch: "main" } });
+    const result = await prepareRevertPrBranch({
+      task,
+      worktreePath: repo,
+      baseBranch: "main",
+      revertBranch: "fusion/revert-fn-a",
+    });
+
+    expect(result).toMatchObject({ eligible: false, classification: "conflicting" });
+    if (!result.eligible && result.classification === "conflicting") {
+      expect(result.conflicts.length).toBeGreaterThan(0);
+      expect(result.conflicts.some((c) => c.file === "foo.ts")).toBe(true);
+    }
+
+    const branchList = git(repo, "git branch --list fusion/revert-fn-a");
+    expect(branchList).toBe("");
+    expect(git(repo, "git rev-parse main")).toBe(mainHeadBefore);
+    expect(git(repo, "git rev-parse --abbrev-ref HEAD")).toBe("main");
+    expect(git(repo, "git status --porcelain")).toBe(statusBefore);
+  });
+
+  it("already-reverted → pass-through: no branch, base unchanged", async () => {
+    const repo = repoFixture();
+    writeFileSync(join(repo, "foo.ts"), "line1\nfeature-a\n");
+    git(repo, "git add foo.ts && git commit -m 'feat(FN-A): add feature a'");
+    const sha = git(repo, "git rev-parse HEAD");
+
+    // Manually revert the change on main before calling prepareRevertPrBranch.
+    git(repo, `git revert --no-edit ${sha}`);
+    const mainHeadBefore = git(repo, "git rev-parse main");
+
+    const task = makeTask({ mergeDetails: { commitSha: sha, mergeTargetBranch: "main" } });
+    const result = await prepareRevertPrBranch({
+      task,
+      worktreePath: repo,
+      baseBranch: "main",
+      revertBranch: "fusion/revert-fn-a",
+    });
+
+    expect(result).toMatchObject({ eligible: false, classification: "already-reverted", alreadyReverted: true });
+    const branchList = git(repo, "git branch --list fusion/revert-fn-a");
+    expect(branchList).toBe("");
+    expect(git(repo, "git rev-parse main")).toBe(mainHeadBefore);
+    expect(git(repo, "git rev-parse --abbrev-ref HEAD")).toBe("main");
+  });
+
+  it("workspace unsupported: a task with workspaceWorktrees populated is refused", async () => {
+    const repo = repoFixture();
+    const task = makeTask({
+      workspaceWorktrees: { "repo-a": { worktreePath: "/tmp/whatever", branch: "main" } },
+    });
+    const result = await prepareRevertPrBranch({
+      task,
+      worktreePath: repo,
+      baseBranch: "main",
+      revertBranch: "fusion/revert-fn-a",
+    });
+    expect(result).toMatchObject({ eligible: false, unsupported: true, reason: "workspace-task-pr-revert-unsupported" });
+  });
+
+  it("idempotent local branch reset: a stale local branch pointing elsewhere is reset off base with the fresh revert commit", async () => {
+    const repo = repoFixture();
+    writeFileSync(join(repo, "foo.ts"), "line1\nfeature-a\n");
+    git(repo, "git add foo.ts && git commit -m 'feat(FN-A): add feature a'");
+    const sha = git(repo, "git rev-parse HEAD");
+
+    // Pre-create a stale local branch pointing at an unrelated commit.
+    git(repo, "git branch fusion/revert-fn-a main~1");
+    const staleTip = git(repo, "git rev-parse fusion/revert-fn-a");
+    expect(staleTip).not.toBe(git(repo, "git rev-parse main"));
+
+    const task = makeTask({ mergeDetails: { commitSha: sha, mergeTargetBranch: "main" } });
+    const result = await prepareRevertPrBranch({
+      task,
+      worktreePath: repo,
+      baseBranch: "main",
+      revertBranch: "fusion/revert-fn-a",
+    });
+
+    expect(result).toMatchObject({ eligible: true });
+    const branchTipSubject = git(repo, "git log -1 --format=%s fusion/revert-fn-a");
+    expect(branchTipSubject).toMatch(/^revert\(FN-A\):/);
+    expect(git(repo, "git rev-parse --abbrev-ref HEAD")).toBe("main");
+  });
+
+  it("dirty-tree refusal: a stray staged change is refused without any branch/base mutation", async () => {
+    const repo = repoFixture();
+    writeFileSync(join(repo, "foo.ts"), "line1\nfeature-a\n");
+    git(repo, "git add foo.ts && git commit -m 'feat(FN-A): add feature a'");
+    const sha = git(repo, "git rev-parse HEAD");
+
+    writeFileSync(join(repo, "stray.txt"), "stray change\n");
+    git(repo, "git add stray.txt");
+
+    const mainHeadBefore = git(repo, "git rev-parse main");
+    const preStatus = git(repo, "git status --porcelain");
+
+    const task = makeTask({ mergeDetails: { commitSha: sha, mergeTargetBranch: "main" } });
+    await expect(
+      prepareRevertPrBranch({ task, worktreePath: repo, baseBranch: "main", revertBranch: "fusion/revert-fn-a" }),
+    ).rejects.toThrow();
+
+    const branchList = git(repo, "git branch --list fusion/revert-fn-a");
+    expect(branchList).toBe("");
+    expect(git(repo, "git rev-parse main")).toBe(mainHeadBefore);
+    expect(git(repo, "git status --porcelain")).toBe(preStatus);
+  });
+});
diff --git a/packages/engine/src/index.ts b/packages/engine/src/index.ts
index 07df194aa3..90721e2a4e 100644
--- a/packages/engine/src/index.ts
+++ b/packages/engine/src/index.ts
@@ -292,6 +292,9 @@ export {
   type WorkspaceRepoRevertResult,
   type WorkspaceTaskRevertResult,
   type RevertWorkspaceTaskOptions,
+  prepareRevertPrBranch,
+  type PrepareRevertPrBranchResult,
+  type PrepareRevertPrBranchOptions,
 } from "./task-revert.js";
 export {
   resolveBranchGroupMergeRouting,
diff --git a/packages/engine/src/task-revert.ts b/packages/engine/src/task-revert.ts
index e1c64537f6..7897beb377 100644
--- a/packages/engine/src/task-revert.ts
+++ b/packages/engine/src/task-revert.ts
@@ -756,6 +756,160 @@ async function applyAndCommitRevert(opts: {
   }
 }
 
+// ---------------------------------------------------------------------------
+// FN-7554: PR-based revert for autoMerge:false projects.
+// ---------------------------------------------------------------------------
+
+export type PrepareRevertPrBranchResult =
+  | { eligible: true; revertBranch: string; revertCommitShas: string[] }
+  | { eligible: false; classification: "conflicting"; conflicts: TaskRevertConflict[] }
+  | { eligible: false; classification: "already-reverted"; alreadyReverted: true }
+  | { eligible: false; unsupported: true; reason: string };
+
+export interface PrepareRevertPrBranchOptions {
+  task: Pick<Task, "id" | "lineageId" | "column" | "mergeDetails" | "workspaceWorktrees">;
+  /** The shared checkout, verified on `baseBranch` by the caller before this is invoked. */
+  worktreePath: string;
+  /** Resolved mergeTargetBranch / integration branch. NEVER written to — see the doc comment below. */
+  baseBranch: string;
+  /** e.g. `fusion/revert-<task-id-lowercase>`. */
+  revertBranch: string;
+  execAsyncImpl?: ExecAsyncImpl;
+  commitAssociationSource?: TaskCommitAssociationSource;
+}
+
+/**
+ * FNXC:TaskRevert 2026-07-05-00:00 (FN-7554 — PR-based revert for
+ * autoMerge:false projects):
+ *
+ * `performTaskRevert` refuses (`needsHuman`) whenever autoMerge is
+ * effectively off, because it commits directly onto `worktreePath`'s current
+ * HEAD branch (the base branch) and this project has opted that branch out
+ * of automated writes. This function gives that dead end an actionable path:
+ * it prepares a DEDICATED `revertBranch` off `baseBranch`'s HEAD, applies the
+ * revert commit(s) onto THAT branch only, and leaves `baseBranch` itself
+ * completely untouched — the caller (the API route) then pushes the branch
+ * and opens a real GitHub PR against `baseBranch`, so the change still lands
+ * through the project's normal human-review flow instead of a forced write.
+ *
+ * NEVER-WRITE-TO-BASE INVARIANT: this function only ever mutates
+ * `revertBranch`. `baseBranch`'s ref is never advanced, reset, or committed
+ * to. The shared checkout (`worktreePath`) is ALWAYS restored to the branch
+ * it was on when this function was called (`originalBranch`), in a `finally`
+ * — regardless of success, classification pass-through, or thrown failure —
+ * so a caller that shares this checkout across requests never observes it
+ * left mid-revert on `revertBranch`.
+ *
+ * REUSE, NOT REIMPLEMENTATION: commit application/message/trailer generation
+ * is delegated entirely to the shared `applyAndCommitRevert` helper (the same
+ * one `performTaskRevert`'s squash path and `revertWorkspaceTask` use) — this
+ * function only adds the branch-prep/checkout-restore choreography around it.
+ *
+ * WORKSPACE DEFERRAL: workspace (multi-repo) tasks are refused with
+ * `{ eligible: false, unsupported: true, reason: "workspace-task-pr-revert-unsupported" }`
+ * — a single PR against a single base branch cannot coherently represent a
+ * multi-repo, multi-branch revert. PR-based workspace revert is explicitly
+ * out of scope here (see the FN-7554 PROMPT's Step 6 follow-up task).
+ */
+export async function prepareRevertPrBranch(opts: PrepareRevertPrBranchOptions): Promise<PrepareRevertPrBranchResult> {
+  const { task, worktreePath, baseBranch, revertBranch } = opts;
+  const execImpl = opts.execAsyncImpl ?? defaultExecAsync;
+
+  if (isWorkspaceTask(task)) {
+    return { eligible: false, unsupported: true, reason: "workspace-task-pr-revert-unsupported" };
+  }
+
+  const resolved = await resolveTaskRevertCommits(task, {
+    worktreePath,
+    execAsyncImpl: execImpl,
+    commitAssociationSource: opts.commitAssociationSource,
+  });
+  if (!resolved.supported) {
+    return { eligible: false, unsupported: true, reason: resolved.reason };
+  }
+
+  const classification = await classifyTaskRevert({
+    worktreePath,
+    commits: resolved.shas,
+    execAsyncImpl: execImpl,
+  });
+
+  if (classification.classification === "already-reverted") {
+    return { eligible: false, classification: "already-reverted", alreadyReverted: true };
+  }
+  if (classification.classification === "conflicting") {
+    return { eligible: false, classification: "conflicting", conflicts: classification.conflicts ?? [] };
+  }
+
+  // classification === "clean" — prepare the dedicated revert branch.
+  let originalBranch: string;
+  try {
+    const { stdout } = await runGit(execImpl, "git rev-parse --abbrev-ref HEAD", worktreePath);
+    originalBranch = stdout.trim();
+  } catch (error) {
+    throw new TaskRevertError("failed to resolve current branch before preparing revert PR branch", "head-resolve-failed", error);
+  }
+
+  const { stdout: statusOut } = await runGit(execImpl, "git status --porcelain", worktreePath);
+  if (statusOut.trim().length > 0) {
+    throw new TaskRevertError(
+      "working tree is dirty; refusing to prepare a revert PR branch",
+      "dirty-working-tree",
+    );
+  }
+
+  let branchCreated = false;
+  try {
+    // FNXC:TaskRevert 2026-07-05-00:00: `-B` (create-or-reset) makes re-running
+    // this idempotent when a stale local `revertBranch` already exists from a
+    // prior failed/aborted attempt — it is reset off `baseBranch` HEAD rather
+    // than accumulating on top of whatever it previously pointed at. `baseBranch`
+    // itself is only ever read here (`git checkout -B <revertBranch> <baseBranch>`
+    // does not move `baseBranch`'s ref).
+    await runGit(
+      execImpl,
+      `git checkout -B ${quoteShellArg(revertBranch)} ${quoteShellArg(baseBranch)}`,
+      worktreePath,
+    );
+    branchCreated = true;
+
+    const applied = await applyAndCommitRevert({
+      worktreePath,
+      commits: resolved.shas,
+      taskId: task.id,
+      execAsyncImpl: execImpl,
+    });
+
+    if ("alreadyReverted" in applied) {
+      // Defensive: the branch moved between classify and apply. Nothing to
+      // commit on the fresh revertBranch — treat as already-reverted.
+      return { eligible: false, classification: "already-reverted", alreadyReverted: true };
+    }
+    if ("conflicts" in applied) {
+      // Late conflict — applyAndCommitRevert already rolled worktreePath back
+      // to the pre-apply HEAD (the tip of revertBranch, i.e. baseBranch's HEAD).
+      return { eligible: false, classification: "conflicting", conflicts: applied.conflicts };
+    }
+
+    return { eligible: true, revertBranch, revertCommitShas: [applied.revertCommitSha] };
+  } catch (error) {
+    // On any thrown failure after branch creation, never leave a dangling
+    // partial revert branch behind — best-effort restore + delete.
+    if (branchCreated) {
+      await runGit(execImpl, `git checkout ${quoteShellArg(originalBranch)}`, worktreePath).catch(() => undefined);
+      await runGit(execImpl, `git branch -D ${quoteShellArg(revertBranch)}`, worktreePath).catch(() => undefined);
+    }
+    throw error instanceof TaskRevertError ? error : new TaskRevertError("failed to prepare revert PR branch", "revert-pr-branch-prepare-failed", error);
+  } finally {
+    // FNXC:TaskRevert 2026-07-05-00:00: ALWAYS restore the shared checkout to
+    // the branch it was on when this function was called, so the checkout is
+    // left exactly where it started — on `baseBranch` (unmutated) in the
+    // documented caller contract — regardless of success/pass-through/failure
+    // above. The revert commit(s) live ONLY on `revertBranch`.
+    await runGit(execImpl, `git checkout ${quoteShellArg(originalBranch)}`, worktreePath).catch(() => undefined);
+  }
+}
+
 export interface WorkspaceRepoRevertCommits {
   commits: string[];
   source: TaskRevertCommitSource;

From 94e9d15e38e0321db52477f3590a8edccd8251c3 Mon Sep 17 00:00:00 2001
From: gsxdsm <gsxdsm@users.noreply.github.com>
Date: Sun, 5 Jul 2026 10:27:03 -0700
Subject: [PATCH 26/65] FN-7556: auto-select review-heavy workflow for AI-undo
 tasks

AI-undo tasks now default to a configurable, stricter review workflow instead of always inheriting the project default.

- Add project setting `aiUndoTaskWorkflowId` (default `builtin:review-heavy`) to ProjectSettings type and DEFAULT_PROJECT_SETTINGS
- `POST /api/tasks/:id/revert` resolves and validates the configured workflow id (via `isBuiltinWorkflowId`/`getWorkflowDefinition`), falling back to inherit-with-warning on a blank/unknown value
- `createAiUndoTask` engine helper gains an optional `workflowId` param, forwarded verbatim to `createTask` only when non-blank, staying pure (no settings/store access itself)
- Add regression tests for the route resolution logic and the engine helper's workflow forwarding
- Update docs (`settings-reference.md`, `task-management.md`) and add changeset

Files changed:
 .changeset/fn-7556-ai-undo-workflow.md             |  7 +++
 docs/settings-reference.md                         |  1 +
 docs/task-management.md                            |  1 +
 packages/core/src/settings-schema.ts               |  4 ++
 packages/core/src/types.ts                         | 14 +++++
 .../settings-default-descriptions.test.tsx         |  2 +
 .../src/__tests__/task-revert-route.test.ts        | 52 ++++++++++++++++-
 .../src/routes/register-task-workflow-routes.ts    | 31 +++++++++-
 .../src/__tests__/task-revert-ai-undo.test.ts      | 67 ++++++++++++++++++++++
 packages/engine/src/task-revert.ts                 | 16 ++++++
 10 files changed, 192 insertions(+), 3 deletions(-)

Fusion-Task-Id: FN-7556
Fusion-Task-Lineage: dec5603c-10a8-4780-a1b8-8a836a0de4c1
Co-authored-by: Fusion (runfusion.ai) <noreply@runfusion.ai>
---
 .changeset/fn-7556-ai-undo-workflow.md        |  7 ++
 docs/settings-reference.md                    |  1 +
 docs/task-management.md                       |  1 +
 packages/core/src/settings-schema.ts          |  4 ++
 packages/core/src/types.ts                    | 14 ++++
 .../settings-default-descriptions.test.tsx    |  2 +
 .../src/__tests__/task-revert-route.test.ts   | 52 +++++++++++++-
 .../routes/register-task-workflow-routes.ts   | 31 ++++++++-
 .../src/__tests__/task-revert-ai-undo.test.ts | 67 +++++++++++++++++++
 packages/engine/src/task-revert.ts            | 16 +++++
 10 files changed, 192 insertions(+), 3 deletions(-)
 create mode 100644 .changeset/fn-7556-ai-undo-workflow.md

diff --git a/.changeset/fn-7556-ai-undo-workflow.md b/.changeset/fn-7556-ai-undo-workflow.md
new file mode 100644
index 0000000000..b087f540ba
--- /dev/null
+++ b/.changeset/fn-7556-ai-undo-workflow.md
@@ -0,0 +1,7 @@
+---
+"@runfusion/fusion": minor
+---
+
+summary: AI-undo tasks now default to a configurable, stricter review workflow.
+category: feature
+dev: New project setting `aiUndoTaskWorkflowId` (default `builtin:review-heavy`) selects the workflow for AI-undo board tasks created by `POST /api/tasks/:id/revert` (`mode: "ai"`, the `auto` conflict fallback, and the workspace conflict fallback all share the `createAiUndoResult()` closure, so all three inherit this default). A blank/unset value means the created task inherits the project default workflow (pre-FN-7556 behavior). The route validates the configured id via `getWorkflowDefinition`/`isBuiltinWorkflowId` and falls back to inherit (with a logged warning) on a blank or unknown value, so a misconfigured id never breaks AI-undo task creation. The engine's `createAiUndoTask` helper stays pure — it only forwards a `workflowId` it is given, never resolves the setting itself. The Settings Modal UI field for this setting is a deliberate follow-up task; the value is settable today only via the settings API.
diff --git a/docs/settings-reference.md b/docs/settings-reference.md
index a6054519a3..ff1f3ceb10 100644
--- a/docs/settings-reference.md
+++ b/docs/settings-reference.md
@@ -412,6 +412,7 @@ Security-sensitive file-browser escape hatches are project-only. `allowAbsoluteF
 | `secretsEnv` | `{ enabled?: boolean; filename?: string; overwritePolicy?: "skip" \| "merge" \| "replace"; keyPrefix?: string; requireGitignored?: boolean }` | `undefined` | Per-project secrets `.env` materialization configuration. When `enabled`, the engine writes `secretsEnv.filename` (default `.env`) into each acquired task worktree from secrets marked `env_exportable=true`. `overwritePolicy` controls merge/skip/replace against an existing file; `requireGitignored` (default `true`) refuses to write a non-gitignored path; `keyPrefix` filters which exported keys are included. See [Secrets](./secrets.md#env-auto-write-into-worktrees). |
 | `mcpServers` | `McpServersSettings` | `{ enabled: false, servers: [] }` | Project-scoped MCP server settings. Project entries override global entries by `name`; `enabled:false` on a same-named project entry disables the inherited global server. Sensitive env/header/token material must be Fusion secret references only. See [MCP server settings](#mcp-server-settings). |
 | `owningNodeHandoffPolicy` | `"block" \| "reassign-to-local" \| "reassign-any-healthy"` | `"reassign-to-local"` | Policy for tasks already checked out by an unavailable owning node. `"block"` parks, `"reassign-to-local"` takes over on local node, `"reassign-any-healthy"` makes takeover eligible on healthy peers. |
+| `aiUndoTaskWorkflowId` | `string` | `"builtin:review-heavy"` | **FN-7556.** Workflow selected for AI-undo board tasks created by `POST /api/tasks/:id/revert` (`mode: "ai"` and the `auto`/workspace conflict fallbacks) — a stricter review posture since these tasks reverse already-shipped code. Blank/unset means the created task inherits the project default workflow. The route validates the configured id and falls back to inherit on a blank or unknown value, so a misconfigured id never breaks AI-undo task creation. Settings Modal UI for this field is a follow-up; today it is settable only through the settings API. See [Task Management → Reverting Done/Archived tasks](./task-management.md#reverting-donearchived-tasks-git-path--ai-undo-fallback). |
 
 | `groupOverlappingFiles` | `boolean` | `true` | Serialize execution when file scopes overlap. |
 | `pluginTrustPolicy` | `"off" | "warn" | "enforce"` | `"warn"` | Plugin provenance enforcement mode: `off` records verification metadata only, `warn` blocks only `invalid` signatures, `enforce` allows only `verified-trusted` or `trusted-local`. |
diff --git a/docs/task-management.md b/docs/task-management.md
index a3890b2ea8..9ce641f8bb 100644
--- a/docs/task-management.md
+++ b/docs/task-management.md
@@ -687,6 +687,7 @@ Recovery/backfill guidance:
 - **Workspace (multi-repo) tasks (FN-7547):** tasks with `workspaceWorktrees` populated (`isWorkspaceTask`) are revertable too — the route dispatches to a dedicated workspace path that reasons about every sub-repo's integration branch as ONE all-or-nothing unit. It resolves each sub-repo's attributable commit(s), dry-run classifies every sub-repo first, and only commits a `revert(FN-xxxx): ...` commit on EACH sub-repo when every sub-repo classifies clean/already-reverted; if any sub-repo conflicts, no sub-repo is committed and every touched sub-repo worktree is rolled back to its pre-call state. Response contract for workspace tasks: `{ mode: "git", clean, workspace: { repos: [{ repo, classification, revertCommitSha?, conflicts?, alreadyReverted? }] }, conflicts?: {repo, file, ...}[] }`. A conflicting workspace result still falls back to the AI-undo task under `"auto"` mode, same as a single-repo conflicting result.
 - **`autoMerge:false` PR-based revert (FN-7554):** for a single-repo task whose git revert classifies **clean**, `autoMerge:false` no longer dead-ends at `needsHuman`. The route prepares a dedicated `fusion/revert-<id>` branch off the resolved base branch (via the engine's `prepareRevertPrBranch`, which NEVER writes to the base branch itself), pushes it, and opens a GitHub PR through the same owner/repo resolution, `githubRateLimiter` gate, `findPrForBranch` idempotency, and `manual: true` handoff as `POST /tasks/:id/pr/create`. Response: `{ mode: "pr", clean: true, prUrl, prNumber, revertBranch, existingPr? }` — a second call while the PR is still open links the existing PR (`existingPr: true`) instead of re-pushing. GitHub unconfigured or rate-limited still degrades gracefully to `{ mode: "git", needsHuman: true, reason }`, and a conflicting/unsupported/already-reverted classification is unaffected (no PR is opened; `"auto"` mode still falls back to the AI-undo task on conflict/unsupported). Workspace (multi-repo) tasks are not yet covered by this PR path — they keep the existing `needsHuman` result under `autoMerge:false`.
 - **Dashboard auto-linking (FN-7555):** the AI-undo task's card shows an "Undo of FN-xxxx" chip and its detail view shows a clickable "Created to undo FN-xxxx" link back to the source task. The source task's detail view shows an "Undo task: FN-YYYY" link whenever an OPEN undo task referencing it exists in the loaded tasks (matching `TaskStore.findOpenRevertTaskForSource`'s open-only semantics — a `done`/`archived`/soft-deleted undo task is never surfaced as active). Both directions are derived client-side from `sourceMetadata.revertOf`; no new API. A dedicated Done/Archived card revert-trigger action is still a separate follow-up (see FN-7525).
+- **Configurable AI-undo workflow default (FN-7556):** the project setting `aiUndoTaskWorkflowId` (default `builtin:review-heavy`) selects the workflow applied to every AI-undo task created above (`mode:"ai"` and the `auto`/workspace conflict fallbacks all share one creation seam, so all three inherit this default) — a stricter review posture is warranted because these tasks reverse already-shipped code. A blank/unset value means the created task inherits the project default workflow (pre-FN-7556 behavior); the route falls back to inherit (with a logged warning) if the configured id is blank or does not resolve to a real workflow, so a misconfigured id never breaks AI-undo task creation. See [Settings Reference → Project Settings](./settings-reference.md#project-settings). The Settings Modal UI field for this setting is a deliberate follow-up; it is settable today only via the settings API.
 
 
 ## GitHub Issue Import and PR Creation
diff --git a/packages/core/src/settings-schema.ts b/packages/core/src/settings-schema.ts
index 77aef733a4..dae587d621 100644
--- a/packages/core/src/settings-schema.ts
+++ b/packages/core/src/settings-schema.ts
@@ -296,6 +296,10 @@ export const DEFAULT_PROJECT_SETTINGS = {
   globalPause: false,
   globalPauseReason: undefined,
   defaultWorkflowId: undefined,
+  // FNXC:TaskRevert 2026-07-05-00:00 (FN-7556): AI-undo tasks reverse
+  // already-shipped code, so default them to the stricter review-heavy
+  // workflow; empty/unset means inherit the project default workflow.
+  aiUndoTaskWorkflowId: "builtin:review-heavy",
   enabledBuiltinWorkflowIds: undefined,
   approvedWorkflowCliCommands: undefined,
   approvedCliAutonomyAdapters: undefined,
diff --git a/packages/core/src/types.ts b/packages/core/src/types.ts
index a783a8cf13..a9e69963ce 100644
--- a/packages/core/src/types.ts
+++ b/packages/core/src/types.ts
@@ -3673,6 +3673,20 @@ export interface ProjectSettings {
   /** Default custom workflow (WF-…) applied to newly created tasks when the
    *  caller does not specify enabledWorkflowSteps. Overridable per task. */
   defaultWorkflowId?: string;
+  /**
+   * FNXC:TaskRevert 2026-07-05-00:00 (FN-7556):
+   * Workflow selected for AI-undo board tasks (`createAiUndoTask`, engine
+   * `task-revert.ts`) — these tasks surgically reverse ALREADY-SHIPPED code
+   * while preserving unrelated later changes to the same files, so they
+   * warrant a stricter default review posture than ordinary new work.
+   * Defaults to `builtin:review-heavy` (see `DEFAULT_PROJECT_SETTINGS`).
+   * Empty/unset means AI-undo tasks inherit the project default workflow
+   * (today's pre-FN-7556 behavior). The route resolving this setting
+   * (`POST /api/tasks/:id/revert`) validates the configured id exists and
+   * falls back to inherit (undefined) on a blank/unknown value so a
+   * misconfigured id never breaks AI-undo task creation.
+   */
+  aiUndoTaskWorkflowId?: string;
   /** Built-in workflow ids visible/selectable in project workflow pickers.
    *  Undefined preserves the default of showing every built-in workflow. */
   enabledBuiltinWorkflowIds?: string[];
diff --git a/packages/dashboard/app/components/settings/sections/__tests__/settings-default-descriptions.test.tsx b/packages/dashboard/app/components/settings/sections/__tests__/settings-default-descriptions.test.tsx
index 77ae215c71..645c1fb262 100644
--- a/packages/dashboard/app/components/settings/sections/__tests__/settings-default-descriptions.test.tsx
+++ b/packages/dashboard/app/components/settings/sections/__tests__/settings-default-descriptions.test.tsx
@@ -468,6 +468,8 @@ const NOT_SURFACED_ALLOWLIST: Record<string, string> = {
   prerebaseDivergenceThreshold: "internal pre-rebase tuning constant, no UI field",
   maxSpawnedAgentsPerParent: "internal spawn-limit constant, no UI field",
   maxSpawnedAgentsGlobal: "internal spawn-limit constant, no UI field",
+  // FN-7556: AI-undo workflow default — Settings UI is a follow-up task.
+  aiUndoTaskWorkflowId: "AI-undo workflow default — Settings UI is a follow-up task",
 };
 
 describe("FN-7505 settings default-value description guard", () => {
diff --git a/packages/dashboard/src/__tests__/task-revert-route.test.ts b/packages/dashboard/src/__tests__/task-revert-route.test.ts
index 0e60955724..2566b1210d 100644
--- a/packages/dashboard/src/__tests__/task-revert-route.test.ts
+++ b/packages/dashboard/src/__tests__/task-revert-route.test.ts
@@ -108,7 +108,13 @@ function makeWorkspaceTask(overrides: Partial<Task>): Task {
 
 function createMockStore(
   task: Task,
-  opts?: { openUndoTask?: Task | null; createdUndoTask?: Task; autoMerge?: boolean },
+  opts?: {
+    openUndoTask?: Task | null;
+    createdUndoTask?: Task;
+    autoMerge?: boolean;
+    aiUndoTaskWorkflowId?: string;
+    knownWorkflowIds?: string[];
+  },
 ): TaskStore {
   let nextId = 800;
   const createTask = vi.fn().mockImplementation(async (input: { description: string; source?: { sourceParentTaskId?: string; sourceMetadata?: Record<string, unknown> } }) => {
@@ -126,9 +132,19 @@ function createMockStore(
     return created;
   });
   const findOpenRevertTaskForSource = vi.fn().mockResolvedValue(opts?.openUndoTask ?? null);
+  // FN-7556: `getWorkflowDefinition` backs the route's validation of a
+  // configured (non-builtin) `aiUndoTaskWorkflowId`; default to "unknown" so
+  // tests must explicitly declare a custom id as known via `knownWorkflowIds`.
+  const getWorkflowDefinition = vi.fn().mockImplementation(async (id: string) =>
+    (opts?.knownWorkflowIds ?? []).includes(id) ? { id, name: id, ir: {} } : undefined,
+  );
   return {
     getSettings: vi.fn().mockResolvedValue({}),
-    getSettingsFast: vi.fn().mockResolvedValue({ autoMerge: opts?.autoMerge ?? true }),
+    getSettingsFast: vi.fn().mockResolvedValue({
+      autoMerge: opts?.autoMerge ?? true,
+      aiUndoTaskWorkflowId: opts?.aiUndoTaskWorkflowId,
+    }),
+    getWorkflowDefinition,
     getRootDir: vi.fn().mockReturnValue(makeGitRepoOnMain()),
     getTask: vi.fn().mockResolvedValue(task),
     getTaskCommitAssociationsByLineageId: vi.fn().mockResolvedValue([]),
@@ -399,6 +415,38 @@ describe("POST /tasks/:id/revert — FN-7524 mode + AI-undo fallback", () => {
     expect(store.createTask as ReturnType<typeof vi.fn>).not.toHaveBeenCalled();
   });
 
+  it("(FN-7556) forwards the configured aiUndoTaskWorkflowId (default review-heavy) into the created AI-undo task", async () => {
+    const task = makeTask({ id: "FN-970", column: "done" });
+    const store = createMockStore(task, { aiUndoTaskWorkflowId: "builtin:review-heavy" });
+
+    const res = await POST_JSON(createApp(store), `/api/tasks/${task.id}/revert`, { mode: "ai" });
+    expect(res.status).toBe(200);
+    expect(store.createTask as ReturnType<typeof vi.fn>).toHaveBeenCalledTimes(1);
+    const createInput = (store.createTask as ReturnType<typeof vi.fn>).mock.calls[0][0] as { workflowId?: string };
+    expect(createInput.workflowId).toBe("builtin:review-heavy");
+  });
+
+  it("(FN-7556) a blank/unset aiUndoTaskWorkflowId omits workflowId so the task inherits the project default", async () => {
+    const task = makeTask({ id: "FN-971", column: "done" });
+    const store = createMockStore(task, { aiUndoTaskWorkflowId: "" });
+
+    const res = await POST_JSON(createApp(store), `/api/tasks/${task.id}/revert`, { mode: "ai" });
+    expect(res.status).toBe(200);
+    const createInput = (store.createTask as ReturnType<typeof vi.fn>).mock.calls[0][0] as { workflowId?: string };
+    expect("workflowId" in createInput).toBe(false);
+  });
+
+  it("(FN-7556) an unknown configured workflow id falls back to inherit (task still created, no 500)", async () => {
+    const task = makeTask({ id: "FN-972", column: "done" });
+    const store = createMockStore(task, { aiUndoTaskWorkflowId: "WF-does-not-exist", knownWorkflowIds: [] });
+
+    const res = await POST_JSON(createApp(store), `/api/tasks/${task.id}/revert`, { mode: "ai" });
+    expect(res.status).toBe(200);
+    expect(store.createTask as ReturnType<typeof vi.fn>).toHaveBeenCalledTimes(1);
+    const createInput = (store.createTask as ReturnType<typeof vi.fn>).mock.calls[0][0] as { workflowId?: string };
+    expect("workflowId" in createInput).toBe(false);
+  });
+
   it("(d) auto + clean: returns the git result and does NOT create an AI-undo task", async () => {
     const task = makeTask({ id: "FN-904", column: "done" });
     const store = createMockStore(task);
diff --git a/packages/dashboard/src/routes/register-task-workflow-routes.ts b/packages/dashboard/src/routes/register-task-workflow-routes.ts
index ec268d558c..5fe91460c9 100644
--- a/packages/dashboard/src/routes/register-task-workflow-routes.ts
+++ b/packages/dashboard/src/routes/register-task-workflow-routes.ts
@@ -45,6 +45,7 @@ import {
   isWorkflowColumnsEnabled,
   TransitionRejectionError,
   getPlannerInterventionTimeline,
+  isBuiltinWorkflowId,
   type NearDuplicateCandidate,
 } from "@fusion/core";
 import { GitHubClient } from "../github.js";
@@ -1744,11 +1745,40 @@ export function registerTaskWorkflowRoutes(ctx: ApiRoutesContext, deps: TaskWork
         granularity = requestedGranularity;
       }
 
+      /*
+      FNXC:TaskRevert 2026-07-05-00:00 (FN-7556):
+      `settings` is fetched HERE (before `createAiUndoResult` is defined/used)
+      because the `mode === "ai"` early-return path below uses the closure
+      before the git-path `settings` fetch that used to follow it. AI-undo
+      tasks default to the `aiUndoTaskWorkflowId` project setting (default
+      `builtin:review-heavy` — a stricter review posture than ordinary new
+      work, since these tasks reverse already-shipped code). A blank/whitespace
+      value means inherit the project default workflow; a non-blank value that
+      does not resolve to a real workflow (custom or builtin) is logged and
+      falls back to inherit too — a misconfigured id must never break AI-undo
+      task creation.
+      */
+      const settings = await scopedStore.getSettingsFast();
+      const configuredAiUndoWorkflowId = settings.aiUndoTaskWorkflowId?.trim();
+      let aiUndoWorkflowId: string | undefined;
+      if (configuredAiUndoWorkflowId) {
+        const exists =
+          isBuiltinWorkflowId(configuredAiUndoWorkflowId) || Boolean(await scopedStore.getWorkflowDefinition(configuredAiUndoWorkflowId));
+        if (exists) {
+          aiUndoWorkflowId = configuredAiUndoWorkflowId;
+        } else {
+          console.warn(
+            `[task-revert] aiUndoTaskWorkflowId "${configuredAiUndoWorkflowId}" does not resolve to a known workflow; AI-undo task will inherit the project default workflow instead`,
+          );
+        }
+      }
+
       const createAiUndoResult = async (): Promise<AiUndoTaskResult> =>
         createAiUndoTask({
           createTask: (input) => scopedStore.createTask(input),
           findOpenRevertTaskForSource: (id) => scopedStore.findOpenRevertTaskForSource(id),
           sourceTask: task,
+          workflowId: aiUndoWorkflowId,
         });
 
       if (mode === "ai") {
@@ -1757,7 +1787,6 @@ export function registerTaskWorkflowRoutes(ctx: ApiRoutesContext, deps: TaskWork
       }
 
       const rootDir = scopedStore.getRootDir();
-      const settings = await scopedStore.getSettingsFast();
 
       /*
       FNXC:TaskRevert 2026-07-04-00:00 (FN-7547 — workspace dispatch):
diff --git a/packages/engine/src/__tests__/task-revert-ai-undo.test.ts b/packages/engine/src/__tests__/task-revert-ai-undo.test.ts
index d4eadf5048..a10fd7ee0f 100644
--- a/packages/engine/src/__tests__/task-revert-ai-undo.test.ts
+++ b/packages/engine/src/__tests__/task-revert-ai-undo.test.ts
@@ -111,4 +111,71 @@ describe("createAiUndoTask (FN-7524)", () => {
     expect(result).toEqual({ mode: "ai", createdTaskId: "FN-955", alreadyOpen: true });
     expect(createTask).not.toHaveBeenCalled();
   });
+
+  it("forwards a non-blank workflowId into the createTask input (FN-7556)", async () => {
+    const createTask = vi.fn(async (input: TaskCreateInput) => makeExistingTask({
+      id: "FN-961",
+      description: input.description,
+      dependencies: input.dependencies ?? [],
+      sourceParentTaskId: input.source?.sourceParentTaskId,
+      sourceMetadata: input.source?.sourceMetadata,
+    }));
+    const findOpenRevertTaskForSource = vi.fn(async () => null);
+
+    const result = await createAiUndoTask({
+      createTask,
+      findOpenRevertTaskForSource,
+      sourceTask: makeSourceTask(),
+      workflowId: "builtin:review-heavy",
+    });
+
+    expect(result).toEqual({ mode: "ai", createdTaskId: "FN-961" });
+    const input = createTask.mock.calls[0][0] as TaskCreateInput;
+    expect(input.workflowId).toBe("builtin:review-heavy");
+  });
+
+  it("omits the workflowId key entirely when no/blank workflowId is supplied (inherit project default, FN-7556)", async () => {
+    const createTask = vi.fn(async (input: TaskCreateInput) => makeExistingTask({
+      id: "FN-962",
+      description: input.description,
+      dependencies: input.dependencies ?? [],
+      sourceParentTaskId: input.source?.sourceParentTaskId,
+      sourceMetadata: input.source?.sourceMetadata,
+    }));
+    const findOpenRevertTaskForSource = vi.fn(async () => null);
+
+    await createAiUndoTask({
+      createTask,
+      findOpenRevertTaskForSource,
+      sourceTask: makeSourceTask(),
+    });
+    const noWorkflowIdInput = createTask.mock.calls[0][0] as TaskCreateInput;
+    expect("workflowId" in noWorkflowIdInput).toBe(false);
+
+    createTask.mockClear();
+    await createAiUndoTask({
+      createTask,
+      findOpenRevertTaskForSource,
+      sourceTask: makeSourceTask(),
+      workflowId: "   ",
+    });
+    const blankWorkflowIdInput = createTask.mock.calls[0][0] as TaskCreateInput;
+    expect("workflowId" in blankWorkflowIdInput).toBe(false);
+  });
+
+  it("never creates a task on the idempotent alreadyOpen path regardless of workflowId (FN-7556)", async () => {
+    const createTask = vi.fn();
+    const existing = makeExistingTask({ id: "FN-963", column: "triage" });
+    const findOpenRevertTaskForSource = vi.fn(async () => existing);
+
+    const result = await createAiUndoTask({
+      createTask,
+      findOpenRevertTaskForSource,
+      sourceTask: makeSourceTask(),
+      workflowId: "builtin:review-heavy",
+    });
+
+    expect(result).toEqual({ mode: "ai", createdTaskId: "FN-963", alreadyOpen: true });
+    expect(createTask).not.toHaveBeenCalled();
+  });
 });
diff --git a/packages/engine/src/task-revert.ts b/packages/engine/src/task-revert.ts
index 7897beb377..47299fdb88 100644
--- a/packages/engine/src/task-revert.ts
+++ b/packages/engine/src/task-revert.ts
@@ -1307,6 +1307,17 @@ export interface CreateAiUndoTaskDeps {
   /** Idempotency lookup — see `REVERT_OF_METADATA_KEY`. Implemented by `TaskStore.findOpenRevertTaskForSource` (core). */
   findOpenRevertTaskForSource(sourceTaskId: string): Promise<Task | null>;
   sourceTask: Pick<Task, "id" | "title" | "description" | "prompt" | "mergeDetails" | "priority">;
+  /**
+   * FNXC:TaskRevert 2026-07-05-00:00 (FN-7556):
+   * Workflow id to select for the created AI-undo task, forwarded verbatim
+   * into `createTask({ workflowId })`. The CALLER (the route) resolves and
+   * validates this from the `aiUndoTaskWorkflowId` project setting (default
+   * `builtin:review-heavy`) — this helper stays pure and never reads
+   * settings/the store itself. A blank/undefined value means the created
+   * task INHERITS the project default workflow (`createTask`'s `undefined`
+   * semantics) — do NOT pass `null` here, which would mean "no workflow".
+   */
+  workflowId?: string;
 }
 
 /**
@@ -1326,6 +1337,10 @@ export async function createAiUndoTask(deps: CreateAiUndoTaskDeps): Promise<AiUn
   }
 
   const description = buildAiUndoTaskDescription({ task: sourceTask });
+  // FNXC:TaskRevert 2026-07-05-00:00 (FN-7556): forward `workflowId` ONLY when
+  // a non-empty string is supplied; otherwise omit the key entirely so
+  // `createTask` inherits the project default (never pass `null`/"" through).
+  const workflowId = deps.workflowId && deps.workflowId.trim() !== "" ? deps.workflowId : undefined;
   const created = await deps.createTask({
     title: `Undo ${sourceTask.id}: ${sourceTask.title ?? sourceTask.description.slice(0, 80)}`,
     description,
@@ -1335,6 +1350,7 @@ export async function createAiUndoTask(deps: CreateAiUndoTaskDeps): Promise<AiUn
       sourceType: "recovery",
       sourceMetadata: { [REVERT_OF_METADATA_KEY]: sourceTask.id },
     },
+    ...(workflowId !== undefined ? { workflowId } : {}),
   });
 
   return { mode: "ai", createdTaskId: created.id };

From e7cb2f1fed620180f16626d1ab41327ee4d01289 Mon Sep 17 00:00:00 2001
From: gsxdsm <gsxdsm@users.noreply.github.com>
Date: Sun, 5 Jul 2026 10:29:42 -0700
Subject: [PATCH 27/65] FN-7525: add Revert/Undo affordance to Done and
 Archived task cards

Adds a Revert action so operators can undo landed changes for Done/Archived tasks directly from the board.

- Adds onRevertTask wiring through Board, Column, Lane, ListView, TaskDetailModal, and WorktreeGroup surfaces
- Adds a Revert affordance to TaskCard (Done/Archived states) with confirm UX and CSS
- Adds POST /tasks/:id/revert legacy API route supporting "auto" mode with an AI-undo fallback (mode: "ai") on conflict
- Wires useTasks hook and dashboard MainContent/types to support the new revert action
- Adds new i18n strings for the revert affordance
- Adds a minor changeset for @runfusion/fusion documenting the feature
- Adds/updates tests: TaskCard.test.tsx, board-mobile.test.tsx, api-git.test.ts
- Updates docs/dashboard-guide.md and docs/task-management.md

Files changed:
 .changeset/fn-7525-revert-card-affordance.md       |   7 +
 docs/dashboard-guide.md                            |   2 +-
 docs/task-management.md                            |  10 ++
 packages/dashboard/app/App.tsx                     |   7 +-
 packages/dashboard/app/__tests__/api-git.test.ts   |  51 +++++++
 packages/dashboard/app/api/legacy.ts               |  51 +++++++
 packages/dashboard/app/components/AppModals.tsx    |   5 +-
 packages/dashboard/app/components/Board.tsx        |  10 +-
 packages/dashboard/app/components/Column.tsx       |   8 +-
 packages/dashboard/app/components/Lane.tsx         |   5 +-
 packages/dashboard/app/components/ListView.tsx     |  80 ++++++++++-
 packages/dashboard/app/components/TaskCard.css     |  24 +++-
 packages/dashboard/app/components/TaskCard.tsx     | 127 ++++++++++++++++-
 packages/dashboard/app/components/TaskDetailModal.tsx   |  85 ++++++++++++
 packages/dashboard/app/components/WorktreeGroup.tsx     |   6 +
 packages/dashboard/app/components/__tests__/TaskCard.test.tsx     | 151 +++++++++++++++++++++
 packages/dashboard/app/components/__tests__/board-mobile.test.tsx |  63 +++++++++
 packages/dashboard/app/components/dashboard/MainContent.tsx       |   4 +
 packages/dashboard/app/components/dashboard/types.ts    |   8 ++
 packages/dashboard/app/components/useRightDockController.tsx      |   4 +
 packages/dashboard/app/hooks/useTasks.ts           |  21 ++-
 packages/i18n/locales/en/app.json                  |  11 ++
 22 files changed, 718 insertions(+), 22 deletions(-)

Fusion-Task-Id: FN-7525

Fusion-Task-Lineage: b9e2ca94-4ec6-4443-8e41-cf4828018856

Co-authored-by: Fusion (runfusion.ai) <noreply@runfusion.ai>
---
 .changeset/fn-7525-revert-card-affordance.md  |   7 +
 docs/dashboard-guide.md                       |   2 +-
 docs/task-management.md                       |  10 ++
 packages/dashboard/app/App.tsx                |   7 +-
 .../dashboard/app/__tests__/api-git.test.ts   |  51 ++++++
 packages/dashboard/app/api/legacy.ts          |  51 ++++++
 .../dashboard/app/components/AppModals.tsx    |   5 +-
 packages/dashboard/app/components/Board.tsx   |  10 +-
 packages/dashboard/app/components/Column.tsx  |   8 +-
 packages/dashboard/app/components/Lane.tsx    |   5 +-
 .../dashboard/app/components/ListView.tsx     |  80 +++++++++-
 .../dashboard/app/components/TaskCard.css     |  24 ++-
 .../dashboard/app/components/TaskCard.tsx     | 127 ++++++++++++++-
 .../app/components/TaskDetailModal.tsx        |  85 ++++++++++
 .../app/components/WorktreeGroup.tsx          |   6 +
 .../components/__tests__/TaskCard.test.tsx    | 151 ++++++++++++++++++
 .../__tests__/board-mobile.test.tsx           |  63 ++++++++
 .../app/components/dashboard/MainContent.tsx  |   4 +
 .../app/components/dashboard/types.ts         |   8 +
 .../app/components/useRightDockController.tsx |   4 +
 packages/dashboard/app/hooks/useTasks.ts      |  21 ++-
 packages/i18n/locales/en/app.json             |  11 ++
 22 files changed, 718 insertions(+), 22 deletions(-)
 create mode 100644 .changeset/fn-7525-revert-card-affordance.md

diff --git a/.changeset/fn-7525-revert-card-affordance.md b/.changeset/fn-7525-revert-card-affordance.md
new file mode 100644
index 0000000000..2444d32ac2
--- /dev/null
+++ b/.changeset/fn-7525-revert-card-affordance.md
@@ -0,0 +1,7 @@
+---
+"@runfusion/fusion": minor
+---
+
+summary: Add a Revert action to Done/Archived task cards to undo landed changes.
+category: feature
+dev: Wires onRevertTask through Board/List/Detail surfaces; calls POST /tasks/:id/revert in "auto" mode with a conflict-confirm AI-undo fallback (mode: "ai").
diff --git a/docs/dashboard-guide.md b/docs/dashboard-guide.md
index 37a2e8cfff..8992295765 100644
--- a/docs/dashboard-guide.md
+++ b/docs/dashboard-guide.md
@@ -295,7 +295,7 @@ Behavior:
 - Renders directed bezier dependency edges (dependent → dependency) with arrowheads
 - Supports cursor-centered wheel zoom, pinch zoom, keyboard shortcuts (`Ctrl/Cmd+=`, `Ctrl/Cmd+-`, `Ctrl/Cmd+0`, `Ctrl/Cmd+Shift+F`, `Escape`), and fit/reset controls via the floating toolbar with live zoom percentage
 - Pan limits are zoom-aware and based on full graph extents (including negative auto-layout origins), so zoomed-in views can still pan to every rendered node instead of getting trapped by fixed viewport-only bounds
-- Dependency graph nodes reuse the same `TaskCard` UI as board/list views, so status badges, progress/steps, mission badges, retry/archive controls, and active-task glow stay visually consistent
+- Dependency graph nodes reuse the same `TaskCard` UI as board/list views, so status badges, progress/steps, mission badges, retry/archive/revert controls, and active-task glow stay visually consistent
 - Active graph nodes also add a dedicated top status indicator bar and current-step row highlighting so in-progress execution state stays visible even when zoomed out
 - Clicking a graph card opens task details in the shared movable/resizable task pop-out via the host detail handler (`onOpenDetail`, with `onOpenTaskDetail` fallback), while clicking the same card again or empty canvas clears selection.
 - On touch devices, single-tap is reserved for pan/drag gestures, so double-tapping a node opens the same shared task pop-out; this does not change selection state.
diff --git a/docs/task-management.md b/docs/task-management.md
index 9ce641f8bb..099d216fab 100644
--- a/docs/task-management.md
+++ b/docs/task-management.md
@@ -162,6 +162,16 @@ These appear in task activity history; run-audit entries are emitted where run c
 
 Recovery is reversible: restore archived tasks via dashboard **Unarchive** or `fn_task_unarchive`.
 
+#### Revert/Undo affordance (FN-7525)
+
+Done and Archived task cards (board card inline row + context menu, the detail view, and the list context menu) expose a **Revert** action alongside Archive/Unarchive when the task has a landed commit to revert. Clicking it calls `POST /tasks/:id/revert` in `"auto"` mode:
+
+- A clean git revert shows a success toast naming the created revert commit sha.
+- A conflicting/unsupported git result opens a confirm dialog offering to create an AI-undo task; confirming re-calls the route in `"ai"` mode and surfaces the created task id (or that an undo task is already open).
+- A `needsHuman` result (e.g. auto-merge is off) is surfaced as an informational/error toast, never silently forked into an AI task.
+
+The source task's column/lifecycle is never mutated as a side effect of a revert; the Revert affordance is absent when the task has no landed commit or when the hosting surface does not support it.
+
 ### 2) Plan Mode (AI interview)
 
 On desktop/tablet, open **Planning** from the left sidebar to start or resume a planning session. You can also hand a draft from the board quick-entry row or New Task dialog to Planning with the **Plan** action.
diff --git a/packages/dashboard/app/App.tsx b/packages/dashboard/app/App.tsx
index 0493e1ac5c..03532054fe 100644
--- a/packages/dashboard/app/App.tsx
+++ b/packages/dashboard/app/App.tsx
@@ -432,7 +432,7 @@ function AppInner() {
   // FNXC:DashboardLiveUpdates 2026-06-26-01:08:
   // SSE remains enabled only for board/list views to free connection slots for mission detail fetches. The false→true missed-event catch-up lives inside useTasks so App keeps the routing gate only and cannot double-fetch on task-view re-entry.
   const taskSseEnabled = taskView === "board" || taskView === "list";
-  const { tasks, isStale, createTask, moveTask, pauseTask, unpauseTask, deleteTask, mergeTask, retryTask, resetTask, updateTask, duplicateTask, archiveTask, unarchiveTask, archiveAllDone, loadArchivedTasks, ingestCreatedTasks, lastFetchTimeMs } = useTasks(
+  const { tasks, isStale, createTask, moveTask, pauseTask, unpauseTask, deleteTask, mergeTask, retryTask, resetTask, updateTask, duplicateTask, archiveTask, unarchiveTask, revertTask, archiveAllDone, loadArchivedTasks, ingestCreatedTasks, lastFetchTimeMs } = useTasks(
     {
       ...(currentProject ? { projectId: currentProject.id } : {}),
       searchQuery: searchQuery || undefined,
@@ -1241,7 +1241,7 @@ function AppInner() {
 
   // Props for the extracted <MainContent> switch (see components/dashboard/MainContent.tsx).
   // Every value is passed by its App name; the switch renders the same subtrees as before.
-  const rightDock = useRightDockController({ active: rightDockActive, projectId: currentProject?.id, addToast, settingsLoaded, researchReadinessVersion, goalAnchorId, tasks: isRemote && remoteData.tasks.length > 0 ? remoteData.tasks : tasks, workflowSteps, subscribePluginEvents, openDetailTask, openTaskPopup: popOutTaskDetail, openMobileTasksInPopup, openFileInBrowser, onMoveTask: moveTask, onDeleteTask: deleteTask, onArchiveTask: archiveTask, onMergeTask: mergeTask, onRetryTask: retryTask, onResetTask: resetTask, onDuplicateTask: duplicateTask, onTaskUpdated: (task: Task) => ingestCreatedTasks([task]), openSettings: (section?: string) => openSettingsWithNav(section as SectionId), onOpenUsage: openUsageWithNav, onOpenActivityLog: openActivityLogWithNav, onOpenGitHubImport: openGitHubImportWithNav, onOpenGitManager: openGitManagerWithNav, onOpenSchedules: openSchedulesWithNav, onSendSelectionToTask: modalManager.openNewTaskWithDescription, onCreateTaskFromInsight: handleInsightTaskCreate, onNavigateToMission: handleOpenMission, onTaskCreated: (task: Task) => ingestCreatedTasks([task]), prAuthAvailable, autoMerge, taskDetailChatFirst, visibilityOptions: { experimentalFeatures: { insights: insightsEnabled, memoryView: memoryEnabled, devServerView: devServerEnabled, researchView: researchEnabled, evalsView: evalsEnabled, goalsView: goalsEnabled }, showSkillsTab: skillsEnabled, todosEnabled, pluginDashboardViews }, footerVisible: executorFooterVisible });
+  const rightDock = useRightDockController({ active: rightDockActive, projectId: currentProject?.id, addToast, settingsLoaded, researchReadinessVersion, goalAnchorId, tasks: isRemote && remoteData.tasks.length > 0 ? remoteData.tasks : tasks, workflowSteps, subscribePluginEvents, openDetailTask, openTaskPopup: popOutTaskDetail, openMobileTasksInPopup, openFileInBrowser, onMoveTask: moveTask, onDeleteTask: deleteTask, onArchiveTask: archiveTask, onRevertTask: revertTask, onMergeTask: mergeTask, onRetryTask: retryTask, onResetTask: resetTask, onDuplicateTask: duplicateTask, onTaskUpdated: (task: Task) => ingestCreatedTasks([task]), openSettings: (section?: string) => openSettingsWithNav(section as SectionId), onOpenUsage: openUsageWithNav, onOpenActivityLog: openActivityLogWithNav, onOpenGitHubImport: openGitHubImportWithNav, onOpenGitManager: openGitManagerWithNav, onOpenSchedules: openSchedulesWithNav, onSendSelectionToTask: modalManager.openNewTaskWithDescription, onCreateTaskFromInsight: handleInsightTaskCreate, onNavigateToMission: handleOpenMission, onTaskCreated: (task: Task) => ingestCreatedTasks([task]), prAuthAvailable, autoMerge, taskDetailChatFirst, visibilityOptions: { experimentalFeatures: { insights: insightsEnabled, memoryView: memoryEnabled, devServerView: devServerEnabled, researchView: researchEnabled, evalsView: evalsEnabled, goalsView: goalsEnabled }, showSkillsTab: skillsEnabled, todosEnabled, pluginDashboardViews }, footerVisible: executorFooterVisible });
 
   /*
   FNXC:OpenTasksInRightSidebar 2026-06-28-00:00:
@@ -1382,6 +1382,7 @@ function AppInner() {
     retryTask,
     archiveTask,
     unarchiveTask,
+    revertTask,
     deleteTask,
     archiveAllDone,
     loadArchivedTasks,
@@ -1810,7 +1811,7 @@ function AppInner() {
         }}
         onPlanningMode={openPlanningWithInitialPlanWithNav}
         onSubtaskBreakdown={subtaskBreakdownEnabled ? openSubtaskBreakdownWithNav : undefined}
-        taskOperations={{ moveTask, deleteTask, mergeTask, archiveTask, retryTask, resetTask, duplicateTask }}
+        taskOperations={{ moveTask, deleteTask, mergeTask, archiveTask, revertTask, retryTask, resetTask, duplicateTask }}
         deepLink={{ handleDetailClose }}
         settings={{ prAuthAvailable, autoMerge, taskDetailChatFirst, themeMode, colorTheme, dashboardFontScalePct, shadcnCustomColors, resolvedThemeMode, setThemeMode, setColorTheme, setDashboardFontScalePct, setShadcnCustomColors, setQuickChatButtonModeImmediate }}
         onSettingsClose={handleSettingsCloseWithNav}
diff --git a/packages/dashboard/app/__tests__/api-git.test.ts b/packages/dashboard/app/__tests__/api-git.test.ts
index 154ca109ae..5db19d0e80 100644
--- a/packages/dashboard/app/__tests__/api-git.test.ts
+++ b/packages/dashboard/app/__tests__/api-git.test.ts
@@ -15,6 +15,7 @@ import {
   fetchAgentTasks,
   archiveTask,
   unarchiveTask,
+  revertTask,
   deleteTask,
   ApiRequestError,
   moveTask,
@@ -550,6 +551,56 @@ describe("Git Management API", () => {
     });
   });
 
+  /*
+  FNXC:TaskRevert 2026-07-05-00:00 (FN-7525):
+  Client-shape coverage for `revertTask` — the `POST /tasks/:id/revert` route
+  (FN-7523/FN-7524) contract. Asserts the JSON body is forwarded verbatim and
+  the parsed discriminated-union result (git or ai path) is returned as-is,
+  plus standard error propagation on a non-2xx response.
+  */
+  describe("revertTask", () => {
+    it("sends POST with the JSON mode body and returns the parsed git-path result", async () => {
+      const gitResult = { mode: "git", clean: true, revertCommitSha: "deadbeef1234" };
+      globalThis.fetch = vi.fn().mockReturnValue(mockFetchResponse(true, gitResult));
+
+      const response = await revertTask("FN-001", undefined, { mode: "auto" });
+
+      expect(response).toEqual(gitResult);
+      expect(globalThis.fetch).toHaveBeenCalledWith("/api/tasks/FN-001/revert", {
+        headers: { "Content-Type": "application/json" },
+        method: "POST",
+        body: JSON.stringify({ mode: "auto" }),
+      });
+    });
+
+    it("returns the parsed ai-path result", async () => {
+      const aiResult = { mode: "ai", createdTaskId: "FN-999" };
+      globalThis.fetch = vi.fn().mockReturnValue(mockFetchResponse(true, aiResult));
+
+      const response = await revertTask("FN-001", undefined, { mode: "ai" });
+
+      expect(response).toEqual(aiResult);
+    });
+
+    it("defaults to an empty JSON body when no options are provided", async () => {
+      globalThis.fetch = vi.fn().mockReturnValue(mockFetchResponse(true, { mode: "git", clean: true }));
+
+      await revertTask("FN-001");
+
+      expect(globalThis.fetch).toHaveBeenCalledWith("/api/tasks/FN-001/revert", {
+        headers: { "Content-Type": "application/json" },
+        method: "POST",
+        body: JSON.stringify({}),
+      });
+    });
+
+    it("throws on error propagation", async () => {
+      globalThis.fetch = vi.fn().mockReturnValue(mockFetchResponse(false, { error: "Task is in column \"todo\"" }, 409));
+
+      await expect(revertTask("FN-001")).rejects.toThrow('Task is in column "todo"');
+    });
+  });
+
   describe("deleteTask", () => {
     it("sends DELETE to task endpoint", async () => {
       const deletedTask: Task = { ...FAKE_DETAIL, column: "done" };
diff --git a/packages/dashboard/app/api/legacy.ts b/packages/dashboard/app/api/legacy.ts
index b83b9a43cb..92cf9f9955 100644
--- a/packages/dashboard/app/api/legacy.ts
+++ b/packages/dashboard/app/api/legacy.ts
@@ -876,6 +876,57 @@ export function unarchiveTask(id: string, projectId?: string): Promise<Task> {
   return api<Task>(withProjectId(`/tasks/${id}/unarchive`, projectId), { method: "POST" });
 }
 
+/*
+FNXC:TaskRevert 2026-07-05-00:00 (FN-7525):
+Client-side contract for `POST /tasks/:id/revert` (route owned by FN-7523/
+FN-7524/FN-7547/FN-7548 — see the `FNXC:TaskRevert` block in
+`register-task-workflow-routes.ts`). This is a discriminated union, NOT a
+`Task` — the source task's column/status is never mutated by this call; the
+caller (useTasks' `revertTask` op) refreshes the task list afterward so any
+newly-created revert commit / AI-undo task becomes visible, without patching
+the source task's column directly.
+*/
+export interface RevertTaskWorkspaceRepoResult {
+  repo: string;
+  classification?: string;
+  revertCommitSha?: string;
+  conflicts?: unknown;
+  alreadyReverted?: boolean;
+}
+
+export interface RevertTaskGitResult {
+  mode: "git";
+  clean: boolean;
+  revertCommitSha?: string;
+  revertCommitShas?: string[];
+  conflicts?: unknown;
+  alreadyReverted?: boolean;
+  unsupported?: boolean;
+  needsHuman?: boolean;
+  reason?: string;
+  workspace?: { repos: RevertTaskWorkspaceRepoResult[] };
+}
+
+export interface RevertTaskAiResult {
+  mode: "ai";
+  createdTaskId: string;
+  alreadyOpen?: boolean;
+}
+
+export type RevertTaskResult = RevertTaskGitResult | RevertTaskAiResult;
+
+export interface RevertTaskOptions {
+  mode?: "git" | "ai" | "auto";
+  granularity?: "squash" | "per-sha";
+}
+
+export function revertTask(id: string, projectId?: string, body?: RevertTaskOptions): Promise<RevertTaskResult> {
+  return api<RevertTaskResult>(withProjectId(`/tasks/${id}/revert`, projectId), {
+    method: "POST",
+    body: JSON.stringify(body ?? {}),
+  });
+}
+
 export function archiveAllDone(projectId?: string): Promise<Task[]> {
   return api<{ archived: Task[] }>(withProjectId("/tasks/archive-all-done", projectId), { method: "POST" }).then(
     (response) => response.archived
diff --git a/packages/dashboard/app/components/AppModals.tsx b/packages/dashboard/app/components/AppModals.tsx
index 0d963b6957..028c3869a4 100644
--- a/packages/dashboard/app/components/AppModals.tsx
+++ b/packages/dashboard/app/components/AppModals.tsx
@@ -1,5 +1,5 @@
 import { useCallback, useEffect, useRef, useState, lazy, Suspense } from "react";
-import type { ProjectInfo } from "../api";
+import type { ProjectInfo, RevertTaskOptions, RevertTaskResult } from "../api";
 import type { ColorTheme, Column, MergeResult, Task, TaskCreateInput, ThemeMode, GithubIssueAction } from "@fusion/core";
 import type { UseProjectActionsResult } from "../hooks/useProjectActions";
 import type { ModalManager } from "../hooks/useModalManager";
@@ -62,6 +62,8 @@ interface AppModalsProps {
     }) => Promise<Task>;
     mergeTask: (taskId: string) => Promise<MergeResult>;
     archiveTask: (taskId: string, options?: { removeLineageReferences?: boolean }) => Promise<Task>;
+    /* FNXC:TaskRevert 2026-07-05-00:00 (FN-7525): threaded alongside archiveTask; never mutates the source task's column. */
+    revertTask?: (taskId: string, body?: RevertTaskOptions) => Promise<RevertTaskResult>;
     retryTask: (taskId: string) => Promise<Task>;
     resetTask: (taskId: string) => Promise<Task>;
     duplicateTask: (taskId: string) => Promise<Task>;
@@ -320,6 +322,7 @@ export function AppModals({
             onDeleteTask={taskOperations.deleteTask}
             onMergeTask={taskOperations.mergeTask}
             onArchiveTask={taskOperations.archiveTask}
+            onRevertTask={taskOperations.revertTask}
             onRetryTask={taskOperations.retryTask}
             onResetTask={taskOperations.resetTask}
             onDuplicateTask={taskOperations.duplicateTask}
diff --git a/packages/dashboard/app/components/Board.tsx b/packages/dashboard/app/components/Board.tsx
index 93171dd429..f343fa8cfb 100644
--- a/packages/dashboard/app/components/Board.tsx
+++ b/packages/dashboard/app/components/Board.tsx
@@ -7,7 +7,7 @@ import "./Board.css";
 import type { ToastType } from "../hooks/useToast";
 import { useState, useMemo, useEffect, useCallback, useRef } from "react";
 import { createPortal } from "react-dom";
-import { promoteTask, type ModelInfo, type BoardWorkflowsPayload, type BoardWorkflowColumn } from "../api";
+import { promoteTask, type ModelInfo, type BoardWorkflowsPayload, type BoardWorkflowColumn, type RevertTaskOptions, type RevertTaskResult } from "../api";
 import { useBlockerFanout } from "../hooks/useBlockerFanout";
 import { MOBILE_MEDIA_QUERY, useViewportMode } from "../hooks/useViewportMode";
 import { recordResumeEvent } from "../utils/resumeInstrumentation";
@@ -55,6 +55,8 @@ interface BoardProps {
   onRetryTask?: (id: string) => Promise<Task>;
   onArchiveTask?: (id: string, options?: { removeLineageReferences?: boolean }) => Promise<Task>;
   onUnarchiveTask?: (id: string) => Promise<Task>;
+  /* FNXC:TaskRevert 2026-07-05-00:00 (FN-7525): threaded alongside onArchiveTask/onUnarchiveTask. */
+  onRevertTask?: (id: string, body?: RevertTaskOptions) => Promise<RevertTaskResult>;
   onDeleteTask?: (id: string, options?: {
     removeDependencyReferences?: boolean;
     removeLineageReferences?: boolean;
@@ -158,7 +160,7 @@ function BoardWorkflowSkeleton({ empty = false }: { empty?: boolean }) {
   );
 }
 
-export function Board({ tasks, projectId, maxConcurrent, showWorktreeGrouping, onMoveTask, onPauseTask, onUnpauseTask, onResetTask, onDuplicateTask, onMergeTask, onOpenDetail, onOpenRefine, onOpenGroupModal, addToast, onQuickCreate, onNewTask, autoMerge, mergeStrategy = "direct", onToggleAutoMerge, planAutoApproveEnabled, onTogglePlanAutoApprove, globalPaused, onUpdateTask, onRetryTask, onArchiveTask, onUnarchiveTask, onDeleteTask, onArchiveAllDone, onLoadArchivedTasks, searchQuery = "", availableModels, onPlanningMode, onSubtaskBreakdown, onOpenDetailWithTab, favoriteProviders, favoriteModels, onToggleFavorite, onToggleModelFavorite, taskStuckTimeoutMs, onOpenMission, staleHighFanoutBlockerAgeThresholdMs, lastFetchTimeMs, prAuthAvailable, onOpenWorkflowEditor, onCreateWorkflow, workflowColumnsEnabled, settingsLoaded, workflowControlsInHeader = false }: BoardProps) {
+export function Board({ tasks, projectId, maxConcurrent, showWorktreeGrouping, onMoveTask, onPauseTask, onUnpauseTask, onResetTask, onDuplicateTask, onMergeTask, onOpenDetail, onOpenRefine, onOpenGroupModal, addToast, onQuickCreate, onNewTask, autoMerge, mergeStrategy = "direct", onToggleAutoMerge, planAutoApproveEnabled, onTogglePlanAutoApprove, globalPaused, onUpdateTask, onRetryTask, onArchiveTask, onUnarchiveTask, onRevertTask, onDeleteTask, onArchiveAllDone, onLoadArchivedTasks, searchQuery = "", availableModels, onPlanningMode, onSubtaskBreakdown, onOpenDetailWithTab, favoriteProviders, favoriteModels, onToggleFavorite, onToggleModelFavorite, taskStuckTimeoutMs, onOpenMission, staleHighFanoutBlockerAgeThresholdMs, lastFetchTimeMs, prAuthAvailable, onOpenWorkflowEditor, onCreateWorkflow, workflowColumnsEnabled, settingsLoaded, workflowControlsInHeader = false }: BoardProps) {
   const [archivedCollapsed, setArchivedCollapsed] = useState(true);
   /*
   FNXC:DoneColumnSorting 2026-06-29-16:57:
@@ -838,6 +840,7 @@ export function Board({ tasks, projectId, maxConcurrent, showWorktreeGrouping, o
                   onRetryTask={onRetryTask}
                   onArchiveTask={onArchiveTask}
                   onUnarchiveTask={onUnarchiveTask}
+                  onRevertTask={onRevertTask}
                   onDeleteTask={onDeleteTask}
                   allTasks={tasks}
                   availableModels={availableModels}
@@ -920,6 +923,7 @@ export function Board({ tasks, projectId, maxConcurrent, showWorktreeGrouping, o
                 onRetryTask={onRetryTask}
                 onArchiveTask={onArchiveTask}
                 onUnarchiveTask={onUnarchiveTask}
+                onRevertTask={onRevertTask}
                 onDeleteTask={onDeleteTask}
                 availableModels={availableModels}
                 onOpenDetailWithTab={onOpenDetailWithTab}
@@ -976,6 +980,7 @@ export function Board({ tasks, projectId, maxConcurrent, showWorktreeGrouping, o
               onRetryTask={onRetryTask}
               onArchiveTask={onArchiveTask}
               onUnarchiveTask={onUnarchiveTask}
+              onRevertTask={onRevertTask}
               onDeleteTask={onDeleteTask}
               availableModels={availableModels}
               onOpenDetailWithTab={onOpenDetailWithTab}
@@ -1027,6 +1032,7 @@ export function Board({ tasks, projectId, maxConcurrent, showWorktreeGrouping, o
             onRetryTask={onRetryTask}
             onArchiveTask={onArchiveTask}
             onUnarchiveTask={onUnarchiveTask}
+            onRevertTask={onRevertTask}
             onDeleteTask={onDeleteTask}
             allTasks={tasks}
             availableModels={availableModels}
diff --git a/packages/dashboard/app/components/Column.tsx b/packages/dashboard/app/components/Column.tsx
index 9973a13de8..1adfe1ee24 100644
--- a/packages/dashboard/app/components/Column.tsx
+++ b/packages/dashboard/app/components/Column.tsx
@@ -13,7 +13,7 @@ import { groupByWorktree } from "../utils/worktreeGrouping";
 import type { ToastType } from "../hooks/useToast";
 import type { TaskContextMenuColumnMetadata } from "./TaskContextMenu";
 import { ChevronDown, ChevronUp, MoreVertical } from "lucide-react";
-import type { BoardWorkflowDefinition, ModelInfo, BoardWorkflowColumnFlags } from "../api";
+import type { BoardWorkflowDefinition, ModelInfo, BoardWorkflowColumnFlags, RevertTaskOptions, RevertTaskResult } from "../api";
 import type { BlockerFanoutEntry } from "../hooks/useBlockerFanout";
 import type { DoneColumnSortMode } from "./taskSorting";
 
@@ -120,6 +120,8 @@ interface ColumnProps {
   onRetryTask?: (id: string) => Promise<Task>;
   onArchiveTask?: (id: string, options?: { removeLineageReferences?: boolean }) => Promise<Task>;
   onUnarchiveTask?: (id: string) => Promise<Task>;
+  /* FNXC:TaskRevert 2026-07-05-00:00 (FN-7525): threaded alongside onArchiveTask/onUnarchiveTask. */
+  onRevertTask?: (id: string, body?: RevertTaskOptions) => Promise<RevertTaskResult>;
   onDeleteTask?: (id: string, options?: {
     removeDependencyReferences?: boolean;
     removeLineageReferences?: boolean;
@@ -197,7 +199,7 @@ interface ColumnProps {
   getDraggingTaskId?: () => string | null;
 }
 
-function ColumnComponent({ column, tasks, projectId, maxConcurrent, showWorktreeGrouping, onMoveTask, onPauseTask, onUnpauseTask, onResetTask, onDuplicateTask, onMergeTask, onOpenDetail, onOpenRefine, onOpenGroupModal, addToast, onQuickCreate, onNewTask, autoMerge, mergeStrategy = "direct", onToggleAutoMerge, planAutoApproveEnabled, onTogglePlanAutoApprove, globalPaused, onUpdateTask, onRetryTask, onArchiveTask, onUnarchiveTask, onDeleteTask, onArchiveAllDone, doneSortMode, onDoneSortModeChange, collapsed, onToggleCollapse, allTasks, availableModels, onPlanningMode, onSubtaskBreakdown, onOpenDetailWithTab, favoriteProviders, favoriteModels, onToggleFavorite, onToggleModelFavorite, isSearchActive, taskStuckTimeoutMs, onOpenMission, lastFetchTimeMs, taskCardFieldDefs, taskWorkflowBadges, blockerFanoutMap, prAuthAvailable, workflowMode, workflowId, workflowOptions, defaultWorkflowId, columnDisplayName, columnFlags, workflowContextMenuColumns, taskContextMenuColumnsByTaskId, onPromote, canDropTask, getDraggingTaskId }: ColumnProps) {
+function ColumnComponent({ column, tasks, projectId, maxConcurrent, showWorktreeGrouping, onMoveTask, onPauseTask, onUnpauseTask, onResetTask, onDuplicateTask, onMergeTask, onOpenDetail, onOpenRefine, onOpenGroupModal, addToast, onQuickCreate, onNewTask, autoMerge, mergeStrategy = "direct", onToggleAutoMerge, planAutoApproveEnabled, onTogglePlanAutoApprove, globalPaused, onUpdateTask, onRetryTask, onArchiveTask, onUnarchiveTask, onRevertTask, onDeleteTask, onArchiveAllDone, doneSortMode, onDoneSortModeChange, collapsed, onToggleCollapse, allTasks, availableModels, onPlanningMode, onSubtaskBreakdown, onOpenDetailWithTab, favoriteProviders, favoriteModels, onToggleFavorite, onToggleModelFavorite, isSearchActive, taskStuckTimeoutMs, onOpenMission, lastFetchTimeMs, taskCardFieldDefs, taskWorkflowBadges, blockerFanoutMap, prAuthAvailable, workflowMode, workflowId, workflowOptions, defaultWorkflowId, columnDisplayName, columnFlags, workflowContextMenuColumns, taskContextMenuColumnsByTaskId, onPromote, canDropTask, getDraggingTaskId }: ColumnProps) {
   const { t } = useTranslation("app");
   // Anchor the board.rejection.* catalog keys for the i18next extractor (it
   // scopes `t` to the useTranslation binding, so the shared translateRejection
@@ -850,6 +852,7 @@ function ColumnComponent({ column, tasks, projectId, maxConcurrent, showWorktree
                   onMergeTask={onMergeTask}
                   onArchiveTask={onArchiveTask}
                   onUnarchiveTask={onUnarchiveTask}
+                  onRevertTask={onRevertTask}
                   onDeleteTask={onDeleteTask}
                   onOpenDetailWithTab={onOpenDetailWithTab}
                   taskStuckTimeoutMs={taskStuckTimeoutMs}
@@ -890,6 +893,7 @@ function ColumnComponent({ column, tasks, projectId, maxConcurrent, showWorktree
                   onMergeTask={onMergeTask}
                   onArchiveTask={onArchiveTask}
                   onUnarchiveTask={onUnarchiveTask}
+                  onRevertTask={onRevertTask}
                   onDeleteTask={onDeleteTask}
                   onOpenDetailWithTab={onOpenDetailWithTab}
                   taskStuckTimeoutMs={taskStuckTimeoutMs}
diff --git a/packages/dashboard/app/components/Lane.tsx b/packages/dashboard/app/components/Lane.tsx
index 6e78110623..1732934269 100644
--- a/packages/dashboard/app/components/Lane.tsx
+++ b/packages/dashboard/app/components/Lane.tsx
@@ -4,7 +4,7 @@ import { useTranslation } from "react-i18next";
 import type { Task, TaskDetail, Column as ColumnType, ColumnId, TaskCreateInput, GithubIssueAction } from "@fusion/core";
 import { Column } from "./Column";
 import { sortTasksForDisplayColumn } from "./taskSorting";
-import type { ModelInfo, BoardWorkflowDefinition } from "../api";
+import type { ModelInfo, BoardWorkflowDefinition, RevertTaskOptions, RevertTaskResult } from "../api";
 import type { ToastType } from "../hooks/useToast";
 import type { BlockerFanoutEntry } from "../hooks/useBlockerFanout";
 
@@ -50,6 +50,8 @@ export interface LaneProps {
   onRetryTask?: (id: string) => Promise<Task>;
   onArchiveTask?: (id: string, options?: { removeLineageReferences?: boolean }) => Promise<Task>;
   onUnarchiveTask?: (id: string) => Promise<Task>;
+  /* FNXC:TaskRevert 2026-07-05-00:00 (FN-7525): threaded alongside onArchiveTask/onUnarchiveTask. */
+  onRevertTask?: (id: string, body?: RevertTaskOptions) => Promise<RevertTaskResult>;
   onDeleteTask?: (id: string, options?: {
     removeDependencyReferences?: boolean;
     removeLineageReferences?: boolean;
@@ -199,6 +201,7 @@ function LaneComponent(props: LaneProps) {
               onRetryTask={props.onRetryTask}
               onArchiveTask={props.onArchiveTask}
               onUnarchiveTask={props.onUnarchiveTask}
+              onRevertTask={props.onRevertTask}
               onDeleteTask={props.onDeleteTask}
               availableModels={props.availableModels}
               onOpenDetailWithTab={props.onOpenDetailWithTab}
diff --git a/packages/dashboard/app/components/ListView.tsx b/packages/dashboard/app/components/ListView.tsx
index 91ada2b550..f17e08a139 100644
--- a/packages/dashboard/app/components/ListView.tsx
+++ b/packages/dashboard/app/components/ListView.tsx
@@ -12,7 +12,7 @@ import { sortTasksForDisplayColumn } from "./taskSorting";
 import { batchUpdateTaskModels, fetchNodes, fetchTaskDetail, rebuildTaskSpec, refreshPrStatus, updateTask } from "../api";
 import { TaskDetailContent } from "./TaskDetailModal";
 import { PrCreateModal } from "./PrCreateModal";
-import type { BoardWorkflowColumn, BoardWorkflowsPayload, ModelInfo, NodeInfo } from "../api";
+import type { BoardWorkflowColumn, BoardWorkflowsPayload, ModelInfo, NodeInfo, RevertTaskOptions, RevertTaskResult } from "../api";
 import { QuickEntryBox } from "./QuickEntryBox";
 import { CustomModelDropdown } from "./CustomModelDropdown";
 import { NodeHealthDot } from "./NodeHealthDot";
@@ -221,6 +221,8 @@ interface ListViewProps {
   onPauseTask?: (id: string) => Promise<Task>;
   onUnpauseTask?: (id: string) => Promise<Task>;
   onArchiveTask?: (id: string, options?: { removeLineageReferences?: boolean }) => Promise<Task>;
+  /* FNXC:TaskRevert 2026-07-05-00:00 (FN-7525): threaded alongside onArchiveTask; never mutates the source task's column. */
+  onRevertTask?: (id: string, body?: RevertTaskOptions) => Promise<RevertTaskResult>;
   onMergeTask: (id: string) => Promise<MergeResult>;
   onResetTask?: (id: string) => Promise<Task>;
   onDuplicateTask?: (id: string) => Promise<Task>;
@@ -313,6 +315,7 @@ export function ListView({
   onPauseTask,
   onUnpauseTask,
   onArchiveTask,
+  onRevertTask,
   onMergeTask,
   onResetTask,
   onDuplicateTask,
@@ -1532,6 +1535,64 @@ export function ListView({
     }
   }, [addToast, confirm, onArchiveTask, t]);
 
+  /*
+  FNXC:TaskRevert 2026-07-05-00:00 (FN-7525):
+  List-view Revert action, mirroring TaskCard's `handleRevertClick`: auto mode
+  first, clean-git success toast with the revert commit sha, an info toast for
+  `alreadyReverted`, an error toast (never a silent AI fork) for `needsHuman`,
+  and a confirm-gated AI-undo fallback on conflict/unsupported. The source
+  task's column is never mutated as a side effect.
+  */
+  const handleListTaskRevert = useCallback(async (task: Task) => {
+    if (!onRevertTask) return;
+    try {
+      const result = await onRevertTask(task.id, { mode: "auto" });
+
+      if (result.mode === "ai") {
+        addToast(result.alreadyOpen
+          ? t("tasks.revertAlreadyOpen", "An undo task is already open: {{id}}", { id: result.createdTaskId })
+          : t("tasks.revertAiCreated", "Created undo task {{id}}", { id: result.createdTaskId }), "success");
+        return;
+      }
+
+      if (result.alreadyReverted) {
+        addToast(t("tasks.revertAlreadyReverted", "{{taskId}} was already reverted", { taskId: task.id }), "info");
+        return;
+      }
+
+      if (result.needsHuman) {
+        addToast(t("tasks.revertNeedsHuman", "Cannot auto-revert {{taskId}}: {{reason}}", { taskId: task.id, reason: result.reason || t("tasks.revertNeedsHumanDefault", "human review required") }), "error");
+        return;
+      }
+
+      if (result.clean && result.revertCommitSha) {
+        addToast(t("tasks.reverted", "Reverted {{taskId}} in commit {{sha}}", { taskId: task.id, sha: result.revertCommitSha.slice(0, 12) }), "success");
+        return;
+      }
+
+      if (!result.clean || result.unsupported) {
+        const confirmed = await confirm({
+          title: t("tasks.revertConflictTitle", "Revert Conflict"),
+          message: t("tasks.revertConflictMessage", "Git revert conflicts with later changes. Create an AI task to undo this?"),
+          cancelLabel: t("common.cancel", "Cancel"),
+        });
+        if (!confirmed) return;
+
+        const aiResult = await onRevertTask(task.id, { mode: "ai" });
+        if (aiResult.mode === "ai") {
+          addToast(aiResult.alreadyOpen
+            ? t("tasks.revertAlreadyOpen", "An undo task is already open: {{id}}", { id: aiResult.createdTaskId })
+            : t("tasks.revertAiCreated", "Created undo task {{id}}", { id: aiResult.createdTaskId }), "success");
+        }
+        return;
+      }
+
+      addToast(t("tasks.revertFailed", "Failed to revert {{taskId}}", { taskId: task.id }), "error");
+    } catch (err) {
+      addToast(getErrorMessage(err), "error");
+    }
+  }, [addToast, confirm, onRevertTask, t]);
+
   const handleListContextMove = useCallback(async (task: Task, column: ColumnId) => {
     try {
       const hasStepProgress = task.steps.some((step) => step.status !== "pending");
@@ -1704,6 +1765,21 @@ export function ListView({
     if (task.column === "done" && onArchiveTask) {
       actions.push({ id: "archive", label: t("tasks.archive", "Archive"), onSelect: () => void handleListTaskArchive(task) });
     }
+    /*
+    FNXC:TaskRevert 2026-07-05-00:00 (FN-7525):
+    List-view Revert menu entry for done/archived rows, mirroring the `archive`
+    entry above. Disabled (rather than omitted) when the task lacks a landed
+    commit to revert.
+    */
+    if ((task.column === "done" || task.column === "archived") && onRevertTask) {
+      const isRevertable = Boolean(task.mergeDetails?.commitSha);
+      actions.push({
+        id: "revert",
+        label: t("tasks.revert", "Revert"),
+        disabled: !isRevertable,
+        onSelect: isRevertable ? () => void handleListTaskRevert(task) : undefined,
+      });
+    }
     for (const transition of model.moveTransitions) {
       actions.push({
         id: `move-${transition.column}`,
@@ -1715,7 +1791,7 @@ export function ListView({
       actions.push({ id: model.reviewAction.id, label: model.reviewAction.label, disabled: model.reviewAction.disabled, onSelect: model.reviewAction.onSelect });
     }
     return actions.filter((action) => action.tone === "note" || action.disabled === true || Boolean(action.onSelect));
-  }, [addToast, autoMerge, columnFlagsById, confirm, getListColumnLabel, handleListContextCheckPrStatus, handleListContextEnableGithubTracking, handleListContextMove, handleListTaskArchive, handleListTaskDelete, isMobile, listContextMenuColumns, mergeStrategy, onDuplicateTask, onMergeTask, onOpenDetail, onPauseTask, onResetTask, onRetryTask, onUnpauseTask, onArchiveTask, onTasksUpdated, projectId, t]);
+  }, [addToast, autoMerge, columnFlagsById, confirm, getListColumnLabel, handleListContextCheckPrStatus, handleListContextEnableGithubTracking, handleListContextMove, handleListTaskArchive, handleListTaskDelete, handleListTaskRevert, isMobile, listContextMenuColumns, mergeStrategy, onDuplicateTask, onMergeTask, onOpenDetail, onPauseTask, onResetTask, onRetryTask, onUnpauseTask, onArchiveTask, onRevertTask, onTasksUpdated, projectId, t]);
 
   const contextMenuActions = useMemo(
     () => (contextMenuState ? buildListContextMenuActions(contextMenuState.task) : []),
diff --git a/packages/dashboard/app/components/TaskCard.css b/packages/dashboard/app/components/TaskCard.css
index 5d3a5983ee..1443982d39 100644
--- a/packages/dashboard/app/components/TaskCard.css
+++ b/packages/dashboard/app/components/TaskCard.css
@@ -1446,9 +1446,17 @@ executing. These map 1:1 to the unified progress status so the dot color encodes
   opacity: 1;
 }
 
-/* Archive/Unarchive buttons */
+/* Archive/Unarchive/Revert buttons */
+/*
+FNXC:TaskRevert 2026-07-05-00:00 (FN-7525):
+.card-revert-btn shares the .card-archive-btn/.card-unarchive-btn tokenized
+look (no one-off px/hex) — it's applied alongside .card-archive-btn on the
+markup so no separate ruleset was strictly required, but it's declared here
+too so future divergence doesn't have to rediscover the shared selector group.
+*/
 .card-archive-btn,
-.card-unarchive-btn {
+.card-unarchive-btn,
+.card-revert-btn {
   display: inline-flex;
   align-items: center;
   justify-content: center;
@@ -1468,19 +1476,22 @@ executing. These map 1:1 to the unified progress status so the dot color encodes
 }
 
 .card:hover .card-archive-btn,
-.card:hover .card-unarchive-btn {
+.card:hover .card-unarchive-btn,
+.card:hover .card-revert-btn {
   opacity: 1;
 }
 
 .card-archive-btn:hover,
-.card-unarchive-btn:hover {
+.card-unarchive-btn:hover,
+.card-revert-btn:hover {
   background: var(--card-hover);
   color: var(--text);
   border-color: color-mix(in srgb, var(--border) 70%, var(--text) 30%);
 }
 
 .card-archive-btn:focus,
-.card-unarchive-btn:focus {
+.card-unarchive-btn:focus,
+.card-revert-btn:focus {
   opacity: 1;
   outline: 1px solid var(--todo);
   outline-offset: 1px;
@@ -1658,7 +1669,8 @@ executing. These map 1:1 to the unified progress status so the dot color encodes
 
   /* FN-4351/FN-3965: keep secondary actions visible on touch, but compact per WCAG 2.5.8 because the card tap surface is the primary target for opening task detail. */
   .card-archive-btn,
-  .card-unarchive-btn {
+  .card-unarchive-btn,
+  .card-revert-btn {
     opacity: 1;
   }
 
diff --git a/packages/dashboard/app/components/TaskCard.tsx b/packages/dashboard/app/components/TaskCard.tsx
index 256876340d..2bcb016f3d 100644
--- a/packages/dashboard/app/components/TaskCard.tsx
+++ b/packages/dashboard/app/components/TaskCard.tsx
@@ -20,7 +20,7 @@ import { resolveEffectiveAutoMerge } from "../../../core/src/task-merge";
 // resolver — like resolveEffectiveAutoMerge above — must be imported from its source module
 // directly rather than the package barrel.
 import { resolveEffectivePlannerOversightLevel } from "../../../core/src/workflow-settings-resolver";
-import { addressPrFeedback, fetchTaskDetail, uploadAttachment, fetchMission, fetchAgent, rebuildTaskSpec, refreshPrStatus, fetchWorkflowSettingValues, type WorkflowFieldDefinition } from "../api";
+import { addressPrFeedback, fetchTaskDetail, uploadAttachment, fetchMission, fetchAgent, rebuildTaskSpec, refreshPrStatus, fetchWorkflowSettingValues, type WorkflowFieldDefinition, type RevertTaskOptions, type RevertTaskResult } from "../api";
 import { GitHubBadge } from "./GitHubBadge";
 import { GitLabBadge } from "./GitLabBadge";
 import { PrCreateModal } from "./PrCreateModal";
@@ -489,6 +489,14 @@ interface TaskCardProps {
   ) => Promise<Task>;
   onArchiveTask?: (id: string, options?: { removeLineageReferences?: boolean }) => Promise<Task>;
   onUnarchiveTask?: (id: string) => Promise<Task>;
+  /*
+  FNXC:TaskRevert 2026-07-05-00:00 (FN-7525):
+  Threaded alongside onArchiveTask/onUnarchiveTask; the source task's column
+  is never mutated by the caller as a side effect. Absent when the parent
+  does not support revert (undefined -> no button rendered, mirroring the
+  onArchiveTask guard).
+  */
+  onRevertTask?: (id: string, body?: RevertTaskOptions) => Promise<RevertTaskResult>;
   onDeleteTask?: (id: string, options?: {
     removeDependencyReferences?: boolean;
     removeLineageReferences?: boolean;
@@ -710,6 +718,7 @@ function areTaskCardPropsEqual(previous: TaskCardProps, next: TaskCardProps): bo
     previous.onUpdateTask === next.onUpdateTask &&
     previous.onArchiveTask === next.onArchiveTask &&
     previous.onUnarchiveTask === next.onUnarchiveTask &&
+    previous.onRevertTask === next.onRevertTask &&
     previous.onDeleteTask === next.onDeleteTask &&
     previous.onPauseTask === next.onPauseTask &&
     previous.onRetryTask === next.onRetryTask &&
@@ -851,6 +860,7 @@ function TaskCardComponent({
   onUpdateTask,
   onArchiveTask,
   onUnarchiveTask,
+  onRevertTask,
   onDeleteTask,
   onPauseTask,
   onRetryTask,
@@ -1861,6 +1871,83 @@ function TaskCardComponent({
     });
   }, [addToast, onUnarchiveTask, task.id]);
 
+  /*
+  FNXC:TaskRevert 2026-07-05-00:00 (FN-7525):
+  Revertable guard: a card is only offered a Revert affordance when it sits in
+  done/archived AND it has a landed commit to revert. Absent `mergeDetails` (no
+  merge ever recorded, e.g. a no-op/no-commits-expected task) means there is
+  nothing to revert — treat it as not-revertable rather than erroring at click
+  time. This mirrors the parent FN-7501 issue's "undo a change" framing: only
+  tasks that actually changed the tree are revertable.
+  */
+  const isRevertable = (task.column === "done" || task.column === "archived")
+    && Boolean(task.mergeDetails?.commitSha);
+
+  /*
+  FNXC:TaskRevert 2026-07-05-00:00 (FN-7525):
+  Revert click handler: calls the API in "auto" mode (git-first, AI-undo
+  fallback on conflict/unsupported). Never silently AI-forks a `needsHuman`
+  result (e.g. autoMerge-off) — that is surfaced as an informational toast so a
+  human can decide, per the FN-7524 route contract. The SOURCE task's column is
+  never mutated here as a side effect of a revert.
+  */
+  const handleRevertClick = useCallback((e: React.MouseEvent<HTMLButtonElement>) => {
+    e.stopPropagation();
+    if (!onRevertTask) return;
+
+    void onRevertTask(task.id, { mode: "auto" }).then(async (result) => {
+      if (result.mode === "ai") {
+        addToast(result.alreadyOpen
+          ? t("tasks.revertAlreadyOpen", "An undo task is already open: {{id}}", { id: result.createdTaskId })
+          : t("tasks.revertAiCreated", "Created undo task {{id}}", { id: result.createdTaskId }), "success");
+        return;
+      }
+
+      if (result.alreadyReverted) {
+        addToast(t("tasks.revertAlreadyReverted", "{{taskId}} was already reverted", { taskId: task.id }), "info");
+        return;
+      }
+
+      if (result.needsHuman) {
+        addToast(t("tasks.revertNeedsHuman", "Cannot auto-revert {{taskId}}: {{reason}}", { taskId: task.id, reason: result.reason || t("tasks.revertNeedsHumanDefault", "human review required") }), "error");
+        return;
+      }
+
+      if (result.clean && result.revertCommitSha) {
+        addToast(t("tasks.reverted", "Reverted {{taskId}} in commit {{sha}}", { taskId: task.id, sha: result.revertCommitSha.slice(0, 12) }), "success");
+        return;
+      }
+
+      if (!result.clean || result.unsupported) {
+        const confirmed = await confirm({
+          title: t("tasks.revertConflictTitle", "Revert Conflict"),
+          message: t("tasks.revertConflictMessage", "Git revert conflicts with later changes. Create an AI task to undo this?"),
+        });
+        if (!confirmed) return;
+
+        try {
+          const aiResult = await onRevertTask(task.id, { mode: "ai" });
+          if (aiResult.mode === "ai") {
+            addToast(aiResult.alreadyOpen
+              ? t("tasks.revertAlreadyOpen", "An undo task is already open: {{id}}", { id: aiResult.createdTaskId })
+              : t("tasks.revertAiCreated", "Created undo task {{id}}", { id: aiResult.createdTaskId }), "success");
+          }
+        } catch (aiErr) {
+          addToast(getErrorMessage(aiErr), "error");
+        }
+        return;
+      }
+
+      addToast(t("tasks.revertFailed", "Failed to revert {{taskId}}", { taskId: task.id }), "error");
+    }).catch((err) => {
+      addToast(getErrorMessage(err), "error");
+    });
+  }, [addToast, confirm, onRevertTask, t, task.id]);
+
+  const handleTaskActionRevert = useCallback(() => {
+    handleRevertClick({ stopPropagation() {} } as React.MouseEvent<HTMLButtonElement>);
+  }, [handleRevertClick]);
+
   const handleDeleteClick = useCallback(async (e: React.MouseEvent<HTMLButtonElement>) => {
     e.stopPropagation();
     if (!onDeleteTask) return;
@@ -2244,7 +2331,7 @@ function TaskCardComponent({
     task.prInfo,
   ]);
   const contextMenuActions = useMemo<TaskMenuActionDescriptor[]>(() => {
-    if (!onDeleteTask && !onArchiveTask && !onUnarchiveTask && !onDuplicateTask && !onRetryTask && !onResetTask && !onPauseTask && !onUnpauseTask && !onMergeTask && !onMoveTask && !onOpenRefine && !onUpdateTask) {
+    if (!onDeleteTask && !onArchiveTask && !onUnarchiveTask && !onRevertTask && !onDuplicateTask && !onRetryTask && !onResetTask && !onPauseTask && !onUnpauseTask && !onMergeTask && !onMoveTask && !onOpenRefine && !onUpdateTask) {
       return [];
     }
     const actions = [...taskActionMenuModel.actions];
@@ -2254,6 +2341,21 @@ function TaskCardComponent({
     if (task.column === "archived" && onUnarchiveTask) {
       actions.push({ id: "unarchive", label: t("tasks.unarchive", "Unarchive"), onSelect: handleTaskActionUnarchive });
     }
+    /*
+    FNXC:TaskRevert 2026-07-05-00:00 (FN-7525):
+    Context-menu Revert entry for done/archived, mirroring the archive/unarchive
+    entries above. Disabled (rather than omitted) when the task lacks a landed
+    commit to revert, so the menu communicates WHY the affordance is inert
+    instead of silently hiding it.
+    */
+    if ((task.column === "done" || task.column === "archived") && onRevertTask) {
+      actions.push({
+        id: "revert",
+        label: t("tasks.revert", "Revert"),
+        disabled: !isRevertable,
+        onSelect: isRevertable ? handleTaskActionRevert : undefined,
+      });
+    }
     if (taskActionMenuModel.reviewAction) {
       actions.push({ id: taskActionMenuModel.reviewAction.id, label: taskActionMenuModel.reviewAction.label, disabled: taskActionMenuModel.reviewAction.disabled, onSelect: taskActionMenuModel.reviewAction.onSelect });
     }
@@ -2267,7 +2369,7 @@ function TaskCardComponent({
       }
     }
     return actions.filter((action) => action.tone === "note" || action.disabled === true || Boolean(action.onSelect));
-  }, [handleTaskActionArchive, handleTaskActionMove, handleTaskActionUnarchive, onArchiveTask, onDeleteTask, onDuplicateTask, onMergeTask, onMoveTask, onOpenRefine, onPauseTask, onResetTask, onRetryTask, onUnarchiveTask, onUnpauseTask, onUpdateTask, t, task.column, taskActionMenuModel.actions, taskActionMenuModel.moveTransitions, taskActionMenuModel.reviewAction]);
+  }, [handleTaskActionArchive, handleTaskActionMove, handleTaskActionRevert, handleTaskActionUnarchive, isRevertable, onArchiveTask, onDeleteTask, onDuplicateTask, onMergeTask, onMoveTask, onOpenRefine, onPauseTask, onResetTask, onRetryTask, onRevertTask, onUnarchiveTask, onUnpauseTask, onUpdateTask, t, task.column, taskActionMenuModel.actions, taskActionMenuModel.moveTransitions, taskActionMenuModel.reviewAction]);
   const hasContextMenuActions = contextMenuActions.length > 0;
 
   const closeContextMenu = useCallback(() => {
@@ -2970,6 +3072,25 @@ function TaskCardComponent({
               {t("tasks.unarchive", "Unarchive")}
             </button>
           )}
+          {/*
+          FNXC:TaskRevert 2026-07-05-00:00 (FN-7525):
+          Inline Revert affordance for done/archived cards (parent FN-7501). Rendered
+          only when the task actually has a landed commit to revert (`isRevertable`)
+          — omitted (not disabled) here to avoid an empty button shell on cards with
+          nothing to revert, matching the "omit inline / disable in menu" split called
+          out in the task spec. Reuses `card-archive-btn`'s tokenized styling via a
+          shared class so no new one-off CSS/colors are introduced.
+          */}
+          {(task.column === "done" || task.column === "archived") && onRevertTask && isRevertable && (
+            <button
+              className="card-archive-btn card-revert-btn"
+              onClick={handleRevertClick}
+              title={t("tasks.revertTask", "Revert this task's changes")}
+              aria-label={t("tasks.revertTask", "Revert this task's changes")}
+            >
+              {t("tasks.revert", "Revert")}
+            </button>
+          )}
           {task.column === "in-progress" && onMoveTask && (
             <div className="card-send-back" ref={sendBackRef}>
               <button
diff --git a/packages/dashboard/app/components/TaskDetailModal.tsx b/packages/dashboard/app/components/TaskDetailModal.tsx
index 3bac1a6738..2d240dc293 100644
--- a/packages/dashboard/app/components/TaskDetailModal.tsx
+++ b/packages/dashboard/app/components/TaskDetailModal.tsx
@@ -24,6 +24,7 @@ import { isNearDuplicateCanonicalInactive } from "../../../core/src/near-duplica
 import { getRevertOfId, findOpenUndoTaskForSource } from "../utils/taskRevert";
 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, fetchWorkflowSettingValues, nudgeOverseer, stopOverseer, explainOverseer, api } from "../api";
+import type { RevertTaskOptions, RevertTaskResult } from "../api";
 import type { BoardWorkflowsPayload, WorkflowFieldDefinition, CustomFieldRejection } from "../api";
 import { WorkflowIcon } from "./WorkflowIcon";
 import { ApiRequestError } from "../api";
@@ -347,6 +348,8 @@ export interface TaskDetailModalProps {
     allowResurrection?: boolean;
   }) => Promise<Task>;
   onArchiveTask?: (id: string, options?: { removeLineageReferences?: boolean }) => Promise<Task>;
+  /* FNXC:TaskRevert 2026-07-05-00:00 (FN-7525): threaded alongside onArchiveTask; never mutates the source task's column. */
+  onRevertTask?: (id: string, body?: RevertTaskOptions) => Promise<RevertTaskResult>;
   onMergeTask: (id: string) => Promise<MergeResult>;
   onRetryTask?: (id: string) => Promise<Task>;
   onResetTask?: (id: string) => Promise<Task>;
@@ -615,6 +618,7 @@ export function TaskDetailContent({
   onMoveTask,
   onDeleteTask,
   onArchiveTask,
+  onRevertTask,
   onMergeTask,
   onRetryTask,
   onResetTask,
@@ -2585,6 +2589,68 @@ export function TaskDetailContent({
     }
   }, [onArchiveTask, confirm, task.id, nearDuplicateOf, addToast, requestClose]);
 
+  /*
+  FNXC:TaskRevert 2026-07-05-00:00 (FN-7525):
+  Detail-view Revert action, mirroring TaskCard's `handleRevertClick`: calls the
+  API in "auto" mode, surfaces a clean-git success toast with the revert commit
+  sha, an info toast for `alreadyReverted`, an error toast (never a silent AI
+  fork) for `needsHuman`, and otherwise confirms before falling back to the
+  AI-undo task on conflict/unsupported. The source task's column is never
+  mutated as a side effect.
+  */
+  const isRevertable = (task.column === "done" || task.column === "archived")
+    && Boolean(task.mergeDetails?.commitSha);
+
+  const handleRevertTask = useCallback(async () => {
+    if (!onRevertTask) return;
+    try {
+      const result = await onRevertTask(task.id, { mode: "auto" });
+
+      if (result.mode === "ai") {
+        addToast(result.alreadyOpen
+          ? t("tasks.revertAlreadyOpen", "An undo task is already open: {{id}}", { id: result.createdTaskId })
+          : t("tasks.revertAiCreated", "Created undo task {{id}}", { id: result.createdTaskId }), "success");
+        return;
+      }
+
+      if (result.alreadyReverted) {
+        addToast(t("tasks.revertAlreadyReverted", "{{taskId}} was already reverted", { taskId: task.id }), "info");
+        return;
+      }
+
+      if (result.needsHuman) {
+        addToast(t("tasks.revertNeedsHuman", "Cannot auto-revert {{taskId}}: {{reason}}", { taskId: task.id, reason: result.reason || t("tasks.revertNeedsHumanDefault", "human review required") }), "error");
+        return;
+      }
+
+      if (result.clean && result.revertCommitSha) {
+        addToast(t("tasks.reverted", "Reverted {{taskId}} in commit {{sha}}", { taskId: task.id, sha: result.revertCommitSha.slice(0, 12) }), "success");
+        return;
+      }
+
+      if (!result.clean || result.unsupported) {
+        const confirmed = await confirm({
+          title: t("tasks.revertConflictTitle", "Revert Conflict"),
+          message: t("tasks.revertConflictMessage", "Git revert conflicts with later changes. Create an AI task to undo this?"),
+          cancelLabel: t("common.cancel", "Cancel"),
+        });
+        if (!confirmed) return;
+
+        const aiResult = await onRevertTask(task.id, { mode: "ai" });
+        if (aiResult.mode === "ai") {
+          addToast(aiResult.alreadyOpen
+            ? t("tasks.revertAlreadyOpen", "An undo task is already open: {{id}}", { id: aiResult.createdTaskId })
+            : t("tasks.revertAiCreated", "Created undo task {{id}}", { id: aiResult.createdTaskId }), "success");
+        }
+        return;
+      }
+
+      addToast(t("tasks.revertFailed", "Failed to revert {{taskId}}", { taskId: task.id }), "error");
+    } catch (err) {
+      addToast(getErrorMessage(err), "error");
+    }
+  }, [onRevertTask, confirm, task.id, addToast, t]);
+
   const isTaskPaused = task.paused || task.userPaused;
   /*
    * FNXC:PlanApproval 2026-07-04-21:35:
@@ -5682,6 +5748,25 @@ export function TaskDetailContent({
                 </button>
               )}
 
+              {/*
+              FNXC:TaskRevert 2026-07-05-00:00 (FN-7525):
+              Detail-view Revert button for done/archived tasks, mirroring the
+              standalone triage Delete button above. Rendered (not just menu-only)
+              because the detail view is the primary surface for reviewing a
+              completed task's outcome. Omitted — not disabled — when the task has
+              no landed commit to revert, avoiding an empty button shell.
+              */}
+              {(task.column === "done" || task.column === "archived") && onRevertTask && isRevertable && (
+                <button
+                  className="btn btn-sm"
+                  onClick={() => void handleRevertTask()}
+                  aria-label={t("tasks.revertTask", "Revert this task's changes")}
+                  title={t("tasks.revertTask", "Revert this task's changes")}
+                >
+                  {t("tasks.revert", "Revert")}
+                </button>
+              )}
+
               {/* Actions dropdown — less common operations */}
               {taskActionMenuModel.shouldShowActionsMenu && (
                 <div className="detail-actions-dropdown" ref={actionsMenuRef}>
diff --git a/packages/dashboard/app/components/WorktreeGroup.tsx b/packages/dashboard/app/components/WorktreeGroup.tsx
index a47183ab6e..449b859248 100644
--- a/packages/dashboard/app/components/WorktreeGroup.tsx
+++ b/packages/dashboard/app/components/WorktreeGroup.tsx
@@ -5,6 +5,7 @@ import { isNearDuplicateCanonicalInactive } from "../../../core/src/near-duplica
 import { ClipboardList, GitBranch } from "lucide-react";
 import { TaskCard } from "./TaskCard";
 import type { ToastType } from "../hooks/useToast";
+import type { RevertTaskOptions, RevertTaskResult } from "../api";
 import type { BlockerFanoutEntry } from "../hooks/useBlockerFanout";
 import type { TaskContextMenuColumnMetadata } from "./TaskContextMenu";
 
@@ -31,6 +32,8 @@ interface WorktreeGroupProps {
   onMergeTask?: (id: string) => Promise<MergeResult>;
   onArchiveTask?: (id: string, options?: { removeLineageReferences?: boolean }) => Promise<Task>;
   onUnarchiveTask?: (id: string) => Promise<Task>;
+  /* FNXC:TaskRevert 2026-07-05-00:00 (FN-7525): threaded alongside onArchiveTask/onUnarchiveTask. */
+  onRevertTask?: (id: string, body?: RevertTaskOptions) => Promise<RevertTaskResult>;
   onDeleteTask?: (id: string, options?: {
     removeDependencyReferences?: boolean;
     removeLineageReferences?: boolean;
@@ -81,6 +84,7 @@ function WorktreeGroupComponent({
   onMergeTask,
   onArchiveTask,
   onUnarchiveTask,
+  onRevertTask,
   onDeleteTask,
   onOpenDetailWithTab,
   taskStuckTimeoutMs,
@@ -135,6 +139,7 @@ function WorktreeGroupComponent({
           onMergeTask={onMergeTask}
           onArchiveTask={onArchiveTask}
           onUnarchiveTask={onUnarchiveTask}
+          onRevertTask={onRevertTask}
           onDeleteTask={onDeleteTask}
           onOpenDetailWithTab={onOpenDetailWithTab}
           taskStuckTimeoutMs={taskStuckTimeoutMs}
@@ -171,6 +176,7 @@ function WorktreeGroupComponent({
           onMergeTask={onMergeTask}
           onArchiveTask={onArchiveTask}
           onUnarchiveTask={onUnarchiveTask}
+          onRevertTask={onRevertTask}
           onDeleteTask={onDeleteTask}
           onOpenDetailWithTab={onOpenDetailWithTab}
           taskStuckTimeoutMs={taskStuckTimeoutMs}
diff --git a/packages/dashboard/app/components/__tests__/TaskCard.test.tsx b/packages/dashboard/app/components/__tests__/TaskCard.test.tsx
index 2c2fbe1707..0f48411f2d 100644
--- a/packages/dashboard/app/components/__tests__/TaskCard.test.tsx
+++ b/packages/dashboard/app/components/__tests__/TaskCard.test.tsx
@@ -1132,6 +1132,157 @@ describe("TaskCard", () => {
     expect(screen.getByLabelText("Unarchive task")).toBeDefined();
   });
 
+  /*
+  FNXC:TaskRevert 2026-07-05-00:00 (FN-7525):
+  Coverage for the Revert affordance: presence/absence on done + archived
+  cards (inline row + context menu), the disabled/omitted no-commit-to-revert
+  guard, the auto→clean-success path, and the auto→conflict→confirm→AI-undo
+  fallback path.
+  */
+  describe("Revert affordance", () => {
+    it("renders the inline Revert button for a done card with a landed commit", () => {
+      render(
+        <TaskCard
+          task={makeTask({ column: "done", mergeDetails: { commitSha: "abc123def456" } as any })}
+          onOpenDetail={noop}
+          addToast={noop}
+          onRevertTask={vi.fn(async () => ({ mode: "git", clean: true, revertCommitSha: "deadbeef" }) as any)}
+        />,
+      );
+
+      expect(screen.getByLabelText("Revert this task's changes")).toBeDefined();
+    });
+
+    it("renders the inline Revert button for an archived card with a landed commit", () => {
+      render(
+        <TaskCard
+          task={makeTask({ column: "archived", mergeDetails: { commitSha: "abc123def456" } as any })}
+          onOpenDetail={noop}
+          addToast={noop}
+          onRevertTask={vi.fn(async () => ({ mode: "git", clean: true, revertCommitSha: "deadbeef" }) as any)}
+        />,
+      );
+
+      expect(screen.getByLabelText("Revert this task's changes")).toBeDefined();
+    });
+
+    it("omits the Revert button when onRevertTask is not provided", () => {
+      render(
+        <TaskCard
+          task={makeTask({ column: "done", mergeDetails: { commitSha: "abc123def456" } as any })}
+          onOpenDetail={noop}
+          addToast={noop}
+        />,
+      );
+
+      expect(screen.queryByLabelText("Revert this task's changes")).toBeNull();
+    });
+
+    it("omits the inline Revert button when the task has no landed commit", () => {
+      render(
+        <TaskCard
+          task={makeTask({ column: "done", mergeDetails: undefined })}
+          onOpenDetail={noop}
+          addToast={noop}
+          onRevertTask={vi.fn(async () => ({ mode: "git", clean: true, revertCommitSha: "deadbeef" }) as any)}
+        />,
+      );
+
+      expect(screen.queryByLabelText("Revert this task's changes")).toBeNull();
+    });
+
+    it("shows a disabled Revert context-menu entry when the task has no landed commit", () => {
+      render(
+        <TaskCard
+          task={makeTask({ column: "done", mergeDetails: undefined })}
+          onOpenDetail={noop}
+          addToast={noop}
+          onRevertTask={vi.fn(async () => ({ mode: "git", clean: true, revertCommitSha: "deadbeef" }) as any)}
+        />,
+      );
+
+      fireEvent.contextMenu(document.querySelector(".card")!, { clientX: 24, clientY: 28 });
+      const menuItem = screen.getByRole("menuitem", { name: "Revert" });
+      expect(menuItem).toBeDisabled();
+    });
+
+    it("shows the Revert context-menu entry for done and archived cards", () => {
+      render(
+        <TaskCard
+          task={makeTask({ column: "done", mergeDetails: { commitSha: "abc123def456" } as any })}
+          onOpenDetail={noop}
+          addToast={noop}
+          onRevertTask={vi.fn(async () => ({ mode: "git", clean: true, revertCommitSha: "deadbeef" }) as any)}
+        />,
+      );
+
+      fireEvent.contextMenu(document.querySelector(".card")!, { clientX: 24, clientY: 28 });
+      expect(screen.getByRole("menuitem", { name: "Revert" })).toBeDefined();
+    });
+
+    it("calls onRevertTask in auto mode and toasts the revert commit sha on a clean result", async () => {
+      const addToast = vi.fn();
+      const onRevertTask = vi.fn(async () => ({ mode: "git", clean: true, revertCommitSha: "deadbeef1234" }) as any);
+
+      render(
+        <TaskCard
+          task={makeTask({ column: "done", mergeDetails: { commitSha: "abc123def456" } as any })}
+          onOpenDetail={noop}
+          addToast={addToast}
+          onRevertTask={onRevertTask}
+        />,
+      );
+
+      await act(async () => {
+        fireEvent.click(screen.getByLabelText("Revert this task's changes"));
+      });
+
+      await waitFor(() => {
+        expect(onRevertTask).toHaveBeenCalledWith("FN-001", { mode: "auto" });
+      });
+      await waitFor(() => {
+        expect(addToast).toHaveBeenCalledWith(
+          expect.stringContaining("deadbeef1234"),
+          "success",
+        );
+      });
+    });
+
+    it("opens a confirm dialog on conflict and falls back to mode: ai, surfacing the created task id", async () => {
+      const addToast = vi.fn();
+      const onRevertTask = vi.fn()
+        .mockResolvedValueOnce({ mode: "git", clean: false, conflicts: [{}] } as any)
+        .mockResolvedValueOnce({ mode: "ai", createdTaskId: "FN-999" } as any);
+      mockConfirm.mockResolvedValueOnce(true);
+
+      render(
+        <TaskCard
+          task={makeTask({ column: "done", mergeDetails: { commitSha: "abc123def456" } as any })}
+          onOpenDetail={noop}
+          addToast={addToast}
+          onRevertTask={onRevertTask}
+        />,
+      );
+
+      await act(async () => {
+        fireEvent.click(screen.getByLabelText("Revert this task's changes"));
+      });
+
+      await waitFor(() => {
+        expect(mockConfirm).toHaveBeenCalled();
+      });
+      await waitFor(() => {
+        expect(onRevertTask).toHaveBeenNthCalledWith(2, "FN-001", { mode: "ai" });
+      });
+      await waitFor(() => {
+        expect(addToast).toHaveBeenCalledWith(
+          expect.stringContaining("FN-999"),
+          "success",
+        );
+      });
+    });
+  });
+
   it("keeps two-button delete flow for non-done task", async () => {
     const onDeleteTask = vi.fn(async () => makeTask());
     mockConfirm.mockResolvedValueOnce(false);
diff --git a/packages/dashboard/app/components/__tests__/board-mobile.test.tsx b/packages/dashboard/app/components/__tests__/board-mobile.test.tsx
index 1a22f61910..772ab7f024 100644
--- a/packages/dashboard/app/components/__tests__/board-mobile.test.tsx
+++ b/packages/dashboard/app/components/__tests__/board-mobile.test.tsx
@@ -418,6 +418,69 @@ describe("TaskCard mobile", () => {
     expectRuleToContain(mobileSection, ".card-delete-btn", "height: 28px;");
   });
 
+  /*
+  FNXC:TaskRevert 2026-07-05-00:00 (FN-7525):
+  Mobile coverage for the Revert affordance (FN-5893 Surface Enumeration —
+  mobile breakpoint): the button renders on done/archived cards at mobile
+  width and, critically, leaves NO empty/orphaned button shell when it is
+  hidden (no landed commit, or onRevertTask undefined).
+  */
+  it("sets .card-revert-btn opacity: 1 in the mobile media block alongside archive/unarchive", () => {
+    const css = loadAllAppCss();
+    const mobileSection = getMainMobileSection(css);
+
+    expectRuleToContain(mobileSection, ".card-revert-btn", "opacity: 1;");
+  });
+
+  it("renders the Revert affordance on a done card at the mobile breakpoint", () => {
+    const task = createTask({ id: "FN-201", column: "done", mergeDetails: { commitSha: "abc123def456" } as any });
+
+    const { container } = render(
+      <TaskCard
+        task={task}
+        onOpenDetail={vi.fn()}
+        addToast={vi.fn()}
+        onRevertTask={vi.fn(async () => ({ mode: "git", clean: true, revertCommitSha: "deadbeef" }) as any)}
+      />,
+    );
+
+    expect(container.querySelector(".card-revert-btn")).toBeTruthy();
+  });
+
+  it("renders the Revert affordance on an archived card at the mobile breakpoint", () => {
+    const task = createTask({ id: "FN-202", column: "archived", mergeDetails: { commitSha: "abc123def456" } as any });
+
+    const { container } = render(
+      <TaskCard
+        task={task}
+        onOpenDetail={vi.fn()}
+        addToast={vi.fn()}
+        onRevertTask={vi.fn(async () => ({ mode: "git", clean: true, revertCommitSha: "deadbeef" }) as any)}
+      />,
+    );
+
+    expect(container.querySelector(".card-revert-btn")).toBeTruthy();
+  });
+
+  it("leaves no empty/orphaned Revert button shell when not revertable or onRevertTask is undefined", () => {
+    const notRevertableTask = createTask({ id: "FN-203", column: "done", mergeDetails: undefined });
+    const { container: containerA } = render(
+      <TaskCard
+        task={notRevertableTask}
+        onOpenDetail={vi.fn()}
+        addToast={vi.fn()}
+        onRevertTask={vi.fn(async () => ({ mode: "git", clean: true, revertCommitSha: "deadbeef" }) as any)}
+      />,
+    );
+    expect(containerA.querySelector(".card-revert-btn")).toBeNull();
+
+    const revertableTask = createTask({ id: "FN-204", column: "done", mergeDetails: { commitSha: "abc123def456" } as any });
+    const { container: containerB } = render(
+      <TaskCard task={revertableTask} onOpenDetail={vi.fn()} addToast={vi.fn()} />,
+    );
+    expect(containerB.querySelector(".card-revert-btn")).toBeNull();
+  });
+
   it("opens task detail on quick tap", async () => {
     const task = createTask({ id: "FN-200", column: "todo" });
 
diff --git a/packages/dashboard/app/components/dashboard/MainContent.tsx b/packages/dashboard/app/components/dashboard/MainContent.tsx
index e25ff47c29..403408d45f 100644
--- a/packages/dashboard/app/components/dashboard/MainContent.tsx
+++ b/packages/dashboard/app/components/dashboard/MainContent.tsx
@@ -130,6 +130,7 @@ export function MainContent({
   retryTask,
   archiveTask,
   unarchiveTask,
+  revertTask,
   deleteTask,
   archiveAllDone,
   loadArchivedTasks,
@@ -723,6 +724,7 @@ export function MainContent({
             onMergeTask={mergeTask}
             onArchiveTask={archiveTask}
             onUnarchiveTask={unarchiveTask}
+            onRevertTask={revertTask}
             onDeleteTask={deleteTask}
             onArchiveAllDone={archiveAllDone}
             onLoadArchivedTasks={loadArchivedTasks}
@@ -828,6 +830,7 @@ export function MainContent({
           onMergeTask={mergeTask}
           onArchiveTask={archiveTask}
           onUnarchiveTask={unarchiveTask}
+          onRevertTask={revertTask}
           onDeleteTask={deleteTask}
           onArchiveAllDone={archiveAllDone}
           onLoadArchivedTasks={loadArchivedTasks}
@@ -865,6 +868,7 @@ export function MainContent({
         onPauseTask={pauseTask}
         onUnpauseTask={unpauseTask}
         onArchiveTask={archiveTask}
+        onRevertTask={revertTask}
         onMergeTask={mergeTask}
         onResetTask={resetTask}
         onDuplicateTask={duplicateTask}
diff --git a/packages/dashboard/app/components/dashboard/types.ts b/packages/dashboard/app/components/dashboard/types.ts
index 0b4ff9da04..9ff8e438a7 100644
--- a/packages/dashboard/app/components/dashboard/types.ts
+++ b/packages/dashboard/app/components/dashboard/types.ts
@@ -27,6 +27,8 @@ import type {
   NodeInfo,
   ProjectInfo,
   ProjectInfoWithSource,
+  RevertTaskOptions,
+  RevertTaskResult,
 } from "../../api";
 import type { FusionShellApi } from "../../types/native-shell";
 import type { DetailTaskOpenOptions, DetailTaskTab, ModalManager } from "../../hooks/useModalManager";
@@ -177,6 +179,12 @@ export interface MainContentProps {
   retryTask: (id: string) => Promise<Task>;
   archiveTask: (id: string, options?: { removeLineageReferences?: boolean }) => Promise<Task>;
   unarchiveTask: (id: string) => Promise<Task>;
+  /*
+  FNXC:TaskRevert 2026-07-05-00:00 (FN-7525):
+  Threaded alongside archiveTask/unarchiveTask; never mutates the source
+  task's column as a side effect (see route + client contract comments).
+  */
+  revertTask: (id: string, body?: RevertTaskOptions) => Promise<RevertTaskResult>;
   deleteTask: (
     id: string,
     options?: {
diff --git a/packages/dashboard/app/components/useRightDockController.tsx b/packages/dashboard/app/components/useRightDockController.tsx
index 7d84a5d79a..37de8a419c 100644
--- a/packages/dashboard/app/components/useRightDockController.tsx
+++ b/packages/dashboard/app/components/useRightDockController.tsx
@@ -4,6 +4,7 @@ import { isNearDuplicateCanonicalInactive } from "../../../core/src/near-duplica
 import type { ToastType } from "../hooks/useToast";
 import type { DetailTaskTab } from "../hooks/useModalManager";
 import { fetchTaskDetail } from "../api";
+import type { RevertTaskOptions, RevertTaskResult } from "../api";
 import { getScopedItem } from "../utils/projectStorage";
 import { DOCK_FILES_CURRENT_KEY } from "./DockFilesView";
 import { TaskCard } from "./TaskCard";
@@ -29,6 +30,8 @@ export interface RightDockControllerInput {
   onMoveTask: (id: string, column: ColumnId, optionsOrPosition?: { preserveProgress?: boolean } | number) => Promise<Task>;
   onDeleteTask: (id: string, options?: { removeDependencyReferences?: boolean; removeLineageReferences?: boolean; githubIssueAction?: GithubIssueAction; allowResurrection?: boolean }) => Promise<Task>;
   onArchiveTask?: (id: string, options?: { removeLineageReferences?: boolean }) => Promise<Task>;
+  /* FNXC:TaskRevert 2026-07-05-00:00 (FN-7525): threaded alongside onArchiveTask; never mutates the source task's column. */
+  onRevertTask?: (id: string, body?: RevertTaskOptions) => Promise<RevertTaskResult>;
   onMergeTask: (id: string) => Promise<MergeResult>;
   onRetryTask?: (id: string) => Promise<Task>;
   onResetTask?: (id: string) => Promise<Task>;
@@ -233,6 +236,7 @@ export function useRightDockController(input: RightDockControllerInput): RightDo
       onMoveTask={input.onMoveTask}
       onDeleteTask={input.onDeleteTask}
       onArchiveTask={input.onArchiveTask}
+      onRevertTask={input.onRevertTask}
       onMergeTask={input.onMergeTask}
       onRetryTask={input.onRetryTask}
       onResetTask={input.onResetTask}
diff --git a/packages/dashboard/app/hooks/useTasks.ts b/packages/dashboard/app/hooks/useTasks.ts
index 325adde437..1944a8f272 100644
--- a/packages/dashboard/app/hooks/useTasks.ts
+++ b/packages/dashboard/app/hooks/useTasks.ts
@@ -751,6 +751,25 @@ export function useTasks(options?: UseTasksOptions) {
     return task;
   }, [projectId]);
 
+  /*
+  FNXC:TaskRevert 2026-07-05-00:00 (FN-7525):
+  Client-side `revertTask` op. Deliberately does NOT patch the source task's
+  column/status in local state — the git/AI-undo route never moves the
+  source task backward (see the `FNXC:TaskRevert` route contract). On success
+  (either a clean git revert producing a new commit, or an AI-undo task being
+  created) we re-fetch via `refreshTasksRef` so the board picks up the new
+  AI-undo task / any lineage changes without us guessing at the shape of the
+  update ourselves.
+  */
+  const revertTask = useCallback(async (
+    id: string,
+    body?: api.RevertTaskOptions,
+  ): Promise<api.RevertTaskResult> => {
+    const result = await api.revertTask(id, projectId, body);
+    void refreshTasksRef.current?.();
+    return result;
+  }, [projectId]);
+
   const archiveAllDone = useCallback(async (): Promise<Task[]> => {
     const archived = await api.archiveAllDone(projectId);
     const normalized = archived.map(normalizeTask);
@@ -804,5 +823,5 @@ export function useTasks(options?: UseTasksOptions) {
     lastFetchTimeMs.current = Date.now();
   }, []);
 
-  return { tasks, isStale, lastRefreshErrorAt, createTask, moveTask, pauseTask, unpauseTask, deleteTask, mergeTask, retryTask, resetTask, duplicateTask, updateTask, archiveTask, unarchiveTask, archiveAllDone, loadArchivedTasks, includeArchived, refreshTasks, ingestCreatedTasks, lastFetchTimeMs: lastFetchTimeMs.current };
+  return { tasks, isStale, lastRefreshErrorAt, createTask, moveTask, pauseTask, unpauseTask, deleteTask, mergeTask, retryTask, resetTask, duplicateTask, updateTask, archiveTask, unarchiveTask, revertTask, archiveAllDone, loadArchivedTasks, includeArchived, refreshTasks, ingestCreatedTasks, lastFetchTimeMs: lastFetchTimeMs.current };
 }
diff --git a/packages/i18n/locales/en/app.json b/packages/i18n/locales/en/app.json
index fdecb3d516..10d29e4447 100644
--- a/packages/i18n/locales/en/app.json
+++ b/packages/i18n/locales/en/app.json
@@ -8213,6 +8213,17 @@
     "retry": "Retry",
     "retryFailed": "Failed to retry {{taskId}}: {{error}}",
     "retrying": "Retrying…",
+    "revert": "Revert",
+    "revertAiCreated": "Created undo task {{id}}",
+    "revertAlreadyOpen": "An undo task is already open: {{id}}",
+    "revertAlreadyReverted": "{{taskId}} was already reverted",
+    "revertConflictMessage": "Git revert conflicts with later changes. Create an AI task to undo this?",
+    "revertConflictTitle": "Revert Conflict",
+    "revertFailed": "Failed to revert {{taskId}}",
+    "revertNeedsHuman": "Cannot auto-revert {{taskId}}: {{reason}}",
+    "revertNeedsHumanDefault": "human review required",
+    "reverted": "Reverted {{taskId}} in commit {{sha}}",
+    "revertTask": "Revert this task's changes",
     "reviewerModel": "Reviewer Model",
     "save": "Save",
     "saving": "Saving...",

From 73b38babf0f833538effd41eaef06150bda47ab2 Mon Sep 17 00:00:00 2001
From: gsxdsm <gsxdsm@users.noreply.github.com>
Date: Sun, 5 Jul 2026 10:42:21 -0700
Subject: [PATCH 28/65] FN-7578: surface aiUndoTaskWorkflowId picker in
 Settings General
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Adds a Settings → General picker so operators can choose which workflow governs AI-undo (revert) board tasks, instead of it being fixed.

- Add aiUndoTaskWorkflowId select to GeneralSection, defaulting to builtin:review-heavy, with an "Inherit project default workflow" empty-string option matching the revert route's blank-is-inherit behavior (FN-7556)
- Load full workflow list (including custom workflows, excluding fragments) separately from the builtin-only workflow list used for enable/disable checkboxes
- Add FNXC:TaskRevert comment documenting the default/inherit semantics
- Add tests for the new picker and update settings-default-descriptions test
- Add changeset (minor) and update settings-reference/task-management docs
- Add i18n strings across en/es/fr/ko/zh-CN/zh-TW locales

Files changed:
 .changeset/fn-7578-ai-undo-workflow-setting-ui.md  |   7 ++
 docs/settings-reference.md                         |   2 +-
 docs/task-management.md                            |   2 +-
 .../settings/sections/GeneralSection.tsx           |  42 +++++++
 .../GeneralSection.aiUndoWorkflow.test.tsx         | 129 +++++++++++++++++++++
 .../settings-default-descriptions.test.tsx         |   3 +-
 packages/i18n/locales/en/app.json                  |   5 +-
 packages/i18n/locales/es/app.json                  |   5 +-
 packages/i18n/locales/fr/app.json                  |   5 +-
 packages/i18n/locales/ko/app.json                  |   5 +-
 packages/i18n/locales/zh-CN/app.json               |   5 +-
 packages/i18n/locales/zh-TW/app.json               |   5 +-
 12 files changed, 205 insertions(+), 10 deletions(-)

Fusion-Task-Id: FN-7578
Fusion-Task-Lineage: 1d1701ab-ecc7-4bbe-a003-2ce45ac15a25
Co-authored-by: Fusion (runfusion.ai) <noreply@runfusion.ai>
---
 .../fn-7578-ai-undo-workflow-setting-ui.md    |   7 +
 docs/settings-reference.md                    |   2 +-
 docs/task-management.md                       |   2 +-
 .../settings/sections/GeneralSection.tsx      |  42 ++++++
 .../GeneralSection.aiUndoWorkflow.test.tsx    | 129 ++++++++++++++++++
 .../settings-default-descriptions.test.tsx    |   3 +-
 packages/i18n/locales/en/app.json             |   5 +-
 packages/i18n/locales/es/app.json             |   5 +-
 packages/i18n/locales/fr/app.json             |   5 +-
 packages/i18n/locales/ko/app.json             |   5 +-
 packages/i18n/locales/zh-CN/app.json          |   5 +-
 packages/i18n/locales/zh-TW/app.json          |   5 +-
 12 files changed, 205 insertions(+), 10 deletions(-)
 create mode 100644 .changeset/fn-7578-ai-undo-workflow-setting-ui.md
 create mode 100644 packages/dashboard/app/components/settings/sections/__tests__/GeneralSection.aiUndoWorkflow.test.tsx

diff --git a/.changeset/fn-7578-ai-undo-workflow-setting-ui.md b/.changeset/fn-7578-ai-undo-workflow-setting-ui.md
new file mode 100644
index 0000000000..a57c515d5c
--- /dev/null
+++ b/.changeset/fn-7578-ai-undo-workflow-setting-ui.md
@@ -0,0 +1,7 @@
+---
+"@runfusion/fusion": minor
+---
+
+summary: Add a Settings → General picker to choose the workflow used for AI-undo (revert) tasks.
+category: feature
+dev: Surfaces `aiUndoTaskWorkflowId` (default `builtin:review-heavy`) in GeneralSection; empty selection means "inherit project default workflow", matching the revert route's blank-is-inherit behavior from FN-7556.
diff --git a/docs/settings-reference.md b/docs/settings-reference.md
index ff1f3ceb10..ec706ab760 100644
--- a/docs/settings-reference.md
+++ b/docs/settings-reference.md
@@ -412,7 +412,7 @@ Security-sensitive file-browser escape hatches are project-only. `allowAbsoluteF
 | `secretsEnv` | `{ enabled?: boolean; filename?: string; overwritePolicy?: "skip" \| "merge" \| "replace"; keyPrefix?: string; requireGitignored?: boolean }` | `undefined` | Per-project secrets `.env` materialization configuration. When `enabled`, the engine writes `secretsEnv.filename` (default `.env`) into each acquired task worktree from secrets marked `env_exportable=true`. `overwritePolicy` controls merge/skip/replace against an existing file; `requireGitignored` (default `true`) refuses to write a non-gitignored path; `keyPrefix` filters which exported keys are included. See [Secrets](./secrets.md#env-auto-write-into-worktrees). |
 | `mcpServers` | `McpServersSettings` | `{ enabled: false, servers: [] }` | Project-scoped MCP server settings. Project entries override global entries by `name`; `enabled:false` on a same-named project entry disables the inherited global server. Sensitive env/header/token material must be Fusion secret references only. See [MCP server settings](#mcp-server-settings). |
 | `owningNodeHandoffPolicy` | `"block" \| "reassign-to-local" \| "reassign-any-healthy"` | `"reassign-to-local"` | Policy for tasks already checked out by an unavailable owning node. `"block"` parks, `"reassign-to-local"` takes over on local node, `"reassign-any-healthy"` makes takeover eligible on healthy peers. |
-| `aiUndoTaskWorkflowId` | `string` | `"builtin:review-heavy"` | **FN-7556.** Workflow selected for AI-undo board tasks created by `POST /api/tasks/:id/revert` (`mode: "ai"` and the `auto`/workspace conflict fallbacks) — a stricter review posture since these tasks reverse already-shipped code. Blank/unset means the created task inherits the project default workflow. The route validates the configured id and falls back to inherit on a blank or unknown value, so a misconfigured id never breaks AI-undo task creation. Settings Modal UI for this field is a follow-up; today it is settable only through the settings API. See [Task Management → Reverting Done/Archived tasks](./task-management.md#reverting-donearchived-tasks-git-path--ai-undo-fallback). |
+| `aiUndoTaskWorkflowId` | `string` | `"builtin:review-heavy"` | **FN-7556 / FN-7578.** Workflow selected for AI-undo board tasks created by `POST /api/tasks/:id/revert` (`mode: "ai"` and the `auto`/workspace conflict fallbacks) — a stricter review posture since these tasks reverse already-shipped code. Blank/unset means the created task inherits the project default workflow. The route validates the configured id and falls back to inherit on a blank or unknown value, so a misconfigured id never breaks AI-undo task creation. Editable from **Settings → General** ("AI-undo task workflow" picker, next to the workflow-enablement controls); choose "Inherit project default workflow" to store the blank/inherit sentinel. See [Task Management → Reverting Done/Archived tasks](./task-management.md#reverting-donearchived-tasks-git-path--ai-undo-fallback). |
 
 | `groupOverlappingFiles` | `boolean` | `true` | Serialize execution when file scopes overlap. |
 | `pluginTrustPolicy` | `"off" | "warn" | "enforce"` | `"warn"` | Plugin provenance enforcement mode: `off` records verification metadata only, `warn` blocks only `invalid` signatures, `enforce` allows only `verified-trusted` or `trusted-local`. |
diff --git a/docs/task-management.md b/docs/task-management.md
index 099d216fab..b4f3bc8f47 100644
--- a/docs/task-management.md
+++ b/docs/task-management.md
@@ -697,7 +697,7 @@ Recovery/backfill guidance:
 - **Workspace (multi-repo) tasks (FN-7547):** tasks with `workspaceWorktrees` populated (`isWorkspaceTask`) are revertable too — the route dispatches to a dedicated workspace path that reasons about every sub-repo's integration branch as ONE all-or-nothing unit. It resolves each sub-repo's attributable commit(s), dry-run classifies every sub-repo first, and only commits a `revert(FN-xxxx): ...` commit on EACH sub-repo when every sub-repo classifies clean/already-reverted; if any sub-repo conflicts, no sub-repo is committed and every touched sub-repo worktree is rolled back to its pre-call state. Response contract for workspace tasks: `{ mode: "git", clean, workspace: { repos: [{ repo, classification, revertCommitSha?, conflicts?, alreadyReverted? }] }, conflicts?: {repo, file, ...}[] }`. A conflicting workspace result still falls back to the AI-undo task under `"auto"` mode, same as a single-repo conflicting result.
 - **`autoMerge:false` PR-based revert (FN-7554):** for a single-repo task whose git revert classifies **clean**, `autoMerge:false` no longer dead-ends at `needsHuman`. The route prepares a dedicated `fusion/revert-<id>` branch off the resolved base branch (via the engine's `prepareRevertPrBranch`, which NEVER writes to the base branch itself), pushes it, and opens a GitHub PR through the same owner/repo resolution, `githubRateLimiter` gate, `findPrForBranch` idempotency, and `manual: true` handoff as `POST /tasks/:id/pr/create`. Response: `{ mode: "pr", clean: true, prUrl, prNumber, revertBranch, existingPr? }` — a second call while the PR is still open links the existing PR (`existingPr: true`) instead of re-pushing. GitHub unconfigured or rate-limited still degrades gracefully to `{ mode: "git", needsHuman: true, reason }`, and a conflicting/unsupported/already-reverted classification is unaffected (no PR is opened; `"auto"` mode still falls back to the AI-undo task on conflict/unsupported). Workspace (multi-repo) tasks are not yet covered by this PR path — they keep the existing `needsHuman` result under `autoMerge:false`.
 - **Dashboard auto-linking (FN-7555):** the AI-undo task's card shows an "Undo of FN-xxxx" chip and its detail view shows a clickable "Created to undo FN-xxxx" link back to the source task. The source task's detail view shows an "Undo task: FN-YYYY" link whenever an OPEN undo task referencing it exists in the loaded tasks (matching `TaskStore.findOpenRevertTaskForSource`'s open-only semantics — a `done`/`archived`/soft-deleted undo task is never surfaced as active). Both directions are derived client-side from `sourceMetadata.revertOf`; no new API. A dedicated Done/Archived card revert-trigger action is still a separate follow-up (see FN-7525).
-- **Configurable AI-undo workflow default (FN-7556):** the project setting `aiUndoTaskWorkflowId` (default `builtin:review-heavy`) selects the workflow applied to every AI-undo task created above (`mode:"ai"` and the `auto`/workspace conflict fallbacks all share one creation seam, so all three inherit this default) — a stricter review posture is warranted because these tasks reverse already-shipped code. A blank/unset value means the created task inherits the project default workflow (pre-FN-7556 behavior); the route falls back to inherit (with a logged warning) if the configured id is blank or does not resolve to a real workflow, so a misconfigured id never breaks AI-undo task creation. See [Settings Reference → Project Settings](./settings-reference.md#project-settings). The Settings Modal UI field for this setting is a deliberate follow-up; it is settable today only via the settings API.
+- **Configurable AI-undo workflow default (FN-7556, UI: FN-7578):** the project setting `aiUndoTaskWorkflowId` (default `builtin:review-heavy`) selects the workflow applied to every AI-undo task created above (`mode:"ai"` and the `auto`/workspace conflict fallbacks all share one creation seam, so all three inherit this default) — a stricter review posture is warranted because these tasks reverse already-shipped code. A blank/unset value means the created task inherits the project default workflow (pre-FN-7556 behavior); the route falls back to inherit (with a logged warning) if the configured id is blank or does not resolve to a real workflow, so a misconfigured id never breaks AI-undo task creation. Editable from **Settings → General → AI-undo task workflow** (choose "Inherit project default workflow" to store the blank/inherit sentinel). See [Settings Reference → Project Settings](./settings-reference.md#project-settings).
 
 
 ## GitHub Issue Import and PR Creation
diff --git a/packages/dashboard/app/components/settings/sections/GeneralSection.tsx b/packages/dashboard/app/components/settings/sections/GeneralSection.tsx
index 8cae07c825..f2b9d85eba 100644
--- a/packages/dashboard/app/components/settings/sections/GeneralSection.tsx
+++ b/packages/dashboard/app/components/settings/sections/GeneralSection.tsx
@@ -38,6 +38,37 @@ export function GeneralSection({ scopeBanner, form, setForm, projectId, addToast
             cancelled = true;
         };
     }, [projectId]);
+    /*
+    FNXC:TaskRevert 2026-07-05-00:00:
+    AI-undo (revert) board tasks default to the stricter builtin:review-heavy workflow
+    (FN-7556) so reversals of already-shipped code get extra review scrutiny. This picker
+    surfaces that choice: the empty-string option means "inherit project default workflow"
+    (the revert route treats blank/whitespace as inherit), an unset form value displays the
+    effective builtin:review-heavy default, and any other value is the concrete workflow id
+    to use for AI-undo tasks. Loaded separately from builtinWorkflows above because this list
+    includes custom workflows too (builtinWorkflows is deliberately builtin-only, used for the
+    enable/disable checkboxes).
+    */
+    const [aiUndoWorkflowOptions, setAiUndoWorkflowOptions] = useState<WorkflowDefinition[]>([]);
+    useEffect(() => {
+        let cancelled = false;
+        fetchWorkflows(projectId)
+            .then((workflows) => {
+            if (!cancelled) {
+                setAiUndoWorkflowOptions(workflows.filter((workflow) => workflow.kind !== "fragment"));
+            }
+        })
+            .catch(() => {
+            if (!cancelled)
+                setAiUndoWorkflowOptions([]);
+        });
+        return () => {
+            cancelled = true;
+        };
+    }, [projectId]);
+    const aiUndoTaskWorkflowValue = form.aiUndoTaskWorkflowId ?? "builtin:review-heavy";
+    const aiUndoWorkflowHasStoredValue = aiUndoTaskWorkflowValue === "" ||
+        aiUndoWorkflowOptions.some((workflow) => workflow.id === aiUndoTaskWorkflowValue);
     const enabledBuiltinWorkflowIds = useMemo(() => {
         const configured = Array.isArray(form.enabledBuiltinWorkflowIds) ? form.enabledBuiltinWorkflowIds : undefined;
         return new Set(configured ?? builtinWorkflows.map((workflow) => workflow.id));
@@ -108,6 +139,17 @@ export function GeneralSection({ scopeBanner, form, setForm, projectId, addToast
           </div>
           <small>{t("settings.general.disabledFusionWorkflowsAreHiddenFromWorkflow", "Disabled Fusion workflows are hidden from workflow pickers. Existing tasks that already use one continue to resolve. Default: all built-in workflows enabled (unset).")}</small>
         </div>)}
+      <div className="form-group">
+        <label htmlFor="aiUndoTaskWorkflowId">{t("settings.general.aiUndoTaskWorkflow", "AI-undo task workflow")}</label>
+        <select id="aiUndoTaskWorkflowId" className="select" data-testid="ai-undo-workflow-select" value={aiUndoTaskWorkflowValue} onChange={(e) => setForm((f) => ({ ...f, aiUndoTaskWorkflowId: e.target.value }))}>
+          <option value="">{t("settings.general.aiUndoTaskWorkflowInherit", "Inherit project default workflow")}</option>
+          {aiUndoWorkflowOptions.map((workflow) => (<option key={workflow.id} value={workflow.id}>
+              {workflow.name}
+            </option>))}
+          {!aiUndoWorkflowHasStoredValue && (<option value={aiUndoTaskWorkflowValue}>{aiUndoTaskWorkflowValue}</option>)}
+        </select>
+        <small>{t("settings.general.aiUndoTaskWorkflowHelp", "Workflow assigned to AI-undo (revert) tasks, which reverse already-shipped code and warrant stricter review. Choose \"Inherit project default workflow\" to leave them on the project default. Default: review-heavy.")}</small>
+      </div>
       <div className="form-group">
         <label htmlFor="ephemeralAgentsEnabled" className="checkbox-label">
           <input id="ephemeralAgentsEnabled" type="checkbox" checked={form.ephemeralAgentsEnabled !== false} onChange={(e) => setForm((f) => ({ ...f, ephemeralAgentsEnabled: e.target.checked }))}/>{t("settings.general.useEphemeralTaskWorkerAgents", " Use ephemeral task-worker agents ")}</label>
diff --git a/packages/dashboard/app/components/settings/sections/__tests__/GeneralSection.aiUndoWorkflow.test.tsx b/packages/dashboard/app/components/settings/sections/__tests__/GeneralSection.aiUndoWorkflow.test.tsx
new file mode 100644
index 0000000000..e0321606c2
--- /dev/null
+++ b/packages/dashboard/app/components/settings/sections/__tests__/GeneralSection.aiUndoWorkflow.test.tsx
@@ -0,0 +1,129 @@
+// @vitest-environment jsdom
+/**
+ * FN-7578: component tests for the "AI-undo task workflow" picker added to
+ * GeneralSection. Covers the Surface Enumeration data states: unset (shows the
+ * builtin:review-heavy default), populated (stores the chosen id), explicit
+ * inherit (stores the "" sentinel, not undefined), and a stale/deleted stored
+ * id (renders without crashing).
+ */
+import { useState } from "react";
+import { describe, it, expect, vi, afterEach, beforeEach } from "vitest";
+import { render, screen, fireEvent, cleanup, waitFor } from "@testing-library/react";
+import * as jestDomMatchers from "@testing-library/jest-dom/matchers";
+
+import { GeneralSection } from "../GeneralSection";
+import type { SettingsFormState } from "../context";
+import { fetchWorkflows } from "../../../../api";
+
+vi.mock("react-i18next", () => ({
+  useTranslation: () => ({
+    t: (_key: string, fallback?: string) => fallback ?? _key,
+  }),
+}));
+
+vi.mock("../../../../api", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("../../../../api")>();
+  return {
+    ...actual,
+    fetchWorkflows: vi.fn(),
+  };
+});
+
+expect.extend(jestDomMatchers);
+
+const WORKFLOWS = [
+  { id: "builtin:review-heavy", name: "Review Heavy", ir: {} },
+  { id: "builtin:coding", name: "Coding", ir: {} },
+  { id: "WF-001", name: "Custom Workflow", ir: {} },
+  { id: "WF-002-fragment", name: "Reusable Fragment", ir: {}, kind: "fragment" },
+] as unknown as import("@fusion/core").WorkflowDefinition[];
+
+beforeEach(() => {
+  vi.mocked(fetchWorkflows).mockReset();
+  vi.mocked(fetchWorkflows).mockResolvedValue(WORKFLOWS);
+});
+afterEach(() => cleanup());
+
+function GeneralHost({ initialForm, onSetForm }: {
+  initialForm: Partial<SettingsFormState>;
+  onSetForm?: (updater: (f: SettingsFormState) => SettingsFormState) => void;
+}) {
+  const [form, setForm] = useState(initialForm as SettingsFormState);
+  return (
+    <GeneralSection
+      scopeBanner={null}
+      form={form}
+      setForm={(updater) => {
+        setForm((prev) => {
+          const next = (typeof updater === "function" ? (updater as (f: SettingsFormState) => SettingsFormState)(prev) : updater);
+          onSetForm?.(() => next);
+          return next;
+        });
+      }}
+      addToast={vi.fn()}
+      prefixError={null}
+      setPrefixError={vi.fn()}
+      projectTrackingRepoOptions={[]}
+      projectTrackingRepoLoading={false}
+      projectTrackingRepoError={null}
+    />
+  );
+}
+
+describe("GeneralSection - AI-undo task workflow picker", () => {
+  it("shows builtin:review-heavy as the effective default when unset", async () => {
+    render(<GeneralHost initialForm={{}} />);
+
+    const select = (await screen.findByTestId("ai-undo-workflow-select")) as HTMLSelectElement;
+    await waitFor(() => expect(select.value).toBe("builtin:review-heavy"));
+  });
+
+  it("stores the chosen workflow id when a workflow is selected", async () => {
+    let latestForm: SettingsFormState | undefined;
+    render(
+      <GeneralHost
+        initialForm={{}}
+        onSetForm={(getNext) => {
+          latestForm = getNext();
+        }}
+      />,
+    );
+
+    const select = (await screen.findByTestId("ai-undo-workflow-select")) as HTMLSelectElement;
+    await waitFor(() => expect(select.querySelectorAll("option").length).toBeGreaterThan(1));
+
+    fireEvent.change(select, { target: { value: "WF-001" } });
+
+    await waitFor(() => expect(latestForm?.aiUndoTaskWorkflowId).toBe("WF-001"));
+  });
+
+  it("stores the empty-string inherit sentinel when 'Inherit project default workflow' is selected", async () => {
+    let latestForm: SettingsFormState | undefined;
+    render(
+      <GeneralHost
+        initialForm={{ aiUndoTaskWorkflowId: "builtin:coding" }}
+        onSetForm={(getNext) => {
+          latestForm = getNext();
+        }}
+      />,
+    );
+
+    const select = (await screen.findByTestId("ai-undo-workflow-select")) as HTMLSelectElement;
+    await waitFor(() => expect(select.value).toBe("builtin:coding"));
+
+    fireEvent.change(select, { target: { value: "" } });
+
+    await waitFor(() => {
+      expect(latestForm?.aiUndoTaskWorkflowId).toBe("");
+      expect(latestForm?.aiUndoTaskWorkflowId).not.toBeUndefined();
+    });
+  });
+
+  it("renders a stale/deleted stored workflow id without crashing", async () => {
+    render(<GeneralHost initialForm={{ aiUndoTaskWorkflowId: "WF-DELETED" }} />);
+
+    const select = (await screen.findByTestId("ai-undo-workflow-select")) as HTMLSelectElement;
+    await waitFor(() => expect(select.value).toBe("WF-DELETED"));
+    expect(screen.getByRole("option", { name: "WF-DELETED" })).toBeInTheDocument();
+  });
+});
diff --git a/packages/dashboard/app/components/settings/sections/__tests__/settings-default-descriptions.test.tsx b/packages/dashboard/app/components/settings/sections/__tests__/settings-default-descriptions.test.tsx
index 645c1fb262..90f7220152 100644
--- a/packages/dashboard/app/components/settings/sections/__tests__/settings-default-descriptions.test.tsx
+++ b/packages/dashboard/app/components/settings/sections/__tests__/settings-default-descriptions.test.tsx
@@ -242,6 +242,7 @@ const SETTING_DESCRIPTION_KEYS: Record<string, string> = {
   workspaceMode: "general.workspaceModeHint",
   defaultWorkflowId: "general.newTasksInheritThisCustomWorkflowsStepsOverridable",
   enabledBuiltinWorkflowIds: "general.disabledFusionWorkflowsAreHiddenFromWorkflow",
+  aiUndoTaskWorkflowId: "general.aiUndoTaskWorkflowHelp",
   // ProjectModelsSection
   autoSelectModelPreset: "projectModels.autoSelectModelPresetHint",
   autoSummarizeTitles: "projectModels.whenEnabledTasksCreatedWithoutATitleBut",
@@ -468,8 +469,6 @@ const NOT_SURFACED_ALLOWLIST: Record<string, string> = {
   prerebaseDivergenceThreshold: "internal pre-rebase tuning constant, no UI field",
   maxSpawnedAgentsPerParent: "internal spawn-limit constant, no UI field",
   maxSpawnedAgentsGlobal: "internal spawn-limit constant, no UI field",
-  // FN-7556: AI-undo workflow default — Settings UI is a follow-up task.
-  aiUndoTaskWorkflowId: "AI-undo workflow default — Settings UI is a follow-up task",
 };
 
 describe("FN-7505 settings default-value description guard", () => {
diff --git a/packages/i18n/locales/en/app.json b/packages/i18n/locales/en/app.json
index 10d29e4447..7a99694cf5 100644
--- a/packages/i18n/locales/en/app.json
+++ b/packages/i18n/locales/en/app.json
@@ -5881,7 +5881,10 @@
       "gitLabEnabledHint": "Configure GitLab.com or self-managed GitLab URLs. Blank values inherit global fallbacks and then GitLab.com. No default — unset (unset behaves as enabled until explicitly disabled).",
       "allowEphemeralAgentsToCreateTasksHint": "When enabled (default), ephemeral task-worker agents can open follow-up tasks via fn_task_create. When disabled, only humans and permanent agents can create tasks; ephemeral callers are rejected.",
       "quickChatCloseOnOutsideClickHint": "When enabled, clicking outside the Quick Chat window closes it. Disable to keep it open until you close it explicitly. Default: enabled.",
-      "disabledFusionWorkflowsAreHiddenFromWorkflow": "Disabled Fusion workflows are hidden from workflow pickers. Existing tasks that already use one continue to resolve. Default: all built-in workflows enabled (unset)."
+      "disabledFusionWorkflowsAreHiddenFromWorkflow": "Disabled Fusion workflows are hidden from workflow pickers. Existing tasks that already use one continue to resolve. Default: all built-in workflows enabled (unset).",
+      "aiUndoTaskWorkflow": "AI-undo task workflow",
+      "aiUndoTaskWorkflowInherit": "Inherit project default workflow",
+      "aiUndoTaskWorkflowHelp": "Workflow assigned to AI-undo (revert) tasks, which reverse already-shipped code and warrant stricter review. Choose \"Inherit project default workflow\" to leave them on the project default. Default: review-heavy."
     },
     "globalGeneral": {
       "andShowsUpdateNoticesInTheCLIAnd": " and shows update notices in the CLI and dashboard. Cadence is governed by the frequency below. Default: enabled. ",
diff --git a/packages/i18n/locales/es/app.json b/packages/i18n/locales/es/app.json
index f7f44ed940..90e198ea55 100644
--- a/packages/i18n/locales/es/app.json
+++ b/packages/i18n/locales/es/app.json
@@ -5847,7 +5847,10 @@
       "warnOnTheBoardWhenTodoWorkExceeds": "",
       "whenEnabledDefaultFusionSpawnsShortLived": "",
       "whenEnabledFusionChecksOpenAndClosedIssues": "",
-      "workflowsOrChangelogModeWhenContributorsShouldUpdate": ""
+      "workflowsOrChangelogModeWhenContributorsShouldUpdate": "",
+      "aiUndoTaskWorkflow": "",
+      "aiUndoTaskWorkflowInherit": "",
+      "aiUndoTaskWorkflowHelp": ""
     },
     "globalGeneral": {
       "andShowsUpdateNoticesInTheCLIAnd": "",
diff --git a/packages/i18n/locales/fr/app.json b/packages/i18n/locales/fr/app.json
index e689a39d2f..b6bc060cc5 100644
--- a/packages/i18n/locales/fr/app.json
+++ b/packages/i18n/locales/fr/app.json
@@ -5847,7 +5847,10 @@
       "warnOnTheBoardWhenTodoWorkExceeds": "",
       "whenEnabledDefaultFusionSpawnsShortLived": "",
       "whenEnabledFusionChecksOpenAndClosedIssues": "",
-      "workflowsOrChangelogModeWhenContributorsShouldUpdate": ""
+      "workflowsOrChangelogModeWhenContributorsShouldUpdate": "",
+      "aiUndoTaskWorkflow": "",
+      "aiUndoTaskWorkflowInherit": "",
+      "aiUndoTaskWorkflowHelp": ""
     },
     "globalGeneral": {
       "andShowsUpdateNoticesInTheCLIAnd": "",
diff --git a/packages/i18n/locales/ko/app.json b/packages/i18n/locales/ko/app.json
index 36a8292cd9..b927ec7a21 100644
--- a/packages/i18n/locales/ko/app.json
+++ b/packages/i18n/locales/ko/app.json
@@ -5847,7 +5847,10 @@
       "warnOnTheBoardWhenTodoWorkExceeds": "",
       "whenEnabledDefaultFusionSpawnsShortLived": "",
       "whenEnabledFusionChecksOpenAndClosedIssues": "",
-      "workflowsOrChangelogModeWhenContributorsShouldUpdate": ""
+      "workflowsOrChangelogModeWhenContributorsShouldUpdate": "",
+      "aiUndoTaskWorkflow": "",
+      "aiUndoTaskWorkflowInherit": "",
+      "aiUndoTaskWorkflowHelp": ""
     },
     "globalGeneral": {
       "andShowsUpdateNoticesInTheCLIAnd": "",
diff --git a/packages/i18n/locales/zh-CN/app.json b/packages/i18n/locales/zh-CN/app.json
index 27354f327d..9255dcb5d2 100644
--- a/packages/i18n/locales/zh-CN/app.json
+++ b/packages/i18n/locales/zh-CN/app.json
@@ -5847,7 +5847,10 @@
       "warnOnTheBoardWhenTodoWorkExceeds": "",
       "whenEnabledDefaultFusionSpawnsShortLived": "",
       "whenEnabledFusionChecksOpenAndClosedIssues": "",
-      "workflowsOrChangelogModeWhenContributorsShouldUpdate": ""
+      "workflowsOrChangelogModeWhenContributorsShouldUpdate": "",
+      "aiUndoTaskWorkflow": "",
+      "aiUndoTaskWorkflowInherit": "",
+      "aiUndoTaskWorkflowHelp": ""
     },
     "globalGeneral": {
       "andShowsUpdateNoticesInTheCLIAnd": "",
diff --git a/packages/i18n/locales/zh-TW/app.json b/packages/i18n/locales/zh-TW/app.json
index 11fc22bfd2..ad97aa9853 100644
--- a/packages/i18n/locales/zh-TW/app.json
+++ b/packages/i18n/locales/zh-TW/app.json
@@ -5847,7 +5847,10 @@
       "warnOnTheBoardWhenTodoWorkExceeds": "",
       "whenEnabledDefaultFusionSpawnsShortLived": "",
       "whenEnabledFusionChecksOpenAndClosedIssues": "",
-      "workflowsOrChangelogModeWhenContributorsShouldUpdate": ""
+      "workflowsOrChangelogModeWhenContributorsShouldUpdate": "",
+      "aiUndoTaskWorkflow": "",
+      "aiUndoTaskWorkflowInherit": "",
+      "aiUndoTaskWorkflowHelp": ""
     },
     "globalGeneral": {
       "andShowsUpdateNoticesInTheCLIAnd": "",

From 9a0951bf2700bf97dd64cf911a32504ff0325567 Mon Sep 17 00:00:00 2001
From: gsxdsm <gsxdsm@users.noreply.github.com>
Date: Sun, 5 Jul 2026 10:46:38 -0700
Subject: [PATCH 29/65] FN-7580: Backfill ~90 missing i18n keys across locale
 catalogs

Fills in translation keys that were missing (empty-string placeholders) in the es, fr, ko, zh-CN, and zh-TW locale app.json catalogs, keeping parity with the en source catalog.

- Added missing settings/workflow keys (aiUndoTaskWorkflow, aiUndoTaskWorkflowInherit, aiUndoTaskWorkflowHelp, workspaceModeHint, allowAbsoluteFileBrowserPathsHint, quickChatLauncherHint, showTaskChatsInCommonFeedHint, whenEnabledImportedGitHubIssuesUseTheirSource, gitLabEnabledHint, allowEphemeralAgentsToCreateTasksHint, quickChatCloseOnOutsideClickHint, disabledFusionWorkflowsAreHiddenFromWorkflow) to es/fr/ko/zh-CN/zh-TW app.json.
- Resolved a merge conflict where main had independently added aiUndoTaskWorkflow* keys to the same object; merged both key sets without duplication or data loss.
- Verified i18n key parity across all 5 secondary locales / 4 namespaces via check-i18n-parity.mjs.

Files changed:
 packages/i18n/locales/es/app.json    | 159 ++++++++++++++++++++++++++++++-----
 packages/i18n/locales/fr/app.json    | 159 ++++++++++++++++++++++++++++++-----
 packages/i18n/locales/ko/app.json    | 159 ++++++++++++++++++++++++++++++-----
 packages/i18n/locales/zh-CN/app.json | 148 +++++++++++++++++++++++++++-----
 packages/i18n/locales/zh-TW/app.json | 159 ++++++++++++++++++++++++++++++-----
 5 files changed, 679 insertions(+), 105 deletions(-)

Fusion-Task-Id: FN-7580

Fusion-Task-Lineage: 78684020-6085-4adb-8e9b-7b35d7448edd

Co-authored-by: Fusion (runfusion.ai) <noreply@runfusion.ai>
---
 packages/i18n/locales/es/app.json    | 159 +++++++++++++++++++++++----
 packages/i18n/locales/fr/app.json    | 159 +++++++++++++++++++++++----
 packages/i18n/locales/ko/app.json    | 159 +++++++++++++++++++++++----
 packages/i18n/locales/zh-CN/app.json | 148 +++++++++++++++++++++----
 packages/i18n/locales/zh-TW/app.json | 159 +++++++++++++++++++++++----
 5 files changed, 679 insertions(+), 105 deletions(-)

diff --git a/packages/i18n/locales/es/app.json b/packages/i18n/locales/es/app.json
index 90e198ea55..a23b2ead5a 100644
--- a/packages/i18n/locales/es/app.json
+++ b/packages/i18n/locales/es/app.json
@@ -29,7 +29,8 @@
     "showLess": "Mostrar menos",
     "showMore": "Mostrar más",
     "update": "Actualizar",
-    "yes": "Sí"
+    "yes": "Sí",
+    "clear": ""
   },
   "activityFeed": {
     "emptyHint": "",
@@ -5646,7 +5647,10 @@
       "languageAuto": "Automático",
       "languageAutoHint": "Seguir el idioma del navegador",
       "suppressTheLdquoNeedsYourInputRdquoBanner": "",
-      "title": "Apariencia"
+      "title": "Apariencia",
+      "openTasksInRightSidebarHelp": "",
+      "openMobileTasksInPopupHelp": "",
+      "taskDetailChatFirstHelp": ""
     },
     "auth": {
       "apiKeyCleared": "Clave API borrada",
@@ -5730,7 +5734,8 @@
       "view": "",
       "whenEnabledProjectAndAgentMemoryFilesAre": "",
       "whenEnabledTheDatabaseIsBackedUpAutomatically": "",
-      "createFailed": ""
+      "createFailed": "",
+      "memoryBackupScopeHint": ""
     },
     "clearToDefault": "",
     "cliAgents": {
@@ -5850,7 +5855,16 @@
       "workflowsOrChangelogModeWhenContributorsShouldUpdate": "",
       "aiUndoTaskWorkflow": "",
       "aiUndoTaskWorkflowInherit": "",
-      "aiUndoTaskWorkflowHelp": ""
+      "aiUndoTaskWorkflowHelp": "",
+      "workspaceModeHint": "",
+      "allowAbsoluteFileBrowserPathsHint": "",
+      "quickChatLauncherHint": "",
+      "showTaskChatsInCommonFeedHint": "",
+      "whenEnabledImportedGitHubIssuesUseTheirSource": "",
+      "gitLabEnabledHint": "",
+      "allowEphemeralAgentsToCreateTasksHint": "",
+      "quickChatCloseOnOutsideClickHint": "",
+      "disabledFusionWorkflowsAreHiddenFromWorkflow": ""
     },
     "globalGeneral": {
       "andShowsUpdateNoticesInTheCLIAnd": "",
@@ -5880,7 +5894,13 @@
       "whenDisabledToolRowsAreStillLoggedBut": "",
       "whenEnabledDefaultTheDashboardAutomaticallyReloadsWhen": "",
       "whenEnabledFusionChecksNpmForNewVersions": "",
-      "whenEnabledTheDashboardProbesForAGlobally": ""
+      "whenEnabledTheDashboardProbesForAGlobally": "",
+      "gitLabEnabledHint": "",
+      "gitLabInstanceUrlHint": "",
+      "gitLabApiBaseUrlHint": "",
+      "gitLabTokenTypeHint": "",
+      "gitLabAuthTokenHint": "",
+      "dismissModalsByClickingOutsideHint": ""
     },
     "globalModels": {
       "allow": "",
@@ -5925,7 +5945,14 @@
       "usedAutomaticallyIfThePrimaryDefaultModelHits": "",
       "useDefault": "",
       "whenEnabledStartupFetchesTheLatestAvailableModels": "",
-      "whenEnabledStartupRefreshesModelsThroughTheLocal": ""
+      "whenEnabledStartupRefreshesModelsThroughTheLocal": "",
+      "commaSeparatedValuesSentToOpenRouterModelSyncOutputModalities": "",
+      "openRouterRoutingOrderHint": "",
+      "openRouterRoutingIgnoreHint": "",
+      "openRouterRoutingOnlyHint": "",
+      "openRouterAllowFallbacksHint": "",
+      "openRouterRoutingSortHint": "",
+      "requireParametersHint": ""
     },
     "header": {
       "discord": "Discord",
@@ -6156,7 +6183,13 @@
       "planApprovalModeAutoApproveAll": "Auto-approve all tasks",
       "planApprovalModeHelp": "Project-wide override for the planning approval gate. Leave on workflow to use each workflow's Require plan approval setting, or force all approved specs to bypass or wait for manual approval.",
       "planApprovalModeRequireAll": "Require approval for all tasks",
-      "planApprovalModeWorkflow": "Use workflow setting"
+      "planApprovalModeWorkflow": "Use workflow setting",
+      "githubAuthTokenHint": "",
+      "gitLabAuthDetails": "",
+      "gitLabPersonalAccessToken": "",
+      "gitLabAuthTokenHint": "",
+      "includeTaskIdInCommitDefault": "",
+      "trailerEmail": ""
     },
     "mergeManually": "Fusionar manualmente",
     "mobileNav": {
@@ -6201,7 +6234,8 @@
       "selectedNode": "",
       "theseSettingsApplyAtTheProjectLevel": "",
       "unavailableNodePolicy": "",
-      "usedWhenATaskHasNoNodeOverride": ""
+      "usedWhenATaskHasNoNodeOverride": "",
+      "unavailableNodePolicyHint": ""
     },
     "nodeSync": {
       "alwaysAsk": "",
@@ -6219,7 +6253,9 @@
       "nodeSync": "",
       "syncInterval": "",
       "syncModelAuthCredentials": "",
-      "workflowSettingsNotSynced": ""
+      "workflowSettingsNotSynced": "",
+      "syncIntervalHint": "",
+      "conflictResolutionHint": ""
     },
     "notifications": {
       "accessTokenOptional": "",
@@ -6263,7 +6299,11 @@
       "webhook": "",
       "webhookNotifications": "",
       "webhookURL": "",
-      "yourNtfyShTopicName164Alphanumeric": ""
+      "yourNtfyShTopicName164Alphanumeric": "",
+      "ntfyEnabledHint": "",
+      "webhookEnabledHint": "",
+      "webhookUrlHint": "",
+      "webhookFormatHint": ""
     },
     "plugins": {
       "fusionPlugins": "",
@@ -6311,7 +6351,10 @@
       "useDefault": "",
       "useWorkflowDefault": "",
       "whenEnabledMergeCommitMessagesIncludeAnAI": "",
-      "whenEnabledTasksCreatedWithoutATitleBut": ""
+      "whenEnabledTasksCreatedWithoutATitleBut": "",
+      "autoSelectModelPresetHint": "",
+      "prTitlePromptInstructionsHelp": "",
+      "prDescriptionPromptInstructionsHelp": ""
     },
     "remote": {
       "acceptRoutes": "",
@@ -6379,7 +6422,10 @@
       "uRLNoHostnameOrPortConfigurationNeeded": "",
       "useExisting": "Usar existente",
       "usingQuickTunnel": "",
-      "installationFailed": ""
+      "installationFailed": "",
+      "acceptRoutesHint": "",
+      "shortLivedEnabledHint": "",
+      "shortLivedTtlMsHint": ""
     },
     "researchGlobal": {
       "advancedExternalSearchProviders": "",
@@ -6408,7 +6454,16 @@
       "searXNG": "",
       "searXNGURL": "",
       "tavily": "",
-      "webSearch": ""
+      "webSearch": "",
+      "searXNGURLHint": "",
+      "googleSearchCXHint": "",
+      "maxConcurrentRunsHint": "",
+      "maxSourcesPerRunHint": "",
+      "defaultMaxDurationMsHint": "",
+      "requestTimeoutMsHint": "",
+      "maxSynthesisRoundsHint": "",
+      "gitHubSourceHint": "",
+      "localDocsSourceHint": ""
     },
     "researchProject": {
       "alwaysOn": "",
@@ -6424,7 +6479,12 @@
       "projectResearchSettings": "",
       "requestTimeoutMs": "",
       "webSearch": "",
-      "webSearchIsAlwaysEnabledConfigureTheSearch": ""
+      "webSearchIsAlwaysEnabledConfigureTheSearch": "",
+      "enableResearchInThisProjectHint": "",
+      "maxConcurrentRunsHint": "",
+      "maxSourcesPerRunHint": "",
+      "maxDurationMsHint": "",
+      "requestTimeoutMsHint": ""
     },
     "resolveAllLocal": "Resolver todo: Mantener local",
     "resolveAllRemote": "Resolver todo: Mantener remoto",
@@ -6449,7 +6509,12 @@
       "openai": "",
       "retentionDays": "",
       "scheduledEvals": "",
-      "suggestOnly": ""
+      "suggestOnly": "",
+      "enabledHint": "",
+      "intervalMsHint": "",
+      "evaluatorProviderHint": "",
+      "followUpPolicyHint": "",
+      "retentionDaysHint": ""
     },
     "scheduling": {
       "addIgnoredPath": "",
@@ -6503,7 +6568,9 @@
       "browseWorkspacePath": "",
       "overlapPickerNote": "",
       "ignoreHiddenDotPathsHelp": "",
-      "ignoreHiddenDotPathsInOverlapChecks": ""
+      "ignoreHiddenDotPathsInOverlapChecks": "",
+      "maxConcurrentTasksHint": "",
+      "pollIntervalMsHint": ""
     },
     "scope": {
       "globalBanner": "Estos ajustes se comparten entre todos tus proyectos de Fusion.",
@@ -6564,7 +6631,11 @@
       "worktrunkBinaryPath": "",
       "worktrunkFailureBehavior": "",
       "worktrunkIntegration": "",
-      "worktreesPickerNote": ""
+      "worktreesPickerNote": "",
+      "showWorktreeGroupingHelp": "",
+      "copyFilesHelp": "",
+      "namingStyleNotApplicableWhenRecycling": "",
+      "howToNameFreshWorktreeDirectories": ""
     },
     "fileBrowser": {
       "currentDirectory": "",
@@ -6574,7 +6645,35 @@
       "globalTitle": "Global MCP servers",
       "projectTitle": "Project MCP servers",
       "globalDescription": "Configure MCP servers shared by all projects. Project settings may override or disable these servers by name.",
-      "projectDescription": "Configure project-specific MCP servers, overrides, and disabled inherited servers."
+      "projectDescription": "Configure project-specific MCP servers, overrides, and disabled inherited servers.",
+      "enabledHint": ""
+    },
+    "search": {
+      "allSections": "",
+      "clear": "",
+      "label": "",
+      "navigationLabel": "",
+      "noMobileOptions": "",
+      "noResults": "",
+      "placeholder": "",
+      "resultCount": ""
+    },
+    "prompts": {
+      "surfaceExplanation": ""
+    },
+    "modelPricing": {
+      "description": ""
+    },
+    "reset": {
+      "button": "",
+      "buttonTitle": "",
+      "dialogAriaLabel": "",
+      "dialogTitle": "",
+      "dialogBody": "",
+      "resetMenuAction": "",
+      "resetAllProjectAction": "",
+      "menuResetSuccess": "",
+      "allProjectResetSuccess": ""
     }
   },
   "setup": {
@@ -7494,7 +7593,8 @@
       "rejected": "Plan rechazado — {{id}} devuelto a Planificación para replanificar",
       "rejectMessage": "¿Rechazar este plan? La especificación será descartada y regenerada.",
       "rejectTitle": "Rechazar plan",
-      "replanning": "Replanificando {{id}}…"
+      "replanning": "Replanificando {{id}}…",
+      "releaseAuthorizationHold": ""
     },
     "pr": {
       "awaitingChecks": "Esperando verificaciones del PR",
@@ -7522,7 +7622,9 @@
     "provenance": {
       "createdBy": "Creado por",
       "createdVia": "Creado mediante",
-      "parentTaskOf": ""
+      "parentTaskOf": "",
+      "createdToUndo": "",
+      "undoTask": ""
     },
     "recoveryState": "Estado de recuperación",
     "refine": {
@@ -8131,7 +8233,22 @@
     "addressPrFeedbackFailed": "",
     "addressPrFeedbackStarted": "",
     "addressPrFeedbackTitle": "",
-    "addressingPrFeedback": ""
+    "addressingPrFeedback": "",
+    "awaitingReleaseAuthorization": "",
+    "revert": "",
+    "revertAiCreated": "",
+    "revertAlreadyOpen": "",
+    "revertAlreadyReverted": "",
+    "revertConflictMessage": "",
+    "revertConflictTitle": "",
+    "revertFailed": "",
+    "revertNeedsHuman": "",
+    "revertNeedsHumanDefault": "",
+    "reverted": "",
+    "revertTask": "",
+    "undoOf": "",
+    "undoOfTitle": "",
+    "undoTask": ""
   },
   "terminal": {
     "arrowKeysLabel": "",
diff --git a/packages/i18n/locales/fr/app.json b/packages/i18n/locales/fr/app.json
index b6bc060cc5..69f21a1337 100644
--- a/packages/i18n/locales/fr/app.json
+++ b/packages/i18n/locales/fr/app.json
@@ -29,7 +29,8 @@
     "showLess": "Afficher moins",
     "showMore": "Afficher plus",
     "update": "Mettre à jour",
-    "yes": "Oui"
+    "yes": "Oui",
+    "clear": ""
   },
   "activityFeed": {
     "emptyHint": "",
@@ -5646,7 +5647,10 @@
       "languageAuto": "Auto",
       "languageAutoHint": "Suivre la langue du navigateur",
       "suppressTheLdquoNeedsYourInputRdquoBanner": "",
-      "title": "Apparence"
+      "title": "Apparence",
+      "openTasksInRightSidebarHelp": "",
+      "openMobileTasksInPopupHelp": "",
+      "taskDetailChatFirstHelp": ""
     },
     "auth": {
       "apiKeyCleared": "Clé API effacée",
@@ -5730,7 +5734,8 @@
       "view": "",
       "whenEnabledProjectAndAgentMemoryFilesAre": "",
       "whenEnabledTheDatabaseIsBackedUpAutomatically": "",
-      "createFailed": ""
+      "createFailed": "",
+      "memoryBackupScopeHint": ""
     },
     "clearToDefault": "",
     "cliAgents": {
@@ -5850,7 +5855,16 @@
       "workflowsOrChangelogModeWhenContributorsShouldUpdate": "",
       "aiUndoTaskWorkflow": "",
       "aiUndoTaskWorkflowInherit": "",
-      "aiUndoTaskWorkflowHelp": ""
+      "aiUndoTaskWorkflowHelp": "",
+      "workspaceModeHint": "",
+      "allowAbsoluteFileBrowserPathsHint": "",
+      "quickChatLauncherHint": "",
+      "showTaskChatsInCommonFeedHint": "",
+      "whenEnabledImportedGitHubIssuesUseTheirSource": "",
+      "gitLabEnabledHint": "",
+      "allowEphemeralAgentsToCreateTasksHint": "",
+      "quickChatCloseOnOutsideClickHint": "",
+      "disabledFusionWorkflowsAreHiddenFromWorkflow": ""
     },
     "globalGeneral": {
       "andShowsUpdateNoticesInTheCLIAnd": "",
@@ -5880,7 +5894,13 @@
       "whenDisabledToolRowsAreStillLoggedBut": "",
       "whenEnabledDefaultTheDashboardAutomaticallyReloadsWhen": "",
       "whenEnabledFusionChecksNpmForNewVersions": "",
-      "whenEnabledTheDashboardProbesForAGlobally": ""
+      "whenEnabledTheDashboardProbesForAGlobally": "",
+      "gitLabEnabledHint": "",
+      "gitLabInstanceUrlHint": "",
+      "gitLabApiBaseUrlHint": "",
+      "gitLabTokenTypeHint": "",
+      "gitLabAuthTokenHint": "",
+      "dismissModalsByClickingOutsideHint": ""
     },
     "globalModels": {
       "allow": "",
@@ -5925,7 +5945,14 @@
       "usedAutomaticallyIfThePrimaryDefaultModelHits": "",
       "useDefault": "",
       "whenEnabledStartupFetchesTheLatestAvailableModels": "",
-      "whenEnabledStartupRefreshesModelsThroughTheLocal": ""
+      "whenEnabledStartupRefreshesModelsThroughTheLocal": "",
+      "commaSeparatedValuesSentToOpenRouterModelSyncOutputModalities": "",
+      "openRouterRoutingOrderHint": "",
+      "openRouterRoutingIgnoreHint": "",
+      "openRouterRoutingOnlyHint": "",
+      "openRouterAllowFallbacksHint": "",
+      "openRouterRoutingSortHint": "",
+      "requireParametersHint": ""
     },
     "header": {
       "discord": "Discord",
@@ -6156,7 +6183,13 @@
       "planApprovalModeAutoApproveAll": "Auto-approve all tasks",
       "planApprovalModeHelp": "Project-wide override for the planning approval gate. Leave on workflow to use each workflow's Require plan approval setting, or force all approved specs to bypass or wait for manual approval.",
       "planApprovalModeRequireAll": "Require approval for all tasks",
-      "planApprovalModeWorkflow": "Use workflow setting"
+      "planApprovalModeWorkflow": "Use workflow setting",
+      "githubAuthTokenHint": "",
+      "gitLabAuthDetails": "",
+      "gitLabPersonalAccessToken": "",
+      "gitLabAuthTokenHint": "",
+      "includeTaskIdInCommitDefault": "",
+      "trailerEmail": ""
     },
     "mergeManually": "Fusionner manuellement",
     "mobileNav": {
@@ -6201,7 +6234,8 @@
       "selectedNode": "",
       "theseSettingsApplyAtTheProjectLevel": "",
       "unavailableNodePolicy": "",
-      "usedWhenATaskHasNoNodeOverride": ""
+      "usedWhenATaskHasNoNodeOverride": "",
+      "unavailableNodePolicyHint": ""
     },
     "nodeSync": {
       "alwaysAsk": "",
@@ -6219,7 +6253,9 @@
       "nodeSync": "",
       "syncInterval": "",
       "syncModelAuthCredentials": "",
-      "workflowSettingsNotSynced": ""
+      "workflowSettingsNotSynced": "",
+      "syncIntervalHint": "",
+      "conflictResolutionHint": ""
     },
     "notifications": {
       "accessTokenOptional": "",
@@ -6263,7 +6299,11 @@
       "webhook": "",
       "webhookNotifications": "",
       "webhookURL": "",
-      "yourNtfyShTopicName164Alphanumeric": ""
+      "yourNtfyShTopicName164Alphanumeric": "",
+      "ntfyEnabledHint": "",
+      "webhookEnabledHint": "",
+      "webhookUrlHint": "",
+      "webhookFormatHint": ""
     },
     "plugins": {
       "fusionPlugins": "",
@@ -6311,7 +6351,10 @@
       "useDefault": "",
       "useWorkflowDefault": "",
       "whenEnabledMergeCommitMessagesIncludeAnAI": "",
-      "whenEnabledTasksCreatedWithoutATitleBut": ""
+      "whenEnabledTasksCreatedWithoutATitleBut": "",
+      "autoSelectModelPresetHint": "",
+      "prTitlePromptInstructionsHelp": "",
+      "prDescriptionPromptInstructionsHelp": ""
     },
     "remote": {
       "acceptRoutes": "",
@@ -6379,7 +6422,10 @@
       "uRLNoHostnameOrPortConfigurationNeeded": "",
       "useExisting": "Utiliser l'existant",
       "usingQuickTunnel": "",
-      "installationFailed": ""
+      "installationFailed": "",
+      "acceptRoutesHint": "",
+      "shortLivedEnabledHint": "",
+      "shortLivedTtlMsHint": ""
     },
     "researchGlobal": {
       "advancedExternalSearchProviders": "",
@@ -6408,7 +6454,16 @@
       "searXNG": "",
       "searXNGURL": "",
       "tavily": "",
-      "webSearch": ""
+      "webSearch": "",
+      "searXNGURLHint": "",
+      "googleSearchCXHint": "",
+      "maxConcurrentRunsHint": "",
+      "maxSourcesPerRunHint": "",
+      "defaultMaxDurationMsHint": "",
+      "requestTimeoutMsHint": "",
+      "maxSynthesisRoundsHint": "",
+      "gitHubSourceHint": "",
+      "localDocsSourceHint": ""
     },
     "researchProject": {
       "alwaysOn": "",
@@ -6424,7 +6479,12 @@
       "projectResearchSettings": "",
       "requestTimeoutMs": "",
       "webSearch": "",
-      "webSearchIsAlwaysEnabledConfigureTheSearch": ""
+      "webSearchIsAlwaysEnabledConfigureTheSearch": "",
+      "enableResearchInThisProjectHint": "",
+      "maxConcurrentRunsHint": "",
+      "maxSourcesPerRunHint": "",
+      "maxDurationMsHint": "",
+      "requestTimeoutMsHint": ""
     },
     "resolveAllLocal": "Résoudre tous : Garder la version locale",
     "resolveAllRemote": "Résoudre tous : Garder la version distante",
@@ -6449,7 +6509,12 @@
       "openai": "",
       "retentionDays": "",
       "scheduledEvals": "",
-      "suggestOnly": ""
+      "suggestOnly": "",
+      "enabledHint": "",
+      "intervalMsHint": "",
+      "evaluatorProviderHint": "",
+      "followUpPolicyHint": "",
+      "retentionDaysHint": ""
     },
     "scheduling": {
       "addIgnoredPath": "",
@@ -6503,7 +6568,9 @@
       "browseWorkspacePath": "",
       "overlapPickerNote": "",
       "ignoreHiddenDotPathsHelp": "",
-      "ignoreHiddenDotPathsInOverlapChecks": ""
+      "ignoreHiddenDotPathsInOverlapChecks": "",
+      "maxConcurrentTasksHint": "",
+      "pollIntervalMsHint": ""
     },
     "scope": {
       "globalBanner": "Ces paramètres sont partagés entre tous vos projets Fusion.",
@@ -6564,7 +6631,11 @@
       "worktrunkBinaryPath": "",
       "worktrunkFailureBehavior": "",
       "worktrunkIntegration": "",
-      "worktreesPickerNote": ""
+      "worktreesPickerNote": "",
+      "showWorktreeGroupingHelp": "",
+      "copyFilesHelp": "",
+      "namingStyleNotApplicableWhenRecycling": "",
+      "howToNameFreshWorktreeDirectories": ""
     },
     "fileBrowser": {
       "currentDirectory": "",
@@ -6574,7 +6645,35 @@
       "globalTitle": "Global MCP servers",
       "projectTitle": "Project MCP servers",
       "globalDescription": "Configure MCP servers shared by all projects. Project settings may override or disable these servers by name.",
-      "projectDescription": "Configure project-specific MCP servers, overrides, and disabled inherited servers."
+      "projectDescription": "Configure project-specific MCP servers, overrides, and disabled inherited servers.",
+      "enabledHint": ""
+    },
+    "search": {
+      "allSections": "",
+      "clear": "",
+      "label": "",
+      "navigationLabel": "",
+      "noMobileOptions": "",
+      "noResults": "",
+      "placeholder": "",
+      "resultCount": ""
+    },
+    "prompts": {
+      "surfaceExplanation": ""
+    },
+    "modelPricing": {
+      "description": ""
+    },
+    "reset": {
+      "button": "",
+      "buttonTitle": "",
+      "dialogAriaLabel": "",
+      "dialogTitle": "",
+      "dialogBody": "",
+      "resetMenuAction": "",
+      "resetAllProjectAction": "",
+      "menuResetSuccess": "",
+      "allProjectResetSuccess": ""
     }
   },
   "setup": {
@@ -7494,7 +7593,8 @@
       "rejected": "Plan rejeté — {{id}} renvoyé en planification pour replanning",
       "rejectMessage": "Rejeter ce plan ? La spécification sera supprimée et régénérée.",
       "rejectTitle": "Rejeter le plan",
-      "replanning": "Replanning de {{id}}…"
+      "replanning": "Replanning de {{id}}…",
+      "releaseAuthorizationHold": ""
     },
     "pr": {
       "awaitingChecks": "En attente des vérifications du PR",
@@ -7522,7 +7622,9 @@
     "provenance": {
       "createdBy": "Créé par",
       "createdVia": "Créé via",
-      "parentTaskOf": ""
+      "parentTaskOf": "",
+      "createdToUndo": "",
+      "undoTask": ""
     },
     "recoveryState": "État de récupération",
     "refine": {
@@ -8131,7 +8233,22 @@
     "addressPrFeedbackFailed": "",
     "addressPrFeedbackStarted": "",
     "addressPrFeedbackTitle": "",
-    "addressingPrFeedback": ""
+    "addressingPrFeedback": "",
+    "awaitingReleaseAuthorization": "",
+    "revert": "",
+    "revertAiCreated": "",
+    "revertAlreadyOpen": "",
+    "revertAlreadyReverted": "",
+    "revertConflictMessage": "",
+    "revertConflictTitle": "",
+    "revertFailed": "",
+    "revertNeedsHuman": "",
+    "revertNeedsHumanDefault": "",
+    "reverted": "",
+    "revertTask": "",
+    "undoOf": "",
+    "undoOfTitle": "",
+    "undoTask": ""
   },
   "terminal": {
     "arrowKeysLabel": "",
diff --git a/packages/i18n/locales/ko/app.json b/packages/i18n/locales/ko/app.json
index b927ec7a21..a3ad02d39c 100644
--- a/packages/i18n/locales/ko/app.json
+++ b/packages/i18n/locales/ko/app.json
@@ -29,7 +29,8 @@
     "showLess": "간략히 보기",
     "showMore": "더 보기",
     "update": "업데이트",
-    "yes": "예"
+    "yes": "예",
+    "clear": ""
   },
   "activityFeed": {
     "emptyHint": "",
@@ -5646,7 +5647,10 @@
       "languageAuto": "자동",
       "languageAutoHint": "브라우저 언어를 따릅니다",
       "suppressTheLdquoNeedsYourInputRdquoBanner": "",
-      "title": "모양"
+      "title": "모양",
+      "openTasksInRightSidebarHelp": "",
+      "openMobileTasksInPopupHelp": "",
+      "taskDetailChatFirstHelp": ""
     },
     "auth": {
       "apiKeyCleared": "API 키가 지워졌습니다",
@@ -5730,7 +5734,8 @@
       "view": "",
       "whenEnabledProjectAndAgentMemoryFilesAre": "",
       "whenEnabledTheDatabaseIsBackedUpAutomatically": "",
-      "createFailed": ""
+      "createFailed": "",
+      "memoryBackupScopeHint": ""
     },
     "clearToDefault": "",
     "cliAgents": {
@@ -5850,7 +5855,16 @@
       "workflowsOrChangelogModeWhenContributorsShouldUpdate": "",
       "aiUndoTaskWorkflow": "",
       "aiUndoTaskWorkflowInherit": "",
-      "aiUndoTaskWorkflowHelp": ""
+      "aiUndoTaskWorkflowHelp": "",
+      "workspaceModeHint": "",
+      "allowAbsoluteFileBrowserPathsHint": "",
+      "quickChatLauncherHint": "",
+      "showTaskChatsInCommonFeedHint": "",
+      "whenEnabledImportedGitHubIssuesUseTheirSource": "",
+      "gitLabEnabledHint": "",
+      "allowEphemeralAgentsToCreateTasksHint": "",
+      "quickChatCloseOnOutsideClickHint": "",
+      "disabledFusionWorkflowsAreHiddenFromWorkflow": ""
     },
     "globalGeneral": {
       "andShowsUpdateNoticesInTheCLIAnd": "",
@@ -5880,7 +5894,13 @@
       "whenDisabledToolRowsAreStillLoggedBut": "",
       "whenEnabledDefaultTheDashboardAutomaticallyReloadsWhen": "",
       "whenEnabledFusionChecksNpmForNewVersions": "",
-      "whenEnabledTheDashboardProbesForAGlobally": ""
+      "whenEnabledTheDashboardProbesForAGlobally": "",
+      "gitLabEnabledHint": "",
+      "gitLabInstanceUrlHint": "",
+      "gitLabApiBaseUrlHint": "",
+      "gitLabTokenTypeHint": "",
+      "gitLabAuthTokenHint": "",
+      "dismissModalsByClickingOutsideHint": ""
     },
     "globalModels": {
       "allow": "",
@@ -5925,7 +5945,14 @@
       "usedAutomaticallyIfThePrimaryDefaultModelHits": "",
       "useDefault": "",
       "whenEnabledStartupFetchesTheLatestAvailableModels": "",
-      "whenEnabledStartupRefreshesModelsThroughTheLocal": ""
+      "whenEnabledStartupRefreshesModelsThroughTheLocal": "",
+      "commaSeparatedValuesSentToOpenRouterModelSyncOutputModalities": "",
+      "openRouterRoutingOrderHint": "",
+      "openRouterRoutingIgnoreHint": "",
+      "openRouterRoutingOnlyHint": "",
+      "openRouterAllowFallbacksHint": "",
+      "openRouterRoutingSortHint": "",
+      "requireParametersHint": ""
     },
     "header": {
       "discord": "Discord",
@@ -6156,7 +6183,13 @@
       "planApprovalModeAutoApproveAll": "Auto-approve all tasks",
       "planApprovalModeHelp": "Project-wide override for the planning approval gate. Leave on workflow to use each workflow's Require plan approval setting, or force all approved specs to bypass or wait for manual approval.",
       "planApprovalModeRequireAll": "Require approval for all tasks",
-      "planApprovalModeWorkflow": "Use workflow setting"
+      "planApprovalModeWorkflow": "Use workflow setting",
+      "githubAuthTokenHint": "",
+      "gitLabAuthDetails": "",
+      "gitLabPersonalAccessToken": "",
+      "gitLabAuthTokenHint": "",
+      "includeTaskIdInCommitDefault": "",
+      "trailerEmail": ""
     },
     "mergeManually": "수동으로 병합",
     "mobileNav": {
@@ -6201,7 +6234,8 @@
       "selectedNode": "",
       "theseSettingsApplyAtTheProjectLevel": "",
       "unavailableNodePolicy": "",
-      "usedWhenATaskHasNoNodeOverride": ""
+      "usedWhenATaskHasNoNodeOverride": "",
+      "unavailableNodePolicyHint": ""
     },
     "nodeSync": {
       "alwaysAsk": "",
@@ -6219,7 +6253,9 @@
       "nodeSync": "",
       "syncInterval": "",
       "syncModelAuthCredentials": "",
-      "workflowSettingsNotSynced": ""
+      "workflowSettingsNotSynced": "",
+      "syncIntervalHint": "",
+      "conflictResolutionHint": ""
     },
     "notifications": {
       "accessTokenOptional": "",
@@ -6263,7 +6299,11 @@
       "webhook": "",
       "webhookNotifications": "",
       "webhookURL": "",
-      "yourNtfyShTopicName164Alphanumeric": ""
+      "yourNtfyShTopicName164Alphanumeric": "",
+      "ntfyEnabledHint": "",
+      "webhookEnabledHint": "",
+      "webhookUrlHint": "",
+      "webhookFormatHint": ""
     },
     "plugins": {
       "fusionPlugins": "",
@@ -6311,7 +6351,10 @@
       "useDefault": "",
       "useWorkflowDefault": "",
       "whenEnabledMergeCommitMessagesIncludeAnAI": "",
-      "whenEnabledTasksCreatedWithoutATitleBut": ""
+      "whenEnabledTasksCreatedWithoutATitleBut": "",
+      "autoSelectModelPresetHint": "",
+      "prTitlePromptInstructionsHelp": "",
+      "prDescriptionPromptInstructionsHelp": ""
     },
     "remote": {
       "acceptRoutes": "",
@@ -6379,7 +6422,10 @@
       "uRLNoHostnameOrPortConfigurationNeeded": "",
       "useExisting": "기존 사용",
       "usingQuickTunnel": "",
-      "installationFailed": ""
+      "installationFailed": "",
+      "acceptRoutesHint": "",
+      "shortLivedEnabledHint": "",
+      "shortLivedTtlMsHint": ""
     },
     "researchGlobal": {
       "advancedExternalSearchProviders": "",
@@ -6408,7 +6454,16 @@
       "searXNG": "",
       "searXNGURL": "",
       "tavily": "",
-      "webSearch": ""
+      "webSearch": "",
+      "searXNGURLHint": "",
+      "googleSearchCXHint": "",
+      "maxConcurrentRunsHint": "",
+      "maxSourcesPerRunHint": "",
+      "defaultMaxDurationMsHint": "",
+      "requestTimeoutMsHint": "",
+      "maxSynthesisRoundsHint": "",
+      "gitHubSourceHint": "",
+      "localDocsSourceHint": ""
     },
     "researchProject": {
       "alwaysOn": "",
@@ -6424,7 +6479,12 @@
       "projectResearchSettings": "",
       "requestTimeoutMs": "",
       "webSearch": "",
-      "webSearchIsAlwaysEnabledConfigureTheSearch": ""
+      "webSearchIsAlwaysEnabledConfigureTheSearch": "",
+      "enableResearchInThisProjectHint": "",
+      "maxConcurrentRunsHint": "",
+      "maxSourcesPerRunHint": "",
+      "maxDurationMsHint": "",
+      "requestTimeoutMsHint": ""
     },
     "resolveAllLocal": "모두 해결: 로컬 유지",
     "resolveAllRemote": "모두 해결: 원격 유지",
@@ -6449,7 +6509,12 @@
       "openai": "",
       "retentionDays": "",
       "scheduledEvals": "",
-      "suggestOnly": ""
+      "suggestOnly": "",
+      "enabledHint": "",
+      "intervalMsHint": "",
+      "evaluatorProviderHint": "",
+      "followUpPolicyHint": "",
+      "retentionDaysHint": ""
     },
     "scheduling": {
       "addIgnoredPath": "",
@@ -6503,7 +6568,9 @@
       "browseWorkspacePath": "",
       "overlapPickerNote": "",
       "ignoreHiddenDotPathsHelp": "",
-      "ignoreHiddenDotPathsInOverlapChecks": ""
+      "ignoreHiddenDotPathsInOverlapChecks": "",
+      "maxConcurrentTasksHint": "",
+      "pollIntervalMsHint": ""
     },
     "scope": {
       "globalBanner": "이 설정은 모든 Fusion 프로젝트에서 공유됩니다.",
@@ -6564,7 +6631,11 @@
       "worktrunkBinaryPath": "",
       "worktrunkFailureBehavior": "",
       "worktrunkIntegration": "",
-      "worktreesPickerNote": ""
+      "worktreesPickerNote": "",
+      "showWorktreeGroupingHelp": "",
+      "copyFilesHelp": "",
+      "namingStyleNotApplicableWhenRecycling": "",
+      "howToNameFreshWorktreeDirectories": ""
     },
     "fileBrowser": {
       "currentDirectory": "",
@@ -6574,7 +6645,35 @@
       "globalTitle": "Global MCP servers",
       "projectTitle": "Project MCP servers",
       "globalDescription": "Configure MCP servers shared by all projects. Project settings may override or disable these servers by name.",
-      "projectDescription": "Configure project-specific MCP servers, overrides, and disabled inherited servers."
+      "projectDescription": "Configure project-specific MCP servers, overrides, and disabled inherited servers.",
+      "enabledHint": ""
+    },
+    "search": {
+      "allSections": "",
+      "clear": "",
+      "label": "",
+      "navigationLabel": "",
+      "noMobileOptions": "",
+      "noResults": "",
+      "placeholder": "",
+      "resultCount": ""
+    },
+    "prompts": {
+      "surfaceExplanation": ""
+    },
+    "modelPricing": {
+      "description": ""
+    },
+    "reset": {
+      "button": "",
+      "buttonTitle": "",
+      "dialogAriaLabel": "",
+      "dialogTitle": "",
+      "dialogBody": "",
+      "resetMenuAction": "",
+      "resetAllProjectAction": "",
+      "menuResetSuccess": "",
+      "allProjectResetSuccess": ""
     }
   },
   "setup": {
@@ -7494,7 +7593,8 @@
       "rejected": "계획 거부됨 — {{id}}이(가) 재계획을 위해 Planning으로 반환됨",
       "rejectMessage": "이 계획을 거부하시겠습니까? 명세가 삭제되고 재생성됩니다.",
       "rejectTitle": "계획 거부",
-      "replanning": "{{id}} 재계획 중…"
+      "replanning": "{{id}} 재계획 중…",
+      "releaseAuthorizationHold": ""
     },
     "pr": {
       "awaitingChecks": "PR 검사 대기 중",
@@ -7522,7 +7622,9 @@
     "provenance": {
       "createdBy": "작성자",
       "createdVia": "생성 경로",
-      "parentTaskOf": ""
+      "parentTaskOf": "",
+      "createdToUndo": "",
+      "undoTask": ""
     },
     "recoveryState": "복구 상태",
     "refine": {
@@ -8131,7 +8233,22 @@
     "addressPrFeedbackFailed": "",
     "addressPrFeedbackStarted": "",
     "addressPrFeedbackTitle": "",
-    "addressingPrFeedback": ""
+    "addressingPrFeedback": "",
+    "awaitingReleaseAuthorization": "",
+    "revert": "",
+    "revertAiCreated": "",
+    "revertAlreadyOpen": "",
+    "revertAlreadyReverted": "",
+    "revertConflictMessage": "",
+    "revertConflictTitle": "",
+    "revertFailed": "",
+    "revertNeedsHuman": "",
+    "revertNeedsHumanDefault": "",
+    "reverted": "",
+    "revertTask": "",
+    "undoOf": "",
+    "undoOfTitle": "",
+    "undoTask": ""
   },
   "terminal": {
     "arrowKeysLabel": "",
diff --git a/packages/i18n/locales/zh-CN/app.json b/packages/i18n/locales/zh-CN/app.json
index 9255dcb5d2..6c7dee07c5 100644
--- a/packages/i18n/locales/zh-CN/app.json
+++ b/packages/i18n/locales/zh-CN/app.json
@@ -29,7 +29,8 @@
     "showLess": "显示更少",
     "showMore": "显示更多",
     "update": "更新",
-    "yes": "是"
+    "yes": "是",
+    "clear": ""
   },
   "activityFeed": {
     "emptyHint": "",
@@ -5646,7 +5647,10 @@
       "languageAuto": "自动",
       "languageAutoHint": "跟随浏览器语言",
       "suppressTheLdquoNeedsYourInputRdquoBanner": "",
-      "title": "外观"
+      "title": "外观",
+      "openTasksInRightSidebarHelp": "",
+      "openMobileTasksInPopupHelp": "",
+      "taskDetailChatFirstHelp": ""
     },
     "auth": {
       "apiKeyCleared": "API 密钥已清除",
@@ -5730,7 +5734,8 @@
       "view": "",
       "whenEnabledProjectAndAgentMemoryFilesAre": "",
       "whenEnabledTheDatabaseIsBackedUpAutomatically": "",
-      "createFailed": ""
+      "createFailed": "",
+      "memoryBackupScopeHint": ""
     },
     "clearToDefault": "",
     "cliAgents": {
@@ -5850,7 +5855,16 @@
       "workflowsOrChangelogModeWhenContributorsShouldUpdate": "",
       "aiUndoTaskWorkflow": "",
       "aiUndoTaskWorkflowInherit": "",
-      "aiUndoTaskWorkflowHelp": ""
+      "aiUndoTaskWorkflowHelp": "",
+      "workspaceModeHint": "",
+      "allowAbsoluteFileBrowserPathsHint": "",
+      "quickChatLauncherHint": "",
+      "showTaskChatsInCommonFeedHint": "",
+      "whenEnabledImportedGitHubIssuesUseTheirSource": "",
+      "gitLabEnabledHint": "",
+      "allowEphemeralAgentsToCreateTasksHint": "",
+      "quickChatCloseOnOutsideClickHint": "",
+      "disabledFusionWorkflowsAreHiddenFromWorkflow": ""
     },
     "globalGeneral": {
       "andShowsUpdateNoticesInTheCLIAnd": "",
@@ -5880,7 +5894,13 @@
       "whenDisabledToolRowsAreStillLoggedBut": "",
       "whenEnabledDefaultTheDashboardAutomaticallyReloadsWhen": "",
       "whenEnabledFusionChecksNpmForNewVersions": "",
-      "whenEnabledTheDashboardProbesForAGlobally": ""
+      "whenEnabledTheDashboardProbesForAGlobally": "",
+      "gitLabEnabledHint": "",
+      "gitLabInstanceUrlHint": "",
+      "gitLabApiBaseUrlHint": "",
+      "gitLabTokenTypeHint": "",
+      "gitLabAuthTokenHint": "",
+      "dismissModalsByClickingOutsideHint": ""
     },
     "globalModels": {
       "allow": "",
@@ -5925,7 +5945,14 @@
       "usedAutomaticallyIfThePrimaryDefaultModelHits": "",
       "useDefault": "",
       "whenEnabledStartupFetchesTheLatestAvailableModels": "",
-      "whenEnabledStartupRefreshesModelsThroughTheLocal": ""
+      "whenEnabledStartupRefreshesModelsThroughTheLocal": "",
+      "commaSeparatedValuesSentToOpenRouterModelSyncOutputModalities": "",
+      "openRouterRoutingOrderHint": "",
+      "openRouterRoutingIgnoreHint": "",
+      "openRouterRoutingOnlyHint": "",
+      "openRouterAllowFallbacksHint": "",
+      "openRouterRoutingSortHint": "",
+      "requireParametersHint": ""
     },
     "header": {
       "discord": "Discord",
@@ -6156,7 +6183,13 @@
       "planApprovalModeAutoApproveAll": "Auto-approve all tasks",
       "planApprovalModeHelp": "Project-wide override for the planning approval gate. Leave on workflow to use each workflow's Require plan approval setting, or force all approved specs to bypass or wait for manual approval.",
       "planApprovalModeRequireAll": "Require approval for all tasks",
-      "planApprovalModeWorkflow": "Use workflow setting"
+      "planApprovalModeWorkflow": "Use workflow setting",
+      "githubAuthTokenHint": "",
+      "gitLabAuthDetails": "",
+      "gitLabPersonalAccessToken": "",
+      "gitLabAuthTokenHint": "",
+      "includeTaskIdInCommitDefault": "",
+      "trailerEmail": ""
     },
     "mergeManually": "手动合并",
     "mobileNav": {
@@ -6201,7 +6234,8 @@
       "selectedNode": "",
       "theseSettingsApplyAtTheProjectLevel": "",
       "unavailableNodePolicy": "",
-      "usedWhenATaskHasNoNodeOverride": ""
+      "usedWhenATaskHasNoNodeOverride": "",
+      "unavailableNodePolicyHint": ""
     },
     "nodeSync": {
       "alwaysAsk": "",
@@ -6219,7 +6253,9 @@
       "nodeSync": "",
       "syncInterval": "",
       "syncModelAuthCredentials": "",
-      "workflowSettingsNotSynced": ""
+      "workflowSettingsNotSynced": "",
+      "syncIntervalHint": "",
+      "conflictResolutionHint": ""
     },
     "notifications": {
       "accessTokenOptional": "",
@@ -6263,7 +6299,11 @@
       "webhook": "",
       "webhookNotifications": "",
       "webhookURL": "",
-      "yourNtfyShTopicName164Alphanumeric": ""
+      "yourNtfyShTopicName164Alphanumeric": "",
+      "ntfyEnabledHint": "",
+      "webhookEnabledHint": "",
+      "webhookUrlHint": "",
+      "webhookFormatHint": ""
     },
     "plugins": {
       "fusionPlugins": "",
@@ -6311,7 +6351,10 @@
       "useDefault": "",
       "useWorkflowDefault": "",
       "whenEnabledMergeCommitMessagesIncludeAnAI": "",
-      "whenEnabledTasksCreatedWithoutATitleBut": ""
+      "whenEnabledTasksCreatedWithoutATitleBut": "",
+      "autoSelectModelPresetHint": "",
+      "prTitlePromptInstructionsHelp": "",
+      "prDescriptionPromptInstructionsHelp": ""
     },
     "remote": {
       "acceptRoutes": "",
@@ -6379,7 +6422,10 @@
       "uRLNoHostnameOrPortConfigurationNeeded": "",
       "useExisting": "使用现有",
       "usingQuickTunnel": "",
-      "installationFailed": ""
+      "installationFailed": "",
+      "acceptRoutesHint": "",
+      "shortLivedEnabledHint": "",
+      "shortLivedTtlMsHint": ""
     },
     "researchGlobal": {
       "advancedExternalSearchProviders": "",
@@ -6408,7 +6454,16 @@
       "searXNG": "",
       "searXNGURL": "",
       "tavily": "",
-      "webSearch": ""
+      "webSearch": "",
+      "searXNGURLHint": "",
+      "googleSearchCXHint": "",
+      "maxConcurrentRunsHint": "",
+      "maxSourcesPerRunHint": "",
+      "defaultMaxDurationMsHint": "",
+      "requestTimeoutMsHint": "",
+      "maxSynthesisRoundsHint": "",
+      "gitHubSourceHint": "",
+      "localDocsSourceHint": ""
     },
     "researchProject": {
       "alwaysOn": "",
@@ -6424,7 +6479,12 @@
       "projectResearchSettings": "",
       "requestTimeoutMs": "",
       "webSearch": "",
-      "webSearchIsAlwaysEnabledConfigureTheSearch": ""
+      "webSearchIsAlwaysEnabledConfigureTheSearch": "",
+      "enableResearchInThisProjectHint": "",
+      "maxConcurrentRunsHint": "",
+      "maxSourcesPerRunHint": "",
+      "maxDurationMsHint": "",
+      "requestTimeoutMsHint": ""
     },
     "resolveAllLocal": "全部解决：保留本地",
     "resolveAllRemote": "全部解决：保留远程",
@@ -6449,7 +6509,12 @@
       "openai": "",
       "retentionDays": "",
       "scheduledEvals": "",
-      "suggestOnly": ""
+      "suggestOnly": "",
+      "enabledHint": "",
+      "intervalMsHint": "",
+      "evaluatorProviderHint": "",
+      "followUpPolicyHint": "",
+      "retentionDaysHint": ""
     },
     "scheduling": {
       "addIgnoredPath": "",
@@ -6503,7 +6568,9 @@
       "browseWorkspacePath": "",
       "overlapPickerNote": "",
       "ignoreHiddenDotPathsHelp": "",
-      "ignoreHiddenDotPathsInOverlapChecks": ""
+      "ignoreHiddenDotPathsInOverlapChecks": "",
+      "maxConcurrentTasksHint": "",
+      "pollIntervalMsHint": ""
     },
     "scope": {
       "globalBanner": "这些设置在所有 Fusion 项目中共享。",
@@ -6564,7 +6631,11 @@
       "worktrunkBinaryPath": "",
       "worktrunkFailureBehavior": "",
       "worktrunkIntegration": "",
-      "worktreesPickerNote": ""
+      "worktreesPickerNote": "",
+      "showWorktreeGroupingHelp": "",
+      "copyFilesHelp": "",
+      "namingStyleNotApplicableWhenRecycling": "",
+      "howToNameFreshWorktreeDirectories": ""
     },
     "fileBrowser": {
       "currentDirectory": "",
@@ -6574,7 +6645,8 @@
       "globalTitle": "Global MCP servers",
       "projectTitle": "Project MCP servers",
       "globalDescription": "Configure MCP servers shared by all projects. Project settings may override or disable these servers by name.",
-      "projectDescription": "Configure project-specific MCP servers, overrides, and disabled inherited servers."
+      "projectDescription": "Configure project-specific MCP servers, overrides, and disabled inherited servers.",
+      "enabledHint": ""
     },
     "reset": {
       "button": "Reset Settings",
@@ -6586,6 +6658,22 @@
       "resetAllProjectAction": "Reset all project settings",
       "menuResetSuccess": "{{section}} settings reset to defaults",
       "allProjectResetSuccess": "All project settings reset to defaults"
+    },
+    "search": {
+      "allSections": "",
+      "clear": "",
+      "label": "",
+      "navigationLabel": "",
+      "noMobileOptions": "",
+      "noResults": "",
+      "placeholder": "",
+      "resultCount": ""
+    },
+    "prompts": {
+      "surfaceExplanation": ""
+    },
+    "modelPricing": {
+      "description": ""
     }
   },
   "setup": {
@@ -7505,7 +7593,8 @@
       "rejected": "计划已拒绝 — {{id}} 已返回规划阶段重新规划",
       "rejectMessage": "拒绝此计划？规范将被丢弃并重新生成。",
       "rejectTitle": "拒绝计划",
-      "replanning": "正在为 {{id}} 重新规划…"
+      "replanning": "正在为 {{id}} 重新规划…",
+      "releaseAuthorizationHold": ""
     },
     "pr": {
       "awaitingChecks": "等待 PR 检查",
@@ -7533,7 +7622,9 @@
     "provenance": {
       "createdBy": "创建者：",
       "createdVia": "通过…创建",
-      "parentTaskOf": ""
+      "parentTaskOf": "",
+      "createdToUndo": "",
+      "undoTask": ""
     },
     "recoveryState": "恢复状态",
     "refine": {
@@ -8142,7 +8233,22 @@
     "addressPrFeedbackFailed": "",
     "addressPrFeedbackStarted": "",
     "addressPrFeedbackTitle": "",
-    "addressingPrFeedback": ""
+    "addressingPrFeedback": "",
+    "awaitingReleaseAuthorization": "",
+    "revert": "",
+    "revertAiCreated": "",
+    "revertAlreadyOpen": "",
+    "revertAlreadyReverted": "",
+    "revertConflictMessage": "",
+    "revertConflictTitle": "",
+    "revertFailed": "",
+    "revertNeedsHuman": "",
+    "revertNeedsHumanDefault": "",
+    "reverted": "",
+    "revertTask": "",
+    "undoOf": "",
+    "undoOfTitle": "",
+    "undoTask": ""
   },
   "terminal": {
     "arrowKeysLabel": "",
diff --git a/packages/i18n/locales/zh-TW/app.json b/packages/i18n/locales/zh-TW/app.json
index ad97aa9853..133c43ac49 100644
--- a/packages/i18n/locales/zh-TW/app.json
+++ b/packages/i18n/locales/zh-TW/app.json
@@ -29,7 +29,8 @@
     "showLess": "顯示較少",
     "showMore": "顯示更多",
     "update": "更新",
-    "yes": "是"
+    "yes": "是",
+    "clear": ""
   },
   "activityFeed": {
     "emptyHint": "",
@@ -5646,7 +5647,10 @@
       "languageAuto": "自動",
       "languageAutoHint": "跟隨瀏覽器語言",
       "suppressTheLdquoNeedsYourInputRdquoBanner": "",
-      "title": "外觀"
+      "title": "外觀",
+      "openTasksInRightSidebarHelp": "",
+      "openMobileTasksInPopupHelp": "",
+      "taskDetailChatFirstHelp": ""
     },
     "auth": {
       "apiKeyCleared": "API 金鑰已清除",
@@ -5730,7 +5734,8 @@
       "view": "",
       "whenEnabledProjectAndAgentMemoryFilesAre": "",
       "whenEnabledTheDatabaseIsBackedUpAutomatically": "",
-      "createFailed": ""
+      "createFailed": "",
+      "memoryBackupScopeHint": ""
     },
     "clearToDefault": "",
     "cliAgents": {
@@ -5850,7 +5855,16 @@
       "workflowsOrChangelogModeWhenContributorsShouldUpdate": "",
       "aiUndoTaskWorkflow": "",
       "aiUndoTaskWorkflowInherit": "",
-      "aiUndoTaskWorkflowHelp": ""
+      "aiUndoTaskWorkflowHelp": "",
+      "workspaceModeHint": "",
+      "allowAbsoluteFileBrowserPathsHint": "",
+      "quickChatLauncherHint": "",
+      "showTaskChatsInCommonFeedHint": "",
+      "whenEnabledImportedGitHubIssuesUseTheirSource": "",
+      "gitLabEnabledHint": "",
+      "allowEphemeralAgentsToCreateTasksHint": "",
+      "quickChatCloseOnOutsideClickHint": "",
+      "disabledFusionWorkflowsAreHiddenFromWorkflow": ""
     },
     "globalGeneral": {
       "andShowsUpdateNoticesInTheCLIAnd": "",
@@ -5880,7 +5894,13 @@
       "whenDisabledToolRowsAreStillLoggedBut": "",
       "whenEnabledDefaultTheDashboardAutomaticallyReloadsWhen": "",
       "whenEnabledFusionChecksNpmForNewVersions": "",
-      "whenEnabledTheDashboardProbesForAGlobally": ""
+      "whenEnabledTheDashboardProbesForAGlobally": "",
+      "gitLabEnabledHint": "",
+      "gitLabInstanceUrlHint": "",
+      "gitLabApiBaseUrlHint": "",
+      "gitLabTokenTypeHint": "",
+      "gitLabAuthTokenHint": "",
+      "dismissModalsByClickingOutsideHint": ""
     },
     "globalModels": {
       "allow": "",
@@ -5925,7 +5945,14 @@
       "usedAutomaticallyIfThePrimaryDefaultModelHits": "",
       "useDefault": "",
       "whenEnabledStartupFetchesTheLatestAvailableModels": "",
-      "whenEnabledStartupRefreshesModelsThroughTheLocal": ""
+      "whenEnabledStartupRefreshesModelsThroughTheLocal": "",
+      "commaSeparatedValuesSentToOpenRouterModelSyncOutputModalities": "",
+      "openRouterRoutingOrderHint": "",
+      "openRouterRoutingIgnoreHint": "",
+      "openRouterRoutingOnlyHint": "",
+      "openRouterAllowFallbacksHint": "",
+      "openRouterRoutingSortHint": "",
+      "requireParametersHint": ""
     },
     "header": {
       "discord": "Discord",
@@ -6156,7 +6183,13 @@
       "planApprovalModeAutoApproveAll": "Auto-approve all tasks",
       "planApprovalModeHelp": "Project-wide override for the planning approval gate. Leave on workflow to use each workflow's Require plan approval setting, or force all approved specs to bypass or wait for manual approval.",
       "planApprovalModeRequireAll": "Require approval for all tasks",
-      "planApprovalModeWorkflow": "Use workflow setting"
+      "planApprovalModeWorkflow": "Use workflow setting",
+      "githubAuthTokenHint": "",
+      "gitLabAuthDetails": "",
+      "gitLabPersonalAccessToken": "",
+      "gitLabAuthTokenHint": "",
+      "includeTaskIdInCommitDefault": "",
+      "trailerEmail": ""
     },
     "mergeManually": "手動合併",
     "mobileNav": {
@@ -6201,7 +6234,8 @@
       "selectedNode": "",
       "theseSettingsApplyAtTheProjectLevel": "",
       "unavailableNodePolicy": "",
-      "usedWhenATaskHasNoNodeOverride": ""
+      "usedWhenATaskHasNoNodeOverride": "",
+      "unavailableNodePolicyHint": ""
     },
     "nodeSync": {
       "alwaysAsk": "",
@@ -6219,7 +6253,9 @@
       "nodeSync": "",
       "syncInterval": "",
       "syncModelAuthCredentials": "",
-      "workflowSettingsNotSynced": ""
+      "workflowSettingsNotSynced": "",
+      "syncIntervalHint": "",
+      "conflictResolutionHint": ""
     },
     "notifications": {
       "accessTokenOptional": "",
@@ -6263,7 +6299,11 @@
       "webhook": "",
       "webhookNotifications": "",
       "webhookURL": "",
-      "yourNtfyShTopicName164Alphanumeric": ""
+      "yourNtfyShTopicName164Alphanumeric": "",
+      "ntfyEnabledHint": "",
+      "webhookEnabledHint": "",
+      "webhookUrlHint": "",
+      "webhookFormatHint": ""
     },
     "plugins": {
       "fusionPlugins": "",
@@ -6311,7 +6351,10 @@
       "useDefault": "",
       "useWorkflowDefault": "",
       "whenEnabledMergeCommitMessagesIncludeAnAI": "",
-      "whenEnabledTasksCreatedWithoutATitleBut": ""
+      "whenEnabledTasksCreatedWithoutATitleBut": "",
+      "autoSelectModelPresetHint": "",
+      "prTitlePromptInstructionsHelp": "",
+      "prDescriptionPromptInstructionsHelp": ""
     },
     "remote": {
       "acceptRoutes": "",
@@ -6379,7 +6422,10 @@
       "uRLNoHostnameOrPortConfigurationNeeded": "",
       "useExisting": "使用現有",
       "usingQuickTunnel": "",
-      "installationFailed": ""
+      "installationFailed": "",
+      "acceptRoutesHint": "",
+      "shortLivedEnabledHint": "",
+      "shortLivedTtlMsHint": ""
     },
     "researchGlobal": {
       "advancedExternalSearchProviders": "",
@@ -6408,7 +6454,16 @@
       "searXNG": "",
       "searXNGURL": "",
       "tavily": "",
-      "webSearch": ""
+      "webSearch": "",
+      "searXNGURLHint": "",
+      "googleSearchCXHint": "",
+      "maxConcurrentRunsHint": "",
+      "maxSourcesPerRunHint": "",
+      "defaultMaxDurationMsHint": "",
+      "requestTimeoutMsHint": "",
+      "maxSynthesisRoundsHint": "",
+      "gitHubSourceHint": "",
+      "localDocsSourceHint": ""
     },
     "researchProject": {
       "alwaysOn": "",
@@ -6424,7 +6479,12 @@
       "projectResearchSettings": "",
       "requestTimeoutMs": "",
       "webSearch": "",
-      "webSearchIsAlwaysEnabledConfigureTheSearch": ""
+      "webSearchIsAlwaysEnabledConfigureTheSearch": "",
+      "enableResearchInThisProjectHint": "",
+      "maxConcurrentRunsHint": "",
+      "maxSourcesPerRunHint": "",
+      "maxDurationMsHint": "",
+      "requestTimeoutMsHint": ""
     },
     "resolveAllLocal": "全部解決：保留本機",
     "resolveAllRemote": "全部解決：保留遠端",
@@ -6449,7 +6509,12 @@
       "openai": "",
       "retentionDays": "",
       "scheduledEvals": "",
-      "suggestOnly": ""
+      "suggestOnly": "",
+      "enabledHint": "",
+      "intervalMsHint": "",
+      "evaluatorProviderHint": "",
+      "followUpPolicyHint": "",
+      "retentionDaysHint": ""
     },
     "scheduling": {
       "addIgnoredPath": "",
@@ -6503,7 +6568,9 @@
       "browseWorkspacePath": "",
       "overlapPickerNote": "",
       "ignoreHiddenDotPathsHelp": "",
-      "ignoreHiddenDotPathsInOverlapChecks": ""
+      "ignoreHiddenDotPathsInOverlapChecks": "",
+      "maxConcurrentTasksHint": "",
+      "pollIntervalMsHint": ""
     },
     "scope": {
       "globalBanner": "這些設定在所有 Fusion 專案中共用。",
@@ -6564,7 +6631,11 @@
       "worktrunkBinaryPath": "",
       "worktrunkFailureBehavior": "",
       "worktrunkIntegration": "",
-      "worktreesPickerNote": ""
+      "worktreesPickerNote": "",
+      "showWorktreeGroupingHelp": "",
+      "copyFilesHelp": "",
+      "namingStyleNotApplicableWhenRecycling": "",
+      "howToNameFreshWorktreeDirectories": ""
     },
     "fileBrowser": {
       "currentDirectory": "",
@@ -6574,7 +6645,35 @@
       "globalTitle": "Global MCP servers",
       "projectTitle": "Project MCP servers",
       "globalDescription": "Configure MCP servers shared by all projects. Project settings may override or disable these servers by name.",
-      "projectDescription": "Configure project-specific MCP servers, overrides, and disabled inherited servers."
+      "projectDescription": "Configure project-specific MCP servers, overrides, and disabled inherited servers.",
+      "enabledHint": ""
+    },
+    "search": {
+      "allSections": "",
+      "clear": "",
+      "label": "",
+      "navigationLabel": "",
+      "noMobileOptions": "",
+      "noResults": "",
+      "placeholder": "",
+      "resultCount": ""
+    },
+    "prompts": {
+      "surfaceExplanation": ""
+    },
+    "modelPricing": {
+      "description": ""
+    },
+    "reset": {
+      "button": "",
+      "buttonTitle": "",
+      "dialogAriaLabel": "",
+      "dialogTitle": "",
+      "dialogBody": "",
+      "resetMenuAction": "",
+      "resetAllProjectAction": "",
+      "menuResetSuccess": "",
+      "allProjectResetSuccess": ""
     }
   },
   "setup": {
@@ -7494,7 +7593,8 @@
       "rejected": "計劃已拒絕 — {{id}} 已返回規劃階段重新規劃",
       "rejectMessage": "拒絕此計劃？規範將被丟棄並重新生成。",
       "rejectTitle": "拒絕計劃",
-      "replanning": "正在為 {{id}} 重新規劃…"
+      "replanning": "正在為 {{id}} 重新規劃…",
+      "releaseAuthorizationHold": ""
     },
     "pr": {
       "awaitingChecks": "等待 PR 檢查",
@@ -7522,7 +7622,9 @@
     "provenance": {
       "createdBy": "創建者：",
       "createdVia": "通過…建立",
-      "parentTaskOf": ""
+      "parentTaskOf": "",
+      "createdToUndo": "",
+      "undoTask": ""
     },
     "recoveryState": "恢復狀態",
     "refine": {
@@ -8131,7 +8233,22 @@
     "addressPrFeedbackFailed": "",
     "addressPrFeedbackStarted": "",
     "addressPrFeedbackTitle": "",
-    "addressingPrFeedback": ""
+    "addressingPrFeedback": "",
+    "awaitingReleaseAuthorization": "",
+    "revert": "",
+    "revertAiCreated": "",
+    "revertAlreadyOpen": "",
+    "revertAlreadyReverted": "",
+    "revertConflictMessage": "",
+    "revertConflictTitle": "",
+    "revertFailed": "",
+    "revertNeedsHuman": "",
+    "revertNeedsHumanDefault": "",
+    "reverted": "",
+    "revertTask": "",
+    "undoOf": "",
+    "undoOfTitle": "",
+    "undoTask": ""
   },
   "terminal": {
     "arrowKeysLabel": "",

From 45e5a269e86a416a70aa86d0835238f27c5310cb Mon Sep 17 00:00:00 2001
From: gsxdsm <gsxdsm@users.noreply.github.com>
Date: Sun, 5 Jul 2026 10:51:44 -0700
Subject: [PATCH 30/65] fix(FN-7579): stop tracking-issue dedup from linking
 new tasks to stale issues

GitHub tracking-issue creation reused old/closed issues via dedup:
- searched state:"all", so a resolved issue from an unrelated task could be reused
- accepted keyword-only matches (generic shared identifiers) with no file overlap

Dedup now only reuses OPEN issues and requires a File-Scope path overlap;
without an open path-overlapping issue a fresh tracking issue is always created.
Adds two regression tests asserting closed and keyword-only matches are not reused.

Fusion-Task-Id: FN-7579

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 .../fn-7579-tracking-dedup-stale-issue.md     |  7 ++
 .../src/__tests__/github-tracking.test.ts     | 71 ++++++++++++++++++-
 packages/dashboard/src/github-tracking.ts     | 17 ++++-
 3 files changed, 91 insertions(+), 4 deletions(-)
 create mode 100644 .changeset/fn-7579-tracking-dedup-stale-issue.md

diff --git a/.changeset/fn-7579-tracking-dedup-stale-issue.md b/.changeset/fn-7579-tracking-dedup-stale-issue.md
new file mode 100644
index 0000000000..9a3d2d26c8
--- /dev/null
+++ b/.changeset/fn-7579-tracking-dedup-stale-issue.md
@@ -0,0 +1,7 @@
+---
+"@runfusion/fusion": patch
+---
+
+summary: Stop GitHub tracking-issue creation from linking new tasks to old/closed issues.
+category: fix
+dev: github-tracking dedup now only reuses OPEN issues and requires a File-Scope path overlap (keyword-only matches no longer link). Prevents mis-linking a fresh task to a stale/resolved tracking issue (FN-7579). Setting `githubTrackingDedupEnabled` unchanged.
diff --git a/packages/dashboard/src/__tests__/github-tracking.test.ts b/packages/dashboard/src/__tests__/github-tracking.test.ts
index bec42bcd84..140e2095d8 100644
--- a/packages/dashboard/src/__tests__/github-tracking.test.ts
+++ b/packages/dashboard/src/__tests__/github-tracking.test.ts
@@ -254,13 +254,14 @@ describe("maybeCreateTrackingIssue", () => {
     const linkGithubIssue = vi.fn();
     const recordActivity = vi.fn();
 
+    // FNXC:GithubTracking Only OPEN issues may be reused (a shared File-Scope path is present here).
     searchIssuesMock.mockResolvedValue([
       {
         number: 400,
         title: "Diff route truncation in packages/dashboard/src/routes/register-session-diff-routes.ts",
         body: "rebase-merge path drops output",
         html_url: "https://github.com/o/r/issues/400",
-        state: "closed",
+        state: "open",
         updatedAt: "2026-05-01T00:00:00.000Z",
       },
     ]);
@@ -290,6 +291,74 @@ describe("maybeCreateTrackingIssue", () => {
     }));
   });
 
+  // FNXC:GithubTracking 2026-07-05 Regression (FN-7579): dedup mis-linked new tasks to old/stale issues.
+  // Surfaces: (1) a resolved CLOSED issue that path+keyword-matches must NOT be reused; (2) an OPEN
+  // issue that matches only on generic keywords (zero File-Scope path overlap) must NOT be reused.
+  // Invariant: the only reusable candidate is an OPEN issue sharing at least one File-Scope path.
+  it("does not reuse a CLOSED issue even when file scope and keywords match (FN-7579 stale-issue regression)", async () => {
+    const linkGithubIssue = vi.fn();
+
+    searchIssuesMock.mockResolvedValue([
+      {
+        number: 500,
+        title: "Diff route truncation in packages/dashboard/src/routes/register-session-diff-routes.ts",
+        body: "rebase-merge truncation resolved long ago",
+        html_url: "https://github.com/o/r/issues/500",
+        state: "closed",
+        updatedAt: "2026-01-01T00:00:00.000Z",
+      },
+    ]);
+
+    const result = await maybeCreateTrackingIssue(buildTask({
+      title: "Fix rebase-merge truncation in registerSessionDiffRoutes",
+      description: "## File Scope\n- packages/dashboard/src/routes/register-session-diff-routes.ts",
+      githubTracking: { enabled: true },
+    }), {
+      taskStore: { linkGithubIssue, recordActivity: vi.fn() } as any,
+      projectSettings: {},
+      globalSettings: { githubTrackingDefaultRepo: "o/r" } as any,
+      rootDir,
+      logger: { warn: vi.fn(), info: vi.fn() },
+    });
+
+    expect(result).toMatchObject({ created: true });
+    expect(createIssueMock).toHaveBeenCalledTimes(1);
+    expect(linkGithubIssue).toHaveBeenCalledWith("FN-1", expect.objectContaining({ number: 12 }));
+    expect(linkGithubIssue).not.toHaveBeenCalledWith("FN-1", expect.objectContaining({ number: 500 }));
+  });
+
+  it("does not reuse an OPEN issue matched on keywords only when no file-scope path overlaps (FN-7579)", async () => {
+    const linkGithubIssue = vi.fn();
+
+    // Shares generic identifiers (truncation / registerSessionDiffRoutes) but references a DIFFERENT file.
+    searchIssuesMock.mockResolvedValue([
+      {
+        number: 501,
+        title: "truncation bug in registerSessionDiffRoutes helper",
+        body: "affects packages/dashboard/src/routes/register-other-routes.ts truncation registerSessionDiffRoutes",
+        html_url: "https://github.com/o/r/issues/501",
+        state: "open",
+        updatedAt: "2026-06-01T00:00:00.000Z",
+      },
+    ]);
+
+    const result = await maybeCreateTrackingIssue(buildTask({
+      title: "Fix rebase-merge truncation in registerSessionDiffRoutes",
+      description: "## File Scope\n- packages/dashboard/src/routes/register-session-diff-routes.ts",
+      githubTracking: { enabled: true },
+    }), {
+      taskStore: { linkGithubIssue, recordActivity: vi.fn() } as any,
+      projectSettings: {},
+      globalSettings: { githubTrackingDefaultRepo: "o/r" } as any,
+      rootDir,
+      logger: { warn: vi.fn(), info: vi.fn() },
+    });
+
+    expect(result).toMatchObject({ created: true });
+    expect(createIssueMock).toHaveBeenCalledTimes(1);
+    expect(linkGithubIssue).not.toHaveBeenCalledWith("FN-1", expect.objectContaining({ number: 501 }));
+  });
+
   it("falls through to create issue when dedup search has no qualifying match", async () => {
     searchIssuesMock.mockResolvedValue([
       {
diff --git a/packages/dashboard/src/github-tracking.ts b/packages/dashboard/src/github-tracking.ts
index 62c6a83919..76ac4a6f83 100644
--- a/packages/dashboard/src/github-tracking.ts
+++ b/packages/dashboard/src/github-tracking.ts
@@ -354,11 +354,20 @@ export async function maybeCreateTrackingIssue(
   const title = formatTrackingIssueTitle(latestTask);
   const body = formatTrackingIssueBody(latestTask);
 
+  /*
+  FNXC:GithubTracking 2026-07-05-00:00:
+  Tracking-issue dedup was mis-linking new tasks to OLD/STALE issues (operator report: FN-7579 got an old issue id instead of a fresh one).
+  Two false-positive vectors, both fixed here:
+    1. Search included CLOSED issues (state: "all"), so a resolved tracking issue from an earlier, unrelated task could be reused. Dedup only exists to avoid opening a *second live* issue for the same active work — a closed/resolved issue must never be reused. We now search and accept OPEN issues only.
+    2. The accept filter allowed a keyword-only match (matchedKeywords >= 2 with zero file-path overlap). Symptom keywords are generic camelCase identifiers shared across many tasks (e.g. `githubTracking`, `trackingIssue`), so 2-3 shared tokens is a weak signal that routinely mis-matched. We now require at least one File-Scope path overlap before reusing an issue; keyword count only breaks ties / raises confidence.
+  Net effect: a task with no File-Scope paths (or no OPEN path-overlapping issue) always creates a fresh tracking issue rather than mis-linking. See docs/triage-duplicate-detection-postmortem.md.
+  */
   if (deps.projectSettings.githubTrackingDedupEnabled !== false) {
     try {
       const paths = extractFileScopePaths(latestTask as Task & { prompt?: string });
       const keywords = extractSymptomKeywords(latestTask, { max: 6 });
-      if (paths.length > 0 || keywords.length > 0) {
+      // FNXC:GithubTracking Path overlap is now mandatory for a dedup link — without File-Scope paths there is no strong-enough signal, so skip the search entirely and create fresh.
+      if (paths.length > 0) {
         const queries = buildIssueSearchQueries(paths, keywords);
         const byNumber = new Map<number, {
           number: number;
@@ -370,8 +379,10 @@ export async function maybeCreateTrackingIssue(
         }>();
 
         for (const query of queries) {
-          const candidates = await githubClient.searchIssues(repo.owner, repo.repo, query, { state: "all", limit: 10 });
+          const candidates = await githubClient.searchIssues(repo.owner, repo.repo, query, { state: "open", limit: 10 });
           for (const candidate of candidates) {
+            // FNXC:GithubTracking Defensive: never reuse a closed/resolved issue even if the API returns one.
+            if (candidate.state !== "open") continue;
             if (!byNumber.has(candidate.number)) {
               byNumber.set(candidate.number, candidate);
             }
@@ -380,7 +391,7 @@ export async function maybeCreateTrackingIssue(
           const scored = [...byNumber.values()]
             .map((candidate) => ({ candidate, ...scoreCandidateIssue(candidate, paths, keywords) }))
             .filter((entry) => entry.score >= DEDUP_MATCH_THRESHOLD)
-            .filter((entry) => entry.matchedPaths.length > 0 || entry.matchedKeywords.length >= 2)
+            .filter((entry) => entry.matchedPaths.length > 0)
             .sort((a, b) => b.score - a.score);
 
           const bestMatch = scored[0];

From 78d4db94d8dc6b2102ce20f217cd980befad92b4 Mon Sep 17 00:00:00 2001
From: gsxdsm <gsxdsm@users.noreply.github.com>
Date: Sun, 5 Jul 2026 10:54:41 -0700
Subject: [PATCH 31/65] FN-7575: add release version lines to Fusion self-repo
 done comments

Extends GitHubIssueCommentService so task-close comments on issues in the runfusion/fusion repo itself append both a current-version and target-next-minor-release line, while comments on all other linked repos stay byte-for-byte unchanged.

- Add isFusionSelfRepo() and computeNextMinorVersion() helpers to github-issue-comment.ts
- Append "Current version: v{current}" and "Target release: v{next-minor}" lines only when the linked source issue's repo is runfusion/fusion (case-insensitive)
- Fall back silently (no version lines) when the resolved version is unparseable or the unresolved 0.0.0 sentinel
- Add changeset (minor) documenting the new behavior
- Update docs/settings-reference.md and docs/gitlab-parity-inventory.md
- Expand github-issue-comment.test.ts coverage for self-repo vs other-repo behavior and version edge cases

Files changed:
 .changeset/fn-7575-release-version-comment.md      |   7 +
 docs/gitlab-parity-inventory.md                    |   2 +-
 docs/settings-reference.md                         |   2 +-
 packages/dashboard/src/__tests__/github-issue-comment.test.ts | 142 ++++++++++++++++++++-
 packages/dashboard/src/github-issue-comment.ts     |  69 +++++++++-
 5 files changed, 212 insertions(+), 10 deletions(-)

Fusion-Task-Id: FN-7575

Fusion-Task-Lineage: b7cf7e6f-8d96-4442-8595-5d54ea911481

Co-authored-by: Fusion (runfusion.ai) <noreply@runfusion.ai>
---
 .changeset/fn-7575-release-version-comment.md |   7 +
 docs/gitlab-parity-inventory.md               |   2 +-
 docs/settings-reference.md                    |   2 +-
 .../__tests__/github-issue-comment.test.ts    | 142 +++++++++++++++++-
 .../dashboard/src/github-issue-comment.ts     |  69 ++++++++-
 5 files changed, 212 insertions(+), 10 deletions(-)
 create mode 100644 .changeset/fn-7575-release-version-comment.md

diff --git a/.changeset/fn-7575-release-version-comment.md b/.changeset/fn-7575-release-version-comment.md
new file mode 100644
index 0000000000..e06e707639
--- /dev/null
+++ b/.changeset/fn-7575-release-version-comment.md
@@ -0,0 +1,7 @@
+---
+"@runfusion/fusion": minor
+---
+
+summary: Fusion self-repo issue-close comments now show current and target release versions.
+category: feature
+dev: GitHubIssueCommentService appends "Current version: v{current}" and "Target release: v{next-minor}" lines when the linked source issue is runfusion/fusion; other repos unchanged. Version resolved via getCliPackageVersion.
diff --git a/docs/gitlab-parity-inventory.md b/docs/gitlab-parity-inventory.md
index d5c0a0702e..e00d340dd6 100644
--- a/docs/gitlab-parity-inventory.md
+++ b/docs/gitlab-parity-inventory.md
@@ -41,7 +41,7 @@ Required included surfaces: issue import, linked issue tracking, completion comm
 | Post-create tracking hook | `registerGithubTrackingHook()` registers a universal post-create hook for dashboard, CLI, extension, mission, automation, delegation, routine, duplicate/refine, and subtask creation paths. | `github-tracking-hook.ts`; `docs/task-management.md` | GitLab tracking must register an equivalent universal post-create hook at the same process entrypoints, or a provider-neutral hook dispatcher that calls GitHub/GitLab handlers. It must be best-effort and non-blocking. |
 | Tracking title/body format | GitHub tracking issues use title `[FN-XXXX] Task title` and body prefix `Fusion task: FN-XXXX` with bounded plain-text summary. | `github-tracking.ts`; docs contract test | GitLab tracking issues should use the same title/body invariant unless later UX explicitly changes it. Keep body bounded and do not include local dashboard links. |
 | Tracking lifecycle comments | GitHub posts lifecycle comments on tracked issues for in-progress/done, with bounded plain text and optional merge metadata. | `github-tracking-comments.ts` | GitLab should post issue notes for the same lifecycle moments to linked GitLab tracking issues. Merge-request notes are only relevant for imported MR review tasks and must be designed separately. |
-| Completion comments on source issues | `githubCommentOnDone` and optional `githubCommentTemplate` post a completion comment to imported GitHub source issues when tasks enter done. | `github-issue-comment.ts`; settings | Add GitLab equivalents using project issue notes. The template placeholders should remain provider-neutral (`{taskId}`, `{taskTitle}`) or be explicitly duplicated with `gitlabCommentOnDone`/`gitlabCommentTemplate`. Group issue imports still comment through owning project issue notes. |
+| Completion comments on source issues | `githubCommentOnDone` and optional `githubCommentTemplate` post a completion comment to imported GitHub source issues when tasks enter done. On GitHub, when the linked source issue's repository is the Fusion self-repo (`runfusion/fusion`, case-insensitive), the comment additionally appends `Current version:` and `Target release:` lines (next-minor bump of the resolved `@runfusion/fusion` CLI package version); this enrichment is GitHub/Fusion-specific and intentionally out of scope for this GitLab parity pass. | `github-issue-comment.ts`; settings | Add GitLab equivalents using project issue notes. The template placeholders should remain provider-neutral (`{taskId}`, `{taskTitle}`) or be explicitly duplicated with `gitlabCommentOnDone`/`gitlabCommentTemplate`. Group issue imports still comment through owning project issue notes. A GitLab release-version enrichment equivalent is not implemented here — file a follow-up if needed. |
 | Auto-close imported source issues | `githubCloseSourceIssueOnDone` closes/reopens source-imported GitHub issues on task state transitions and startup reconciliation closes missed done tasks. | `github-source-issue-close.ts`; `github-tracking-reconciler.ts` | Add GitLab source issue close/reopen on imported project issues. Reconciliation must use stored GitLab project identity plus issue IID/global ID. Group issue rows cannot be closed through group endpoint; resolve owning project first. Do not auto-close or merge merge requests unless a later task explicitly adds an MR policy. |
 | Source issue close timestamp backfill | Command Center GitHub fixed counts can be made exact by `POST /api/git/github/backfill-source-issue-closed-at` in manual batches. | `GithubArea.tsx`; `register-git-github.ts`; `TaskSourceIssue.closedAt` | Add a GitLab manual backfill for imported GitLab source issues/MRs if analytics need exact close/merged timestamps. It must be an explicit operator action and never run during render-time analytics. |
 | Webhooks for linked state | `POST /api/github/webhooks` verifies GitHub App signatures and updates issue/PR/task badges from pull_request/issues/issue_comment events. | `github-webhooks.ts`; `register-git-github.ts` | GitLab webhook support should use GitLab project/group/system hooks as provider-specific signed signal ingestion. Badge/state update hooks for GitLab-linked issues/MRs are separate from Command Center Signals but can reuse signature-validation patterns. Document exact GitLab headers/secrets in the implementation task. |
diff --git a/docs/settings-reference.md b/docs/settings-reference.md
index ec706ab760..a86961953a 100644
--- a/docs/settings-reference.md
+++ b/docs/settings-reference.md
@@ -604,7 +604,7 @@ Default notes:
 | `archiveAgentLogMode` | `"none" \| "compact" \| "full"` | `"compact"` | Agent log retention strategy for cold archive snapshots. |
 | `autoUpdatePrStatus` | `boolean` | `false` | Auto-refresh PR status badges. |
 | `githubCommentOnDone` | `boolean` | `false` | When enabled, tasks imported from GitHub issues post a completion comment to the source issue when the task moves to `done`. |
-| `githubCommentTemplate` | `string` | `undefined` | Optional issue comment template used by `githubCommentOnDone`. Supports `{taskId}` and `{taskTitle}` placeholders. If unset, Fusion uses a default completion message. |
+| `githubCommentTemplate` | `string` | `undefined` | Optional issue comment template used by `githubCommentOnDone`. Supports `{taskId}` and `{taskTitle}` placeholders. If unset, Fusion uses a default completion message. When the linked source issue's repository is the Fusion self-repo (`runfusion/fusion`, case-insensitive), Fusion appends a `Current version: v<current>` line and a `Target release: v<nextMinor>` line (next-minor bump, patch reset to 0, e.g. `0.55.0` → `0.56.0`), resolved via the published `@runfusion/fusion` CLI package version. If that version is unresolved/unparseable, the base comment is posted with no version lines. Comments on every other repository are byte-for-byte unchanged. |
 | `githubCloseSourceIssueOnDone` | `boolean` | `false` | When enabled, source-imported GitHub issues are automatically closed with `state_reason: completed` when the Fusion task moves to `done`. A startup reconciliation sweep also closes missed open source issues on boot. |
 | `githubTrackingEnabledByDefault` | `boolean` | `false` | Project-level default for enabling issue tracking on ordinary new tasks. When this is false, the Quick Entry GitHub toggle is disabled until tracking is enabled in Settings. Imported GitHub issues still follow this default unless `githubLinkImportedIssuesToTracking` is enabled. |
 | `githubLinkImportedIssuesToTracking` | `boolean` | `false` | Project-scoped, import-only option. When enabled, GitHub issue imports from the dashboard, CLI, and extension tools persist `githubTracking: { enabled: true }` so Fusion adopts the imported source issue as the tracking issue without turning tracking on for ordinary new tasks. Duplicate/skipped imports do not create tasks or tracking metadata. |
diff --git a/packages/dashboard/src/__tests__/github-issue-comment.test.ts b/packages/dashboard/src/__tests__/github-issue-comment.test.ts
index 8c3793e78a..061d849541 100644
--- a/packages/dashboard/src/__tests__/github-issue-comment.test.ts
+++ b/packages/dashboard/src/__tests__/github-issue-comment.test.ts
@@ -1,7 +1,12 @@
 import { EventEmitter } from "node:events";
-import { beforeEach, describe, expect, it, vi, type Mock } from "vitest";
+import { afterEach, beforeEach, describe, expect, it, vi, type Mock } from "vitest";
 import type { TaskStore } from "@fusion/core";
-import { DEFAULT_COMMENT_TEMPLATE, GitHubIssueCommentService } from "../github-issue-comment.js";
+import {
+  computeNextMinorVersion,
+  DEFAULT_COMMENT_TEMPLATE,
+  GitHubIssueCommentService,
+  isFusionSelfRepo,
+} from "../github-issue-comment.js";
 
 const { mockCommentOnIssue } = vi.hoisted(() => ({
   mockCommentOnIssue: vi.fn(),
@@ -30,6 +35,10 @@ class MockStore extends EventEmitter {
   setSettings(settings: Record<string, unknown>): void {
     this.settings = settings;
   }
+
+  getRootDir(): string {
+    return "/tmp/github-issue-comment-test";
+  }
 }
 
 function createTask(overrides: Record<string, unknown> = {}): Record<string, unknown> {
@@ -49,17 +58,67 @@ async function flushAsync(): Promise<void> {
   await new Promise((resolve) => setTimeout(resolve, 0));
 }
 
+describe("isFusionSelfRepo", () => {
+  it("matches the canonical slug", () => {
+    expect(isFusionSelfRepo("runfusion/fusion")).toBe(true);
+  });
+
+  it("matches case-insensitively and trims whitespace", () => {
+    expect(isFusionSelfRepo("Runfusion/Fusion")).toBe(true);
+    expect(isFusionSelfRepo("  runfusion/fusion  ")).toBe(true);
+    expect(isFusionSelfRepo("RUNFUSION/FUSION")).toBe(true);
+  });
+
+  it("does not match other repos", () => {
+    expect(isFusionSelfRepo("owner/repo")).toBe(false);
+    expect(isFusionSelfRepo("runfusion/other")).toBe(false);
+    expect(isFusionSelfRepo("other/fusion")).toBe(false);
+  });
+});
+
+describe("computeNextMinorVersion", () => {
+  it("bumps the minor version and resets patch to 0", () => {
+    expect(computeNextMinorVersion("0.55.0")).toBe("0.56.0");
+  });
+
+  it("resets patch to 0 for a non-zero patch", () => {
+    expect(computeNextMinorVersion("1.2.9")).toBe("1.3.0");
+  });
+
+  it("tolerates a leading v prefix", () => {
+    expect(computeNextMinorVersion("v0.55.0")).toBe("0.56.0");
+  });
+
+  it("ignores pre-release/build suffixes", () => {
+    expect(computeNextMinorVersion("0.55.0-beta.1")).toBe("0.56.0");
+  });
+
+  it("returns null for the unresolved 0.0.0 sentinel", () => {
+    expect(computeNextMinorVersion("0.0.0")).toBeNull();
+  });
+
+  it("returns null for unparseable input", () => {
+    expect(computeNextMinorVersion("not-a-version")).toBeNull();
+    expect(computeNextMinorVersion("")).toBeNull();
+  });
+});
+
 describe("GitHubIssueCommentService", () => {
   let store: MockStore;
   let service: GitHubIssueCommentService;
 
   beforeEach(() => {
     vi.clearAllMocks();
+    mockCommentOnIssue.mockResolvedValue(undefined);
     store = new MockStore({ githubCommentOnDone: true });
-    service = new GitHubIssueCommentService(store as unknown as TaskStore, () => "ghp_test");
+    service = new GitHubIssueCommentService(store as unknown as TaskStore, () => "ghp_test", () => "0.55.0");
     service.start();
   });
 
+  afterEach(() => {
+    service.stop();
+  });
+
   it("does nothing when setting is disabled", async () => {
     store.setSettings({ githubCommentOnDone: false });
 
@@ -105,7 +164,7 @@ describe("GitHubIssueCommentService", () => {
     expect(mockCommentOnIssue).not.toHaveBeenCalled();
   });
 
-  it("posts comment when setting enabled and task moved to done", async () => {
+  it("posts comment when setting enabled and task moved to done (non-self-repo, byte-for-byte unchanged)", async () => {
     mockCommentOnIssue.mockResolvedValue(undefined);
 
     store.emit("task:moved", { task: createTask(), from: "in-progress", to: "done" });
@@ -119,7 +178,7 @@ describe("GitHubIssueCommentService", () => {
     );
   });
 
-  it("uses custom template with placeholder substitution", async () => {
+  it("uses custom template with placeholder substitution for non-self-repo", async () => {
     store.setSettings({
       githubCommentOnDone: true,
       githubCommentTemplate: "Task {taskId}: {taskTitle} complete",
@@ -177,6 +236,79 @@ describe("GitHubIssueCommentService", () => {
     );
   });
 
+  it("appends current + target release version lines for the Fusion self-repo", async () => {
+    store.emit("task:moved", {
+      task: createTask({
+        sourceIssue: { provider: "github", repository: "runfusion/fusion", issueNumber: 42 },
+      }),
+      from: "in-progress",
+      to: "done",
+    });
+    await flushAsync();
+
+    expect(mockCommentOnIssue).toHaveBeenCalledWith(
+      "runfusion",
+      "fusion",
+      42,
+      "✅ Task FN-2623 (Imported task) has been completed and resolved.\n\nCurrent version: v0.55.0\nTarget release: v0.56.0",
+    );
+    expect(store.logEntry).toHaveBeenCalledWith(
+      "FN-2623",
+      "Posted GitHub issue completion comment",
+      "runfusion/fusion#42",
+    );
+  });
+
+  it("appends release version lines for a case-insensitive self-repo match", async () => {
+    store.emit("task:moved", {
+      task: createTask({
+        sourceIssue: { provider: "github", repository: "Runfusion/Fusion", issueNumber: 42 },
+      }),
+      from: "in-progress",
+      to: "done",
+    });
+    await flushAsync();
+
+    expect(mockCommentOnIssue).toHaveBeenCalledWith(
+      "Runfusion",
+      "Fusion",
+      42,
+      "✅ Task FN-2623 (Imported task) has been completed and resolved.\n\nCurrent version: v0.55.0\nTarget release: v0.56.0",
+    );
+  });
+
+  it("falls back to the base comment with no version lines when the version is unresolved (0.0.0 sentinel)", async () => {
+    const unresolvedService = new GitHubIssueCommentService(
+      store as unknown as TaskStore,
+      () => "ghp_test",
+      () => "0.0.0",
+    );
+    unresolvedService.start();
+
+    store.emit("task:moved", {
+      task: createTask({
+        sourceIssue: { provider: "github", repository: "runfusion/fusion", issueNumber: 42 },
+      }),
+      from: "in-progress",
+      to: "done",
+    });
+    await flushAsync();
+
+    expect(mockCommentOnIssue).toHaveBeenCalledWith(
+      "runfusion",
+      "fusion",
+      42,
+      "✅ Task FN-2623 (Imported task) has been completed and resolved.",
+    );
+    expect(store.logEntry).toHaveBeenCalledWith(
+      "FN-2623",
+      "Posted GitHub issue completion comment",
+      "runfusion/fusion#42",
+    );
+
+    unresolvedService.stop();
+  });
+
   it("stop unregisters listener", async () => {
     service.stop();
 
diff --git a/packages/dashboard/src/github-issue-comment.ts b/packages/dashboard/src/github-issue-comment.ts
index cce053d675..a3ec321b56 100644
--- a/packages/dashboard/src/github-issue-comment.ts
+++ b/packages/dashboard/src/github-issue-comment.ts
@@ -1,5 +1,6 @@
 import type { TaskStore } from "@fusion/core";
 import { GitHubClient } from "./github.js";
+import { getCliPackageVersion, isUnresolvedCliPackageVersion } from "./cli-package-version.js";
 
 interface TaskMovedEvent {
   task: {
@@ -16,17 +17,70 @@ interface TaskMovedEvent {
 
 const DEFAULT_COMMENT_TEMPLATE = "✅ Task {taskId} ({taskTitle}) has been completed and resolved.";
 
+/*
+ * FNXC:GitHubIssueComment 2026-07-05-01:30:
+ * Requirement: when a Fusion task's linked source GitHub issue lives in the
+ * Fusion self-repo (`runfusion/fusion`, case-insensitive), the completion
+ * comment posted on `done` must ALSO include both a "Current version:" line
+ * and a "Target release:" line (the next-minor bump of the currently
+ * published `@runfusion/fusion` version), so readers know which Fusion
+ * release ships the fix. Every other linked repository's completion comment
+ * must remain byte-for-byte identical to the pre-FN-7575 template output.
+ * If the resolved version is unparseable/unresolved (the `0.0.0` sentinel),
+ * fall back silently to the base comment with no version lines — never throw.
+ */
+const FUSION_SELF_REPO = "runfusion/fusion";
+
+/** Case-insensitive, trimmed `owner/repo` slug comparison against the Fusion self-repo. */
+function isFusionSelfRepo(repository: string): boolean {
+  return repository.trim().toLowerCase() === FUSION_SELF_REPO;
+}
+
+/** `major.minor.patch` leading numeric semver shape; ignores any trailing prerelease/build metadata. */
+const SEMVER_PREFIX_PATTERN = /^v?(\d+)\.(\d+)\.(\d+)/;
+
+/**
+ * Compute the next-minor release version (patch reset to 0) from a semver string,
+ * e.g. `"0.55.0"` -> `"0.56.0"`, `"1.2.9"` -> `"1.3.0"`, `"v0.55.0"` -> `"0.56.0"`.
+ * Returns `null` for the unresolved `"0.0.0"` sentinel or any unparseable input so
+ * callers can skip appending version lines rather than emit garbage.
+ */
+function computeNextMinorVersion(current: string): string | null {
+  if (isUnresolvedCliPackageVersion(current)) {
+    return null;
+  }
+
+  const match = SEMVER_PREFIX_PATTERN.exec(current.trim());
+  if (!match) {
+    return null;
+  }
+
+  const major = Number.parseInt(match[1] ?? "", 10);
+  const minor = Number.parseInt(match[2] ?? "", 10);
+  if (!Number.isFinite(major) || !Number.isFinite(minor)) {
+    return null;
+  }
+
+  return `${major}.${minor + 1}.0`;
+}
+
 export class GitHubIssueCommentService {
   private readonly store: TaskStore;
   private readonly getGitHubToken: () => string | undefined;
+  private readonly getCurrentVersion: () => string;
   private readonly onTaskMoved = (event: TaskMovedEvent): void => {
     void this.handleTaskMoved(event);
   };
   private started = false;
 
-  constructor(store: TaskStore, getGitHubToken?: () => string | undefined) {
+  constructor(
+    store: TaskStore,
+    getGitHubToken?: () => string | undefined,
+    getCurrentVersion?: () => string,
+  ) {
     this.store = store;
     this.getGitHubToken = getGitHubToken ?? (() => process.env.GITHUB_TOKEN);
+    this.getCurrentVersion = getCurrentVersion ?? (() => getCliPackageVersion(import.meta.url));
   }
 
   start(): void {
@@ -68,10 +122,19 @@ export class GitHubIssueCommentService {
     }
 
     const template = settings.githubCommentTemplate || DEFAULT_COMMENT_TEMPLATE;
-    const commentBody = template
+    let commentBody = template
       .replaceAll("{taskId}", task.id)
       .replaceAll("{taskTitle}", task.title ?? "");
 
+    if (isFusionSelfRepo(sourceIssue.repository)) {
+      const currentVersion = this.getCurrentVersion();
+      const nextMinorVersion = computeNextMinorVersion(currentVersion);
+      if (nextMinorVersion) {
+        const currentLine = currentVersion.startsWith("v") ? currentVersion : `v${currentVersion}`;
+        commentBody += `\n\nCurrent version: ${currentLine}\nTarget release: v${nextMinorVersion}`;
+      }
+    }
+
     try {
       const client = new GitHubClient(this.getGitHubToken());
       await client.commentOnIssue(owner, repo, sourceIssue.issueNumber, commentBody);
@@ -91,4 +154,4 @@ export class GitHubIssueCommentService {
   }
 }
 
-export { DEFAULT_COMMENT_TEMPLATE };
+export { DEFAULT_COMMENT_TEMPLATE, FUSION_SELF_REPO, isFusionSelfRepo, computeNextMinorVersion };

From b173f76adbd5317329310ce045aaadfe0c5c30d1 Mon Sep 17 00:00:00 2001
From: gsxdsm <gsxdsm@users.noreply.github.com>
Date: Sun, 5 Jul 2026 10:57:58 -0700
Subject: [PATCH 32/65] fix(FN-7577): stop planner overseer from "recovering"
 healthy in-progress tasks
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

decidePlannerRecovery fell through to inject_guidance for any non-failed
executor/workflow-gate signal, including the healthy `progressing` signal.
Under autonomous oversight this dispatched steering into the live agent of
every healthy task — flipping the card badge to "recovering", burning a
bounded-attempt slot, and consuming AI usage for no reason.

- Only problem signals (`stuck`/`blocked`, plus the existing `failed` path)
  now trigger autonomous steering; healthy (`progressing`/`complete`) and
  human-wait (`awaiting-human`) signals return `none`.
- PlannerRecoveryController.tick clears stale attempt/last-action records for
  a (taskId, stage) once its signal is healthy, so a recovered task drops
  from "recovering" back to "watching" and a later problem gets a fresh budget.
- PlannerOverseerMonitor dedupes the activity-feed heartbeat: an unchanged
  (stage, signal, reason) observation logs once per change, not every tick.

Invariant tests added across all signals for both fall-through stages.

Fusion-Task-Id: FN-7577

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 ...anner-overseer-no-recover-healthy-tasks.md |  7 ++++
 .../src/__tests__/planner-recovery.test.ts    | 25 ++++++++++++++
 packages/core/src/planner-recovery.ts         | 33 +++++++++++++++++--
 .../src/__tests__/planner-overseer.test.ts    | 26 +++++++++++++++
 .../planner-recovery-controller.test.ts       | 29 ++++++++++++++++
 packages/engine/src/planner-overseer.ts       | 31 +++++++++++++++--
 .../engine/src/planner-recovery-controller.ts | 15 +++++++++
 7 files changed, 160 insertions(+), 6 deletions(-)
 create mode 100644 .changeset/planner-overseer-no-recover-healthy-tasks.md

diff --git a/.changeset/planner-overseer-no-recover-healthy-tasks.md b/.changeset/planner-overseer-no-recover-healthy-tasks.md
new file mode 100644
index 0000000000..9c96edc1ed
--- /dev/null
+++ b/.changeset/planner-overseer-no-recover-healthy-tasks.md
@@ -0,0 +1,7 @@
+---
+"@runfusion/fusion": patch
+---
+
+summary: Planner overseer no longer marks healthy in-progress tasks as "recovering" or steers them.
+category: fix
+dev: `decidePlannerRecovery` now returns `none` for healthy (`progressing`/`complete`) and `awaiting-human` executor/workflow-gate signals instead of falling through to `inject_guidance`; only `stuck`/`blocked`/`failed` trigger autonomous steering. Also dedupes the `PlannerOverseerMonitor` activity-feed heartbeat so an unchanged `(stage, signal, reason)` observation is logged once per change, not every poll tick. Fixes the "overseer recovering" badge appearing on every autonomous card and the needless AI-consuming guidance injections (FN-7577).
diff --git a/packages/core/src/__tests__/planner-recovery.test.ts b/packages/core/src/__tests__/planner-recovery.test.ts
index 0fcf3d2151..a635a588b0 100644
--- a/packages/core/src/__tests__/planner-recovery.test.ts
+++ b/packages/core/src/__tests__/planner-recovery.test.ts
@@ -68,6 +68,31 @@ describe("decidePlannerRecovery", () => {
     expect(decision.action).toBe("inject_guidance");
   });
 
+  // FN-7577: a healthy or human-wait signal must NOT trigger autonomous
+  // steering on the executor/workflow-gate fall-through — steering a task that
+  // reports it is progressing flipped every card's badge to "recovering" and
+  // burned AI usage via a needless inject_guidance dispatch. Invariant across
+  // both fall-through stages and both problem/healthy signal classes.
+  it("returns none for healthy/human-wait signals on executor and workflow-gate stages", () => {
+    for (const stage of ["executor", "workflow-gate"] as const) {
+      for (const signal of ["progressing", "complete", "awaiting-human"] as const) {
+        const decision = decidePlannerRecovery({ snapshot: observation({ stage, signal }) });
+        expect(decision.action, `stage=${stage} signal=${signal}`).toBe("none");
+        expect(decision.exhausted, `stage=${stage} signal=${signal}`).toBe(false);
+        expect(decision.requiresConfirmation, `stage=${stage} signal=${signal}`).toBe(false);
+      }
+    }
+  });
+
+  it("still steers on problem signals (stuck/blocked) for executor and workflow-gate stages", () => {
+    for (const stage of ["executor", "workflow-gate"] as const) {
+      for (const signal of ["stuck", "blocked"] as const) {
+        const decision = decidePlannerRecovery({ snapshot: observation({ stage, signal }) });
+        expect(decision.action, `stage=${stage} signal=${signal}`).toBe("inject_guidance");
+      }
+    }
+  });
+
   it("gates merger and pull-request stages behind confirmation (FN-7513) instead of none", () => {
     for (const stage of ["merger", "pull-request"] as const) {
       const decision = decidePlannerRecovery({ snapshot: observation({ stage, signal: "failed" }) });
diff --git a/packages/core/src/planner-recovery.ts b/packages/core/src/planner-recovery.ts
index 8c0717e16b..426c2b4904 100644
--- a/packages/core/src/planner-recovery.ts
+++ b/packages/core/src/planner-recovery.ts
@@ -140,8 +140,19 @@ export interface DecidePlannerRecoveryInput {
  *  5. `executor` / `workflow-gate` stage with `signal === "failed"` →
  *     `"request_targeted_fix"` when a source link carries a specific
  *     fixable error (`failed-check` / `merge-error`), else `"retry_step"`.
- *  6. Any other `executor` / `workflow-gate` signal (stuck/blocked/
- *     progressing/awaiting-human) → `"inject_guidance"`.
+ *  6. `executor` / `workflow-gate` stage with a PROBLEM signal
+ *     (`stuck` / `blocked`) → `"inject_guidance"`.
+ *
+ * FNXC:PlannerOversight 2026-07-05-11:00:
+ * A HEALTHY signal (`progressing` / `complete`) or a human-wait signal
+ * (`awaiting-human`) yields `"none"` — steering a task that reports it is
+ * actively progressing is a misfire: it flips the card's overseer badge to
+ * "recovering", burns a bounded-attempt slot, and (because `inject_guidance`
+ * feeds the LIVE agent) consumes AI usage for no reason. Only a signal that
+ * actually indicates trouble may trigger autonomous steering (user report
+ * FN-7577: "recovering" badge on every healthy in-progress card). Previously
+ * this branch injected guidance on ANY non-`failed` signal, including
+ * `progressing`.
  */
 export function decidePlannerRecovery(input: DecidePlannerRecoveryInput): PlannerRecoveryDecision {
   const attemptCount = input?.attemptState?.attemptCount ?? 0;
@@ -252,7 +263,11 @@ export function decidePlannerRecovery(input: DecidePlannerRecoveryInput): Planne
       };
     }
 
-    {
+    // FNXC:PlannerOversight 2026-07-05-11:00: only PROBLEM signals warrant
+    // autonomous steering. Healthy (`progressing`/`complete`) and human-wait
+    // (`awaiting-human`) signals are a no-op so a fine, actively-progressing
+    // task is never "recovered" (FN-7577).
+    if (snapshot.signal === "stuck" || snapshot.signal === "blocked") {
       const proposedAction = "inject_guidance";
       const sideEffectClass = classifyPlannerActionSideEffect({ watchedStage: snapshot.stage, proposedAction });
       return {
@@ -267,6 +282,18 @@ export function decidePlannerRecovery(input: DecidePlannerRecoveryInput): Planne
         sideEffectClass,
       };
     }
+
+    return {
+      action: "none",
+      reason: `Stage "${snapshot.stage}" signal "${snapshot.signal}" is healthy or awaiting a human — no autonomous steering`,
+      attemptCount,
+      attemptLimit,
+      exhausted: false,
+      watchedStage,
+      sourceLinks,
+      requiresConfirmation: false,
+      sideEffectClass: "bounded_recovery",
+    };
   } catch {
     return {
       action: "none",
diff --git a/packages/engine/src/__tests__/planner-overseer.test.ts b/packages/engine/src/__tests__/planner-overseer.test.ts
index 4855077af0..af4a8ffe54 100644
--- a/packages/engine/src/__tests__/planner-overseer.test.ts
+++ b/packages/engine/src/__tests__/planner-overseer.test.ts
@@ -251,6 +251,32 @@ describe("PlannerOverseerMonitor.observeTask", () => {
     expect(store.logEntry).toHaveBeenCalledTimes(1);
   });
 
+  // FN-7577: an unchanged heartbeat (same stage/signal/reason) must not re-write
+  // the activity feed on every poll tick — only a CHANGE re-logs; clear() resets
+  // the dedup so a re-run re-logs its first observation.
+  it("dedupes consecutive identical feed entries, re-logs on signal change, resets on clear", async () => {
+    const store = { logEntry: vi.fn().mockResolvedValue(undefined) };
+    const monitor = new PlannerOverseerMonitor({ store });
+    const task = taskFixture({ column: "in-progress" });
+
+    // Three identical healthy ticks → a single feed entry.
+    await monitor.observeTask(task, "observe");
+    await monitor.observeTask(task, "observe");
+    await monitor.observeTask(task, "observe");
+    expect(store.logEntry).toHaveBeenCalledTimes(1);
+
+    // Signal flips (executor paused → "blocked") → re-logs once.
+    const paused = { ...task, paused: true, pausedReason: "gate" };
+    await monitor.observeTask(paused, "observe");
+    await monitor.observeTask(paused, "observe");
+    expect(store.logEntry).toHaveBeenCalledTimes(2);
+
+    // clear() drops the dedup key so the next identical observation re-logs.
+    monitor.clear(task.id);
+    await monitor.observeTask(paused, "observe");
+    expect(store.logEntry).toHaveBeenCalledTimes(3);
+  });
+
   it("bounds the per-task ring buffer to the configured cap, keeping the most recent N", async () => {
     const monitor = new PlannerOverseerMonitor({ maxObservationsPerTask: 3 });
     const task = taskFixture({ column: "in-progress" });
diff --git a/packages/engine/src/__tests__/planner-recovery-controller.test.ts b/packages/engine/src/__tests__/planner-recovery-controller.test.ts
index b1ce0ea415..e336c9998d 100644
--- a/packages/engine/src/__tests__/planner-recovery-controller.test.ts
+++ b/packages/engine/src/__tests__/planner-recovery-controller.test.ts
@@ -84,6 +84,35 @@ describe("PlannerRecoveryController.tick", () => {
     expect(retryStep).toHaveBeenCalledTimes(PLANNER_RECOVERY_MAX_ATTEMPTS);
   });
 
+  // FN-7577: a stale recovery attempt must not keep a recovered task badged
+  // "recovering" — a healthy/human-wait signal on the next tick clears the
+  // per-(taskId, stage) attempt + last-action records, restoring a fresh budget.
+  it("clears stale attempt records once the stage reports a healthy signal", async () => {
+    const retryStep = vi.fn().mockResolvedValue(undefined);
+    let current: OverseerStageObservation = observation({ signal: "failed" });
+    const controller = new PlannerRecoveryController({
+      snapshotProvider: { getSnapshot: () => current },
+      handlers: { retryStep },
+    });
+
+    await controller.tick(task());
+    expect(controller.getAttemptCount("FN-1", "executor")).toBe(1);
+    expect(controller.getLastAction("FN-1", "executor")).toBe("retry_step");
+
+    // Task recovers → healthy signal on the next tick clears the registry.
+    current = observation({ signal: "progressing" });
+    const healthy = await controller.tick(task());
+    expect(healthy?.action).toBe("none");
+    expect(controller.getAttemptCount("FN-1", "executor")).toBe(0);
+    expect(controller.getLastAction("FN-1", "executor")).toBeUndefined();
+
+    // A later genuine failure starts from a fresh budget and dispatches again.
+    current = observation({ signal: "failed" });
+    await controller.tick(task());
+    expect(retryStep).toHaveBeenCalledTimes(2);
+    expect(controller.getAttemptCount("FN-1", "executor")).toBe(1);
+  });
+
   it("is inert when effectiveLevel/oversightLevel is off/observe/steer", async () => {
     for (const level of ["off", "observe", "steer"] as const) {
       const retryStep = vi.fn().mockResolvedValue(undefined);
diff --git a/packages/engine/src/planner-overseer.ts b/packages/engine/src/planner-overseer.ts
index 6c1a688f0e..7f8ebf3128 100644
--- a/packages/engine/src/planner-overseer.ts
+++ b/packages/engine/src/planner-overseer.ts
@@ -255,6 +255,21 @@ export class PlannerOverseerMonitor {
   private readonly maxObservationsPerTask: number;
   private readonly observations = new Map<string, OverseerStageObservation[]>();
 
+  /*
+  FNXC:PlannerOversight 2026-07-05-11:00:
+  The overseer logs one activity-feed entry per poll tick. On the healthy path an
+  executor task re-emits the identical `signal=progressing` heartbeat every tick,
+  which spammed the task feed (user report FN-7577) with no new information and no
+  lifecycle change. Dedup the feed write on the composite `stage|signal|reason`
+  key so a log entry is only written when the observed situation CHANGES — mirrors
+  the FN-7514 withheld-oversight dedup ("not re-emitted every poll while the reason
+  is unchanged"). The in-memory ring buffer and `onObservation` callback are left
+  intact (they are cheap / drive downstream emission façades); only the noisy feed
+  logEntry is gated. Cleared alongside the ring buffer in `clear()` so a re-run of
+  the same task re-logs its first observation.
+  */
+  private readonly lastLoggedKey = new Map<string, string>();
+
   constructor(options: PlannerOverseerMonitorOptions = {}) {
     this.store = options.store;
     this.onObservation = options.onObservation;
@@ -299,9 +314,16 @@ export class PlannerOverseerMonitor {
       }
 
       if (this.store?.logEntry) {
-        await this.store
-          .logEntry(task.id, `[planner-overseer] stage=${stage} signal=${signal}: ${reason}`)
-          .catch(() => undefined);
+        // FNXC:PlannerOversight 2026-07-05-11:00 — only write the feed entry when
+        // the observed (stage, signal, reason) differs from the last one logged
+        // for this task, so an unchanged heartbeat does not re-spam the feed.
+        const loggedKey = `${stage}|${signal}|${reason}`;
+        if (this.lastLoggedKey.get(task.id) !== loggedKey) {
+          this.lastLoggedKey.set(task.id, loggedKey);
+          await this.store
+            .logEntry(task.id, `[planner-overseer] stage=${stage} signal=${signal}: ${reason}`)
+            .catch(() => undefined);
+        }
       }
 
       return observation;
@@ -327,6 +349,9 @@ export class PlannerOverseerMonitor {
   /** Clear recorded observations for a task (e.g. on task completion). */
   clear(taskId: string): void {
     this.observations.delete(taskId);
+    // FNXC:PlannerOversight 2026-07-05-11:00 — drop the feed-dedup key too so a
+    // re-run of the same task re-logs its first observation.
+    this.lastLoggedKey.delete(taskId);
   }
 
   /** Task IDs that currently retain at least one recorded observation. Used
diff --git a/packages/engine/src/planner-recovery-controller.ts b/packages/engine/src/planner-recovery-controller.ts
index ee4c2e1aaf..ccf820c354 100644
--- a/packages/engine/src/planner-recovery-controller.ts
+++ b/packages/engine/src/planner-recovery-controller.ts
@@ -265,6 +265,21 @@ export class PlannerRecoveryController {
       }
 
       const key = this.attemptKey(task.id, snapshot.stage);
+
+      // FNXC:PlannerOversight 2026-07-05-11:00:
+      // FN-7577: once a task's watched stage reports a HEALTHY (`progressing`/
+      // `complete`) or human-wait (`awaiting-human`) signal, it is no longer
+      // being recovered — drop any stale attempt / last-action records for the
+      // (taskId, stage) so the card badge falls back from "recovering" to
+      // "watching" on the next `GET /api/tasks` serialization, and a later
+      // genuine problem starts from a fresh bounded budget. A still-problematic
+      // signal (`stuck`/`blocked`/`failed`) keeps its attempts so the bound holds.
+      const signal = snapshot.signal;
+      if (signal === "progressing" || signal === "complete" || signal === "awaiting-human") {
+        this.attempts.delete(key);
+        this.lastActions.delete(key);
+      }
+
       const attemptCount = this.attempts.get(key) ?? 0;
 
       const decision = decidePlannerRecovery({

From 74358494a7a8c0127c87056f41974882adf07757 Mon Sep 17 00:00:00 2001
From: gsxdsm <gsxdsm@users.noreply.github.com>
Date: Sun, 5 Jul 2026 11:03:45 -0700
Subject: [PATCH 33/65] FN-7577: extend PR-based revert to workspace tasks
 under autoMerge:false

Extends FN-7554's single-repo PR revert path to workspace (multi-repo) tasks: when autoMerge is disabled, the revert route now opens one dedicated fusion/revert-<id> PR per sub-repo instead of refusing workspace tasks outright.

- Add prepareWorkspaceRevertPrBranches (packages/engine/src/task-revert.ts): classifies every sub-repo first and only prepares a per-sub-repo fusion/revert-<id> branch when all sub-repos are clean/already-reverted (all-or-nothing at branch-prep phase); never force-writes any sub-repo integration branch.
- Export the new helper from packages/engine/src/index.ts.
- Extend POST /api/tasks/:id/revert (register-task-workflow-routes.ts) to resolve owner/repo and check the GitHub rate limiter for every sub-repo before pushing/creating any PR, opening one PR per sub-repo and returning an additive { mode: "pr", clean: true, workspace: { repos: [...] } } result; degrades the whole task to needsHuman if GitHub is unconfigured or any sub-repo is rate-limited, rather than opening a partial subset of PRs.
- Leave existing { mode: "git" | "ai" | "pr" } shapes, the autoMerge:true workspace path, and FN-7554's single-repo PR path unchanged.
- Add engine real-git coverage (task-revert-workspace-pr.real-git.test.ts) and extend dashboard route tests (task-revert-route.test.ts) for the new workspace PR path.
- Add changeset (.changeset/fn-7577-workspace-pr-revert.md, minor) and update docs/task-management.md.

Files changed:
 .changeset/fn-7577-workspace-pr-revert.md          |   7 +
 docs/task-management.md                            |   3 +-
 .../src/__tests__/task-revert-route.test.ts        | 313 ++++++++++++++++-
 .../src/routes/register-task-workflow-routes.ts    | 181 +++++++++-
 .../task-revert-workspace-pr.real-git.test.ts      | 371 +++++++++++++++++++++
 packages/engine/src/index.ts                       |   4 +
 packages/engine/src/task-revert.ts                 | 295 ++++++++++++++++
 7 files changed, 1166 insertions(+), 8 deletions(-)

Fusion-Task-Id: FN-7577

Fusion-Task-Lineage: bedbfab7-5804-485f-9b40-64531edfc64a

Co-authored-by: Fusion (runfusion.ai) <noreply@runfusion.ai>
---
 .changeset/fn-7577-workspace-pr-revert.md     |   7 +
 docs/task-management.md                       |   3 +-
 .../src/__tests__/task-revert-route.test.ts   | 313 ++++++++++++++-
 .../routes/register-task-workflow-routes.ts   | 181 ++++++++-
 .../task-revert-workspace-pr.real-git.test.ts | 371 ++++++++++++++++++
 packages/engine/src/index.ts                  |   4 +
 packages/engine/src/task-revert.ts            | 295 ++++++++++++++
 7 files changed, 1166 insertions(+), 8 deletions(-)
 create mode 100644 .changeset/fn-7577-workspace-pr-revert.md
 create mode 100644 packages/engine/src/__tests__/task-revert-workspace-pr.real-git.test.ts

diff --git a/.changeset/fn-7577-workspace-pr-revert.md b/.changeset/fn-7577-workspace-pr-revert.md
new file mode 100644
index 0000000000..a231551ed5
--- /dev/null
+++ b/.changeset/fn-7577-workspace-pr-revert.md
@@ -0,0 +1,7 @@
+---
+"@runfusion/fusion": minor
+---
+
+summary: Open one revert PR per sub-repo for workspace tasks when autoMerge is disabled.
+category: feature
+dev: `POST /api/tasks/:id/revert` gains an additive workspace `{ mode: "pr", clean: true, workspace: { repos: [{ repo, revertBranch, prUrl, prNumber, existingPr? }] } }` result for clean multi-repo reverts under `autoMerge:false`, extending FN-7554's single-repo `mode:"pr"` path. New engine export `prepareWorkspaceRevertPrBranches` (packages/engine/src/task-revert.ts) classifies every sub-repo first and only prepares a dedicated `fusion/revert-<id>` branch per sub-repo when all are clean/already-reverted (all-or-nothing at the branch-prep phase), never force-writing any sub-repo integration branch. The route resolves owner/repo and checks the rate limiter for every sub-repo before pushing/creating any PR, so GitHub-unconfigured/rate-limited cases degrade the whole task to `needsHuman` rather than opening a partial subset of PRs. Existing `{ mode: "git" | "ai" | "pr", ... }` shapes, the `autoMerge:true` workspace path, and FN-7554's single-repo path are unchanged.
diff --git a/docs/task-management.md b/docs/task-management.md
index b4f3bc8f47..f592e41fe2 100644
--- a/docs/task-management.md
+++ b/docs/task-management.md
@@ -695,7 +695,8 @@ Recovery/backfill guidance:
 - Git-path response contract (additive only): `{ mode: "git", clean, revertCommitSha?, revertCommitShas?, conflicts?, alreadyReverted?, unsupported?, needsHuman?, reason? }`. A clean revert lands a `revert(FN-xxxx): ...` commit carrying a `Fusion-Task-Id` trailer on the resolved base branch; `revertCommitShas` reports every commit created (all of them for `per-sha`, the single one for `squash`) alongside the existing `revertCommitSha`.
 - AI-undo response contract: `{ mode: "ai", createdTaskId: "FN-YYYY", alreadyOpen?: true }`. The created task is an ordinary `triage`-column board task (via the normal `store.createTask` path) that references the source task's id, mission, and landed files, and instructs undoing the source task's behavior while preserving unrelated later changes to the same files, using a `revert(FN-xxxx): ...` commit convention. It carries NO dependency on the (already done/archived) source task. A `sourceMetadata.revertOf` marker makes repeated fallback calls idempotent — while an AI-undo task for that source is still open, a further call returns the same `createdTaskId` with `alreadyOpen: true` instead of creating a duplicate; a prior undo task that itself reached `done`/`archived` does not suppress a fresh one.
 - **Workspace (multi-repo) tasks (FN-7547):** tasks with `workspaceWorktrees` populated (`isWorkspaceTask`) are revertable too — the route dispatches to a dedicated workspace path that reasons about every sub-repo's integration branch as ONE all-or-nothing unit. It resolves each sub-repo's attributable commit(s), dry-run classifies every sub-repo first, and only commits a `revert(FN-xxxx): ...` commit on EACH sub-repo when every sub-repo classifies clean/already-reverted; if any sub-repo conflicts, no sub-repo is committed and every touched sub-repo worktree is rolled back to its pre-call state. Response contract for workspace tasks: `{ mode: "git", clean, workspace: { repos: [{ repo, classification, revertCommitSha?, conflicts?, alreadyReverted? }] }, conflicts?: {repo, file, ...}[] }`. A conflicting workspace result still falls back to the AI-undo task under `"auto"` mode, same as a single-repo conflicting result.
-- **`autoMerge:false` PR-based revert (FN-7554):** for a single-repo task whose git revert classifies **clean**, `autoMerge:false` no longer dead-ends at `needsHuman`. The route prepares a dedicated `fusion/revert-<id>` branch off the resolved base branch (via the engine's `prepareRevertPrBranch`, which NEVER writes to the base branch itself), pushes it, and opens a GitHub PR through the same owner/repo resolution, `githubRateLimiter` gate, `findPrForBranch` idempotency, and `manual: true` handoff as `POST /tasks/:id/pr/create`. Response: `{ mode: "pr", clean: true, prUrl, prNumber, revertBranch, existingPr? }` — a second call while the PR is still open links the existing PR (`existingPr: true`) instead of re-pushing. GitHub unconfigured or rate-limited still degrades gracefully to `{ mode: "git", needsHuman: true, reason }`, and a conflicting/unsupported/already-reverted classification is unaffected (no PR is opened; `"auto"` mode still falls back to the AI-undo task on conflict/unsupported). Workspace (multi-repo) tasks are not yet covered by this PR path — they keep the existing `needsHuman` result under `autoMerge:false`.
+- **`autoMerge:false` PR-based revert (FN-7554):** for a single-repo task whose git revert classifies **clean**, `autoMerge:false` no longer dead-ends at `needsHuman`. The route prepares a dedicated `fusion/revert-<id>` branch off the resolved base branch (via the engine's `prepareRevertPrBranch`, which NEVER writes to the base branch itself), pushes it, and opens a GitHub PR through the same owner/repo resolution, `githubRateLimiter` gate, `findPrForBranch` idempotency, and `manual: true` handoff as `POST /tasks/:id/pr/create`. Response: `{ mode: "pr", clean: true, prUrl, prNumber, revertBranch, existingPr? }` — a second call while the PR is still open links the existing PR (`existingPr: true`) instead of re-pushing. GitHub unconfigured or rate-limited still degrades gracefully to `{ mode: "git", needsHuman: true, reason }`, and a conflicting/unsupported/already-reverted classification is unaffected (no PR is opened; `"auto"` mode still falls back to the AI-undo task on conflict/unsupported).
+- **`autoMerge:false` PR-based revert extended to workspace tasks (FN-7577):** a workspace task whose git revert classifies **clean across every sub-repo** also opens PRs instead of dead-ending at `needsHuman` under `autoMerge:false`. The engine's `prepareWorkspaceRevertPrBranches` mirrors the workspace all-or-nothing classify-all contract: it dry-run classifies EVERY sub-repo first, and only prepares one `fusion/revert-<id>` branch per sub-repo (never writing any sub-repo's integration branch) when every sub-repo classifies clean/already-reverted — a single conflicting sub-repo aborts the WHOLE preparation with no branch created anywhere. The route then resolves owner/repo and checks the rate limiter for EVERY sub-repo before pushing/creating any PR (so a GitHub-unconfigured or rate-limited sub-repo degrades the whole task to `needsHuman` rather than opening a partial subset), then opens one PR per sub-repo reusing FN-7554's per-sub-repo `findPrForBranch` idempotency and `manual: true` handoff. Response: `{ mode: "pr", clean: true, workspace: { repos: [{ repo, revertBranch, prUrl, prNumber, existingPr? }] } }`. Existing `{ mode: "git" | "ai" | "pr" }` shapes, the `autoMerge:true` workspace path, and FN-7554's single-repo path are unchanged.
 - **Dashboard auto-linking (FN-7555):** the AI-undo task's card shows an "Undo of FN-xxxx" chip and its detail view shows a clickable "Created to undo FN-xxxx" link back to the source task. The source task's detail view shows an "Undo task: FN-YYYY" link whenever an OPEN undo task referencing it exists in the loaded tasks (matching `TaskStore.findOpenRevertTaskForSource`'s open-only semantics — a `done`/`archived`/soft-deleted undo task is never surfaced as active). Both directions are derived client-side from `sourceMetadata.revertOf`; no new API. A dedicated Done/Archived card revert-trigger action is still a separate follow-up (see FN-7525).
 - **Configurable AI-undo workflow default (FN-7556, UI: FN-7578):** the project setting `aiUndoTaskWorkflowId` (default `builtin:review-heavy`) selects the workflow applied to every AI-undo task created above (`mode:"ai"` and the `auto`/workspace conflict fallbacks all share one creation seam, so all three inherit this default) — a stricter review posture is warranted because these tasks reverse already-shipped code. A blank/unset value means the created task inherits the project default workflow (pre-FN-7556 behavior); the route falls back to inherit (with a logged warning) if the configured id is blank or does not resolve to a real workflow, so a misconfigured id never breaks AI-undo task creation. Editable from **Settings → General → AI-undo task workflow** (choose "Inherit project default workflow" to store the blank/inherit sentinel). See [Settings Reference → Project Settings](./settings-reference.md#project-settings).
 
diff --git a/packages/dashboard/src/__tests__/task-revert-route.test.ts b/packages/dashboard/src/__tests__/task-revert-route.test.ts
index 2566b1210d..6d7c38390b 100644
--- a/packages/dashboard/src/__tests__/task-revert-route.test.ts
+++ b/packages/dashboard/src/__tests__/task-revert-route.test.ts
@@ -11,7 +11,7 @@ this suite stubs `performTaskRevert` at the route boundary and asserts:
 */
 import { afterEach, describe, expect, it, vi } from "vitest";
 import express from "express";
-import { mkdtempSync } from "node:fs";
+import { mkdirSync, mkdtempSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { execFileSync } from "node:child_process";
@@ -20,6 +20,25 @@ import { createApiRoutes } from "../routes.js";
 import { request as performRequest } from "../test-request.js";
 import { githubRateLimiter } from "../github-poll.js";
 
+// FN-7577: `getCurrentRepo` is mocked at the `@fusion/core` boundary (partial
+// mock, everything else passes through to the real module) so workspace
+// mode:"pr" tests can resolve distinct owner/repo per sub-repo without a real
+// GitHub remote. The returned wrapper defers reading `getCurrentRepoMock` (and
+// falls back to the REAL `getCurrentRepo`) until CALL time — never inside the
+// synchronous factory body — so existing single-repo FN-7554 tests (which
+// rely on real local-remote resolution / the `GITHUB_REPOSITORY` env
+// override) are unaffected; workspace tests below override via
+// `mockImplementation`.
+const getCurrentRepoMock = vi.fn();
+vi.mock("@fusion/core", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("@fusion/core")>();
+  return {
+    ...actual,
+    getCurrentRepo: (...args: [string?]) =>
+      getCurrentRepoMock.getMockImplementation() ? getCurrentRepoMock(...args) : actual.getCurrentRepo(...args),
+  };
+});
+
 // FNXC:TaskRevert 2026-07-04-00:00: the route now guards against `rootDir`
 // (the shared user checkout) sitting on a branch other than the resolved
 // base branch (see the branch-mismatch check in register-task-workflow-routes.ts).
@@ -44,6 +63,7 @@ function makeGitRepoOnMain(): string {
 const performTaskRevertMock = vi.fn();
 const revertWorkspaceTaskMock = vi.fn();
 const prepareRevertPrBranchMock = vi.fn();
+const prepareWorkspaceRevertPrBranchesMock = vi.fn();
 
 vi.mock("@fusion/engine", async (importOriginal) => {
   const actual = await importOriginal<typeof import("@fusion/engine")>();
@@ -52,6 +72,7 @@ vi.mock("@fusion/engine", async (importOriginal) => {
     performTaskRevert: (...args: unknown[]) => performTaskRevertMock(...args),
     revertWorkspaceTask: (...args: unknown[]) => revertWorkspaceTaskMock(...args),
     prepareRevertPrBranch: (...args: unknown[]) => prepareRevertPrBranchMock(...args),
+    prepareWorkspaceRevertPrBranches: (...args: unknown[]) => prepareWorkspaceRevertPrBranchesMock(...args),
   };
 });
 
@@ -106,6 +127,29 @@ function makeWorkspaceTask(overrides: Partial<Task>): Task {
   });
 }
 
+// FN-7577: real multi-sub-repo git fixture for workspace mode:"pr" tests —
+// each sub-repo is its own real git repo with a real bare "origin" remote, so
+// the route's REAL `git push -u origin <revertBranch>` has something to push
+// (mirrors `makeGitRepoOnMain`'s single-repo pattern, once per sub-repo).
+function makeWorkspaceGitRoot(repoRels: string[]): { rootDir: string; repoDirs: Record<string, string> } {
+  const rootDir = mkdtempSync(join(tmpdir(), "kb-task-revert-ws-route-"));
+  const repoDirs: Record<string, string> = {};
+  for (const rel of repoRels) {
+    const dir = join(rootDir, rel);
+    mkdirSync(dir, { recursive: true });
+    execFileSync("git", ["init", "-b", "main"], { cwd: dir });
+    execFileSync("git", ["config", "user.email", "test@example.com"], { cwd: dir });
+    execFileSync("git", ["config", "user.name", "Test"], { cwd: dir });
+    execFileSync("git", ["commit", "--allow-empty", "-m", "init"], { cwd: dir });
+    const originDir = mkdtempSync(join(tmpdir(), "kb-task-revert-ws-route-origin-"));
+    execFileSync("git", ["init", "--bare", "-b", "main"], { cwd: originDir });
+    execFileSync("git", ["remote", "add", "origin", originDir], { cwd: dir });
+    execFileSync("git", ["push", "-u", "origin", "main"], { cwd: dir });
+    repoDirs[rel] = dir;
+  }
+  return { rootDir, repoDirs };
+}
+
 function createMockStore(
   task: Task,
   opts?: {
@@ -114,6 +158,7 @@ function createMockStore(
     autoMerge?: boolean;
     aiUndoTaskWorkflowId?: string;
     knownWorkflowIds?: string[];
+    rootDir?: string;
   },
 ): TaskStore {
   let nextId = 800;
@@ -145,7 +190,7 @@ function createMockStore(
       aiUndoTaskWorkflowId: opts?.aiUndoTaskWorkflowId,
     }),
     getWorkflowDefinition,
-    getRootDir: vi.fn().mockReturnValue(makeGitRepoOnMain()),
+    getRootDir: vi.fn().mockReturnValue(opts?.rootDir ?? makeGitRepoOnMain()),
     getTask: vi.fn().mockResolvedValue(task),
     getTaskCommitAssociationsByLineageId: vi.fn().mockResolvedValue([]),
     createTask,
@@ -699,3 +744,267 @@ describe("POST /tasks/:id/revert — FN-7554 mode:'pr' (autoMerge:false)", () =>
     expect(createPrMock).not.toHaveBeenCalled();
   });
 });
+
+// FN-7577: mode:"pr" — PR-based revert extended to WORKSPACE (multi-repo)
+// tasks under autoMerge:false. Real per-sub-repo branch-prep behavior is
+// proven by packages/engine/src/__tests__/task-revert-workspace-pr.real-git.test.ts;
+// this suite stubs `prepareWorkspaceRevertPrBranches` at the engine boundary
+// and `getCurrentRepo` at the core boundary, and asserts the route's
+// per-sub-repo PR orchestration, atomic pre-check degrade ordering, and
+// idempotency.
+describe("POST /tasks/:id/revert — FN-7577 workspace mode:'pr' (autoMerge:false)", () => {
+  const originalGithubRepository = process.env.GITHUB_REPOSITORY;
+
+  afterEach(() => {
+    vi.clearAllMocks();
+    vi.restoreAllMocks();
+    if (originalGithubRepository === undefined) {
+      delete process.env.GITHUB_REPOSITORY;
+    } else {
+      process.env.GITHUB_REPOSITORY = originalGithubRepository;
+    }
+  });
+
+  function mockRepoResolution(resolvable: Record<string, { owner: string; repo: string } | null>): void {
+    getCurrentRepoMock.mockImplementation((cwd?: string) => {
+      for (const [rel, value] of Object.entries(resolvable)) {
+        if (typeof cwd === "string" && cwd.endsWith(rel)) return value;
+      }
+      return null;
+    });
+  }
+
+  it("all clean + autoMerge:false → mode:'pr' (multi-PR), one PR per sub-repo, manual:true persistence", async () => {
+    delete process.env.GITHUB_REPOSITORY;
+    const task = makeWorkspaceTask({ id: "FN-100", column: "done" });
+    const { rootDir, repoDirs } = makeWorkspaceGitRoot(["repo-a", "repo-b"]);
+    const store = createMockStore(task, { autoMerge: false, rootDir });
+    // `prepareWorkspaceRevertPrBranches` is mocked (real branch-prep behavior is
+    // proven by the engine real-git suite) — create the branches it would have
+    // created locally, so the route's REAL `git push -u origin <branch>` per
+    // sub-repo has something to push.
+    execFileSync("git", ["branch", "fusion/revert-fn-100"], { cwd: repoDirs["repo-a"] });
+    execFileSync("git", ["branch", "fusion/revert-fn-100"], { cwd: repoDirs["repo-b"] });
+    mockRepoResolution({ "repo-a": { owner: "o", repo: "repo-a" }, "repo-b": { owner: "o", repo: "repo-b" } });
+    vi.spyOn(githubRateLimiter, "canMakeRequest").mockReturnValue(true);
+    findPrForBranchMock.mockResolvedValue(null);
+    prepareWorkspaceRevertPrBranchesMock.mockResolvedValue({
+      eligible: true,
+      repos: [
+        { repo: "repo-a", revertBranch: "fusion/revert-fn-100", integrationBranch: "main", revertCommitShas: ["a"] },
+        { repo: "repo-b", revertBranch: "fusion/revert-fn-100", integrationBranch: "main", revertCommitShas: ["b"] },
+      ],
+    });
+    let callCount = 0;
+    createPrMock.mockImplementation(async () => {
+      callCount += 1;
+      return { number: 100 + callCount, url: `https://github.com/o/repo/pull/${100 + callCount}` };
+    });
+
+    const res = await REQUEST(createApp(store), "POST", `/api/tasks/${task.id}/revert`);
+    expect(res.status).toBe(200);
+    expect(res.body).toMatchObject({
+      mode: "pr",
+      clean: true,
+      workspace: {
+        repos: [
+          { repo: "repo-a", revertBranch: "fusion/revert-fn-100" },
+          { repo: "repo-b", revertBranch: "fusion/revert-fn-100" },
+        ],
+      },
+    });
+    expect(createPrMock).toHaveBeenCalledTimes(2);
+    expect(createPrMock.mock.calls[0]?.[0]).toMatchObject({ owner: "o", repo: "repo-a", head: "fusion/revert-fn-100", base: "main" });
+    expect(createPrMock.mock.calls[1]?.[0]).toMatchObject({ owner: "o", repo: "repo-b", head: "fusion/revert-fn-100", base: "main" });
+    for (const call of createPrMock.mock.calls) {
+      expect(typeof call[0]?.body).toBe("string");
+      expect((call[0]?.body as string).length).toBeGreaterThan(0);
+    }
+    expect(store.updatePrInfo as ReturnType<typeof vi.fn>).toHaveBeenCalledWith(task.id, expect.objectContaining({ manual: true }));
+    expect(revertWorkspaceTaskMock).not.toHaveBeenCalled();
+    expect(performTaskRevertMock).not.toHaveBeenCalled();
+  });
+
+  it("existing PR idempotency: links repo-a's existing PR and only creates a PR for repo-b", async () => {
+    delete process.env.GITHUB_REPOSITORY;
+    const task = makeWorkspaceTask({ id: "FN-101", column: "done" });
+    const { rootDir, repoDirs } = makeWorkspaceGitRoot(["repo-a", "repo-b"]);
+    const store = createMockStore(task, { autoMerge: false, rootDir });
+    execFileSync("git", ["branch", "fusion/revert-fn-101"], { cwd: repoDirs["repo-b"] });
+    mockRepoResolution({ "repo-a": { owner: "o", repo: "repo-a" }, "repo-b": { owner: "o", repo: "repo-b" } });
+    vi.spyOn(githubRateLimiter, "canMakeRequest").mockReturnValue(true);
+    findPrForBranchMock.mockImplementation(async ({ repo }: { repo: string }) =>
+      repo === "repo-a" ? { number: 55, url: "https://github.com/o/repo-a/pull/55" } : null,
+    );
+    prepareWorkspaceRevertPrBranchesMock.mockResolvedValue({
+      eligible: true,
+      repos: [
+        { repo: "repo-a", revertBranch: "fusion/revert-fn-101", integrationBranch: "main", revertCommitShas: ["a"] },
+        { repo: "repo-b", revertBranch: "fusion/revert-fn-101", integrationBranch: "main", revertCommitShas: ["b"] },
+      ],
+    });
+    createPrMock.mockResolvedValue({ number: 56, url: "https://github.com/o/repo-b/pull/56" });
+
+    const res = await REQUEST(createApp(store), "POST", `/api/tasks/${task.id}/revert`);
+    expect(res.status).toBe(200);
+    expect(res.body).toMatchObject({
+      mode: "pr",
+      clean: true,
+      workspace: {
+        repos: [
+          { repo: "repo-a", prNumber: 55, existingPr: true },
+          { repo: "repo-b", prNumber: 56 },
+        ],
+      },
+    });
+    expect(createPrMock).toHaveBeenCalledTimes(1);
+    expect(createPrMock.mock.calls[0]?.[0]).toMatchObject({ repo: "repo-b" });
+  });
+
+  it("GitHub unconfigured degrade (whole-task): needsHuman, no createPr for ANY sub-repo", async () => {
+    delete process.env.GITHUB_REPOSITORY;
+    const task = makeWorkspaceTask({ id: "FN-102", column: "done" });
+    const { rootDir, repoDirs } = makeWorkspaceGitRoot(["repo-a", "repo-b"]);
+    const store = createMockStore(task, { autoMerge: false, rootDir });
+    execFileSync("git", ["branch", "fusion/revert-fn-102"], { cwd: repoDirs["repo-a"] });
+    execFileSync("git", ["branch", "fusion/revert-fn-102"], { cwd: repoDirs["repo-b"] });
+    // repo-b has NO configured GitHub repository.
+    mockRepoResolution({ "repo-a": { owner: "o", repo: "repo-a" }, "repo-b": null });
+    prepareWorkspaceRevertPrBranchesMock.mockResolvedValue({
+      eligible: true,
+      repos: [
+        { repo: "repo-a", revertBranch: "fusion/revert-fn-102", integrationBranch: "main", revertCommitShas: ["a"] },
+        { repo: "repo-b", revertBranch: "fusion/revert-fn-102", integrationBranch: "main", revertCommitShas: ["b"] },
+      ],
+    });
+
+    const res = await REQUEST(createApp(store), "POST", `/api/tasks/${task.id}/revert`);
+    expect(res.status).toBe(200);
+    expect(res.body).toMatchObject({ mode: "git", needsHuman: true });
+    expect(String((res.body as { reason?: string }).reason ?? "")).toMatch(/no GitHub repository/i);
+    expect(createPrMock).not.toHaveBeenCalled();
+    expect(findPrForBranchMock).not.toHaveBeenCalled();
+  });
+
+  it("rate-limited degrade (whole-task): needsHuman without touching createPr for any sub-repo", async () => {
+    delete process.env.GITHUB_REPOSITORY;
+    const task = makeWorkspaceTask({ id: "FN-103", column: "done" });
+    const { rootDir, repoDirs } = makeWorkspaceGitRoot(["repo-a", "repo-b"]);
+    const store = createMockStore(task, { autoMerge: false, rootDir });
+    execFileSync("git", ["branch", "fusion/revert-fn-103"], { cwd: repoDirs["repo-a"] });
+    execFileSync("git", ["branch", "fusion/revert-fn-103"], { cwd: repoDirs["repo-b"] });
+    mockRepoResolution({ "repo-a": { owner: "o", repo: "repo-a" }, "repo-b": { owner: "o", repo: "repo-b" } });
+    vi.spyOn(githubRateLimiter, "canMakeRequest").mockImplementation((repoKey: string) => repoKey !== "o/repo-b");
+    prepareWorkspaceRevertPrBranchesMock.mockResolvedValue({
+      eligible: true,
+      repos: [
+        { repo: "repo-a", revertBranch: "fusion/revert-fn-103", integrationBranch: "main", revertCommitShas: ["a"] },
+        { repo: "repo-b", revertBranch: "fusion/revert-fn-103", integrationBranch: "main", revertCommitShas: ["b"] },
+      ],
+    });
+
+    const res = await REQUEST(createApp(store), "POST", `/api/tasks/${task.id}/revert`);
+    expect(res.status).toBe(200);
+    expect(res.body).toMatchObject({ mode: "git", needsHuman: true });
+    expect(String((res.body as { reason?: string }).reason ?? "")).toMatch(/rate limit/i);
+    expect(createPrMock).not.toHaveBeenCalled();
+    expect(findPrForBranchMock).not.toHaveBeenCalled();
+  });
+
+  it("conflicting under autoMerge:false, mode:'git' → { mode: 'git', clean: false, workspace, conflicts }, no PR", async () => {
+    delete process.env.GITHUB_REPOSITORY;
+    const task = makeWorkspaceTask({ id: "FN-104", column: "done" });
+    const { rootDir } = makeWorkspaceGitRoot(["repo-a", "repo-b"]);
+    const store = createMockStore(task, { autoMerge: false, rootDir });
+    prepareWorkspaceRevertPrBranchesMock.mockResolvedValue({
+      eligible: false,
+      classification: "conflicting",
+      conflicts: [{ repo: "repo-b", file: "b.ts", status: "UU" }],
+      repos: [
+        { repo: "repo-a", classification: "clean" },
+        { repo: "repo-b", classification: "conflicting", conflicts: [{ file: "b.ts", status: "UU" }] },
+      ],
+    });
+
+    const res = await POST_JSON(createApp(store), `/api/tasks/${task.id}/revert`, { mode: "git" });
+    expect(res.status).toBe(200);
+    expect(res.body).toMatchObject({
+      mode: "git",
+      clean: false,
+      conflicts: [{ repo: "repo-b", file: "b.ts" }],
+    });
+    expect(createPrMock).not.toHaveBeenCalled();
+  });
+
+  it("conflicting under autoMerge:false, mode:'auto' → falls back to the AI-undo task", async () => {
+    delete process.env.GITHUB_REPOSITORY;
+    const task = makeWorkspaceTask({ id: "FN-105", column: "done" });
+    const { rootDir } = makeWorkspaceGitRoot(["repo-a", "repo-b"]);
+    const store = createMockStore(task, { autoMerge: false, rootDir });
+    prepareWorkspaceRevertPrBranchesMock.mockResolvedValue({
+      eligible: false,
+      classification: "conflicting",
+      conflicts: [{ repo: "repo-b", file: "b.ts", status: "UU" }],
+      repos: [
+        { repo: "repo-a", classification: "clean" },
+        { repo: "repo-b", classification: "conflicting", conflicts: [{ file: "b.ts", status: "UU" }] },
+      ],
+    });
+
+    const res = await POST_JSON(createApp(store), `/api/tasks/${task.id}/revert`, { mode: "auto" });
+    expect(res.status).toBe(200);
+    expect(res.body).toMatchObject({ mode: "ai" });
+    expect((res.body as { createdTaskId?: string }).createdTaskId).toBeTruthy();
+    expect(createPrMock).not.toHaveBeenCalled();
+  });
+
+  it("empty prep (all already-reverted) → { mode: 'git', clean: true, workspace: { repos: [] } }, no createPr", async () => {
+    delete process.env.GITHUB_REPOSITORY;
+    const task = makeWorkspaceTask({ id: "FN-106", column: "done" });
+    const { rootDir } = makeWorkspaceGitRoot(["repo-a", "repo-b"]);
+    const store = createMockStore(task, { autoMerge: false, rootDir });
+    prepareWorkspaceRevertPrBranchesMock.mockResolvedValue({ eligible: true, repos: [] });
+
+    const res = await REQUEST(createApp(store), "POST", `/api/tasks/${task.id}/revert`);
+    expect(res.status).toBe(200);
+    expect(res.body).toMatchObject({ mode: "git", clean: true, workspace: { repos: [] } });
+    expect(createPrMock).not.toHaveBeenCalled();
+    expect(findPrForBranchMock).not.toHaveBeenCalled();
+  });
+
+  it("regression — workspace autoMerge:true unchanged: still calls revertWorkspaceTask, prepareWorkspaceRevertPrBranches/createPr not called", async () => {
+    const task = makeWorkspaceTask({ id: "FN-107", column: "done" });
+    const { rootDir } = makeWorkspaceGitRoot(["repo-a", "repo-b"]);
+    const store = createMockStore(task, { autoMerge: true, rootDir });
+    revertWorkspaceTaskMock.mockResolvedValue({
+      mode: "git",
+      clean: true,
+      workspace: {
+        repos: [
+          { repo: "repo-a", classification: "clean", revertCommitSha: "rev-a" },
+          { repo: "repo-b", classification: "clean", revertCommitSha: "rev-b" },
+        ],
+      },
+    });
+
+    const res = await REQUEST(createApp(store), "POST", `/api/tasks/${task.id}/revert`);
+    expect(res.status).toBe(200);
+    expect(res.body).toMatchObject({ mode: "git", clean: true });
+    expect(revertWorkspaceTaskMock).toHaveBeenCalledTimes(1);
+    expect(prepareWorkspaceRevertPrBranchesMock).not.toHaveBeenCalled();
+    expect(createPrMock).not.toHaveBeenCalled();
+  });
+
+  it("regression — single-repo autoMerge:false unchanged: still takes prepareRevertPrBranch, prepareWorkspaceRevertPrBranches not called", async () => {
+    process.env.GITHUB_REPOSITORY = "o/r";
+    const task = makeTask({ id: "FN-108", column: "done" });
+    const store = createMockStore(task, { autoMerge: false });
+    vi.spyOn(githubRateLimiter, "canMakeRequest").mockReturnValue(true);
+    findPrForBranchMock.mockResolvedValue({ number: 21, url: "https://github.com/o/r/pull/21" });
+
+    const res = await REQUEST(createApp(store), "POST", `/api/tasks/${task.id}/revert`);
+    expect(res.status).toBe(200);
+    expect(res.body).toMatchObject({ mode: "pr", clean: true, prNumber: 21, existingPr: true });
+    expect(prepareWorkspaceRevertPrBranchesMock).not.toHaveBeenCalled();
+  });
+});
diff --git a/packages/dashboard/src/routes/register-task-workflow-routes.ts b/packages/dashboard/src/routes/register-task-workflow-routes.ts
index 5fe91460c9..6884cd5130 100644
--- a/packages/dashboard/src/routes/register-task-workflow-routes.ts
+++ b/packages/dashboard/src/routes/register-task-workflow-routes.ts
@@ -1,5 +1,5 @@
 import { createReadStream } from "node:fs";
-import { resolve, sep } from "node:path";
+import { join, resolve, sep } from "node:path";
 import type {
   TaskStore,
   Task,
@@ -60,8 +60,11 @@ import {
   TaskRevertError,
   createAiUndoTask,
   prepareRevertPrBranch,
+  prepareWorkspaceRevertPrBranches,
   type AiUndoTaskResult,
   type PrepareRevertPrBranchResult,
+  type PrepareWorkspaceRevertPrBranchesResult,
+  type WorkspaceRepoRevertPrBranch,
 } from "@fusion/engine";
 import { buildBoardWorkflowsPayload } from "./board-workflows.js";
 import { isBackwardMoveBlockedByOpenPr, PR_OPEN_BLOCKS_MOVE_BACK_MESSAGE } from "./register-pull-requests-routes.js";
@@ -1704,10 +1707,15 @@ export function registerTaskWorkflowRoutes(ctx: ApiRoutesContext, deps: TaskWork
   conflicts?, alreadyReverted?, unsupported?, needsHuman?, reason? }` OR, for workspace tasks (FN-7547),
   `{ mode: "git", clean, workspace: { repos: [{ repo, classification, revertCommitSha?, conflicts?,
   alreadyReverted? }] }, conflicts?: {repo, file, ...}[] }` OR
-  `{ mode: "ai", createdTaskId: "FN-YYYY", alreadyOpen?: true }`. The AI-undo task is created via
-  `createAiUndoTask` (engine) + `TaskStore.findOpenRevertTaskForSource` (core) for the idempotency
-  guard — a second call while an undo task is still open returns the SAME `createdTaskId` with
-  `alreadyOpen: true` rather than creating a duplicate.
+  `{ mode: "ai", createdTaskId: "FN-YYYY", alreadyOpen?: true }` OR, for a single-repo task under
+  `autoMerge:false` (FN-7554), `{ mode: "pr", clean: true, prUrl, prNumber, revertBranch, existingPr? }`
+  OR, for a WORKSPACE task under `autoMerge:false` (FN-7577 — additive over FN-7554/FN-7547),
+  `{ mode: "pr", clean: true, workspace: { repos: [{ repo, revertBranch, prUrl, prNumber, existingPr? }] } }`
+  — one revert PR opened per sub-repo, all-or-nothing at the branch-prep phase
+  (`prepareWorkspaceRevertPrBranches`), never force-writing any sub-repo integration branch. The
+  AI-undo task is created via `createAiUndoTask` (engine) + `TaskStore.findOpenRevertTaskForSource`
+  (core) for the idempotency guard — a second call while an undo task is still open returns the
+  SAME `createdTaskId` with `alreadyOpen: true` rather than creating a duplicate.
   */
   router.post("/tasks/:id/revert", async (req, res) => {
     try {
@@ -1800,6 +1808,169 @@ export function registerTaskWorkflowRoutes(ctx: ApiRoutesContext, deps: TaskWork
       UNCHANGED. `granularity` does not apply to the workspace path.
       */
       if (isWorkspaceTask(task)) {
+        /*
+        FNXC:TaskRevert 2026-07-05-00:00 (FN-7577 — workspace mode:"pr" dispatch,
+        additive over FN-7554/FN-7547): `revertWorkspaceTask` refuses
+        (`needsHuman`) whenever autoMerge is effectively off, the same dead end
+        `performTaskRevert` hits for single-repo tasks. Instead of stopping
+        there, take the multi-PR path: `prepareWorkspaceRevertPrBranches`
+        classifies EVERY sub-repo first and only prepares one dedicated
+        `fusion/revert-<id>` branch per sub-repo (never writing any sub-repo
+        integration branch) when every sub-repo is clean/already-reverted; this
+        route then opens ONE revert PR per prepared sub-repo branch, reusing
+        FN-7554's per-repo owner/repo resolution, rate-limiter gate,
+        `findPrForBranch` idempotency, and `manual:true` handoff. The
+        `autoMerge:true` workspace path below (the existing `revertWorkspaceTask`
+        call) is UNCHANGED.
+        */
+        const effectiveAutoMerge = task.autoMerge ?? settings.autoMerge ?? true;
+
+        if (effectiveAutoMerge === false) {
+          const revertBranch = `fusion/revert-${task.id.toLowerCase()}`;
+
+          const prepared: PrepareWorkspaceRevertPrBranchesResult = await prepareWorkspaceRevertPrBranches({
+            task,
+            workspaceRootDir: rootDir,
+            settings,
+            revertBranch,
+            commitAssociationSource: {
+              getTaskCommitAssociationsByLineageId: (lineageId: string) =>
+                scopedStore.getTaskCommitAssociationsByLineageId(lineageId),
+            },
+          });
+
+          if (!prepared.eligible) {
+            if ("classification" in prepared && prepared.classification === "conflicting") {
+              if (mode === "auto") {
+                res.json(await createAiUndoResult());
+                return;
+              }
+              res.json({ mode: "git", clean: false, workspace: { repos: prepared.repos }, conflicts: prepared.conflicts });
+              return;
+            }
+            if ("unsupported" in prepared && prepared.unsupported) {
+              if (mode === "auto") {
+                res.json(await createAiUndoResult());
+                return;
+              }
+              res.json({ mode: "git", unsupported: true, reason: prepared.reason });
+              return;
+            }
+          }
+
+          if (prepared.eligible) {
+            // prepared.eligible === true
+            if (prepared.repos.length === 0) {
+              // Every sub-repo was already-reverted — nothing to PR.
+              res.json({ mode: "git", clean: true, workspace: { repos: [] } });
+              return;
+            }
+
+            /*
+            FNXC:TaskRevert 2026-07-05-00:00 (FN-7577 — atomic pre-check ordering):
+            Resolve owner/repo AND check the rate limiter for EVERY prepared
+            sub-repo BEFORE pushing/creating any PR, so the two common degrade
+            cases (GitHub unconfigured / rate-limited) never leave a partial
+            subset of PRs open across sub-repos. Nothing has been pushed to any
+            remote yet at this point, so degrading here only needs to delete the
+            purely-local prepared branches.
+            */
+            const cleanupPreparedBranches = async (): Promise<void> => {
+              for (const repoBranch of prepared.repos) {
+                const repoRootDir = join(rootDir, repoBranch.repo);
+                await runGitCommand(["checkout", repoBranch.integrationBranch], repoRootDir, 10_000).catch(() => undefined);
+                await runGitCommand(["branch", "-D", revertBranch], repoRootDir, 10_000).catch(() => undefined);
+              }
+            };
+
+            const targets: { repoBranch: WorkspaceRepoRevertPrBranch; owner: string; repo: string }[] = [];
+            for (const repoBranch of prepared.repos) {
+              const gitRepo = getCurrentRepo(join(rootDir, repoBranch.repo));
+              if (!gitRepo) {
+                await cleanupPreparedBranches();
+                res.json({
+                  mode: "git",
+                  needsHuman: true,
+                  reason: "autoMerge is disabled and one or more sub-repos have no GitHub repository configured; cannot open revert PRs",
+                });
+                return;
+              }
+              targets.push({ repoBranch, owner: gitRepo.owner, repo: gitRepo.repo });
+            }
+
+            for (const target of targets) {
+              const repoKey = `${target.owner}/${target.repo}`;
+              if (!githubRateLimiter.canMakeRequest(repoKey)) {
+                await cleanupPreparedBranches();
+                res.json({
+                  mode: "git",
+                  needsHuman: true,
+                  reason: "GitHub API rate limit exceeded; try again later",
+                });
+                return;
+              }
+            }
+
+            /*
+            FNXC:TaskRevert 2026-07-05-00:00 (FN-7577 — idempotent multi-PR
+            recovery contract): from this point on, a thrown error (network down,
+            push rejected, GitHub 5xx, etc.) is surfaced via the shared `catch`
+            below rather than a graceful needsHuman degrade, because an earlier
+            sub-repo in this loop may already have an open remote PR by the time a
+            later sub-repo fails — this route NEVER attempts to close/delete an
+            already-created remote PR. A re-run of this endpoint is safe:
+            `findPrForBranch` links any already-created sub-repo PR instead of
+            re-creating it, and `prepareWorkspaceRevertPrBranches`'s `checkout -B`
+            re-preps local branches for any sub-repo not yet pushed.
+            */
+            const resultRepos: { repo: string; revertBranch: string; prUrl: string; prNumber: number; existingPr?: boolean }[] = [];
+            const persistPrInfo = async (prInfo: PrInfo): Promise<void> => {
+              const existingPrs = task.prInfos ?? (task.prInfo ? [task.prInfo] : []);
+              if (existingPrs.length > 0) {
+                await scopedStore.addPrInfo(task.id, prInfo);
+              } else {
+                await scopedStore.updatePrInfo(task.id, prInfo);
+              }
+            };
+
+            for (const target of targets) {
+              const client = new GitHubClient();
+              const existingPr = await client.findPrForBranch({ head: revertBranch, state: "all", owner: target.owner, repo: target.repo });
+
+              if (existingPr) {
+                // Idempotency — never re-push/re-create when an open (or all-state)
+                // PR already exists for this sub-repo's branch, just link it.
+                const prInfo: PrInfo = { ...existingPr, manual: true };
+                await persistPrInfo(prInfo);
+                await scopedStore.logEntry(task.id, "Linked existing revert PR", `${target.repoBranch.repo}: PR #${prInfo.number}: ${prInfo.url}`);
+                resultRepos.push({ repo: target.repoBranch.repo, revertBranch, prUrl: prInfo.url, prNumber: prInfo.number, existingPr: true });
+                continue;
+              }
+
+              await runGitCommand(["push", "-u", "origin", revertBranch], join(rootDir, target.repoBranch.repo), 60_000);
+              const prTitle = `revert(${task.id}): undo landed work (${target.repoBranch.repo})`;
+              const prBody =
+                `This PR reverts the work landed by task ${task.id} in sub-repo \`${target.repoBranch.repo}\`.\n\n` +
+                `See \`GET /api/tasks/${task.id}/diff\` for the full landed diff being reverted.\n`;
+              const created = await client.createPr({
+                owner: target.owner,
+                repo: target.repo,
+                title: prTitle,
+                body: prBody,
+                head: revertBranch,
+                base: target.repoBranch.integrationBranch,
+              });
+              const prInfo: PrInfo = { ...created, manual: true };
+              await persistPrInfo(prInfo);
+              await scopedStore.logEntry(task.id, "Created revert PR", `${target.repoBranch.repo}: PR #${prInfo.number}: ${prInfo.url}`);
+              resultRepos.push({ repo: target.repoBranch.repo, revertBranch, prUrl: prInfo.url, prNumber: prInfo.number });
+            }
+
+            res.json({ mode: "pr", clean: true, workspace: { repos: resultRepos } });
+            return;
+          }
+        }
+
         const workspaceResult = await revertWorkspaceTask({
           task,
           workspaceRootDir: rootDir,
diff --git a/packages/engine/src/__tests__/task-revert-workspace-pr.real-git.test.ts b/packages/engine/src/__tests__/task-revert-workspace-pr.real-git.test.ts
new file mode 100644
index 0000000000..e2fb93571e
--- /dev/null
+++ b/packages/engine/src/__tests__/task-revert-workspace-pr.real-git.test.ts
@@ -0,0 +1,371 @@
+import { exec, execSync, spawnSync } from "node:child_process";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { promisify } from "node:util";
+import { afterEach, describe, expect, it } from "vitest";
+import { prepareWorkspaceRevertPrBranches } from "../task-revert.js";
+import type { Task } from "@fusion/core";
+
+const realExecAsync = promisify(exec);
+
+const hasGit = spawnSync("git", ["--version"], { stdio: "pipe" }).status === 0;
+const describeIfGit = hasGit ? describe : describe.skip;
+
+function git(repo: string, command: string): string {
+  return execSync(command, { cwd: repo, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+}
+
+function makeTask(overrides: Partial<Task>): Task {
+  return {
+    id: "FN-A",
+    lineageId: "FN-A",
+    description: "",
+    column: "done",
+    dependencies: [],
+    steps: [],
+    currentStep: 0,
+    ...overrides,
+  } as Task;
+}
+
+/*
+FNXC:TaskRevert 2026-07-05-00:00 (FN-7577):
+Real multi-sub-repo git fixture coverage for `prepareWorkspaceRevertPrBranches`
+— the Symptom Verification regression suite for the workspace `mode:"pr"`
+branch-prep primitive. Mirrors the two-sub-repo fixture pattern from
+`task-revert.workspace.real-git.test.ts` (FN-7547) combined with the
+single-repo branch-prep assertions from `task-revert-pr.real-git.test.ts`
+(FN-7554): clean → per-sub-repo `fusion/revert-<id>` branches with
+integration branches left byte-identical; one conflicting sub-repo aborts the
+WHOLE preparation with no branch created anywhere; already-reverted →
+eligible with empty repos; mixed clean/already-reverted → only the
+still-clean sub-repo gets a branch; non-workspace task → unsupported;
+idempotent local branch reset; dirty-tree/branch-mismatch refusal; and a
+late-conflict multi-branch cleanup.
+*/
+describeIfGit("prepareWorkspaceRevertPrBranches real-git scenarios", { timeout: 30_000 }, () => {
+  const dirs: string[] = [];
+  afterEach(() => {
+    for (const dir of dirs.splice(0)) rmSync(dir, { recursive: true, force: true });
+  });
+
+  function subRepoFixture(workspaceRoot: string, repoRel: string, initialFile: string, initialContent: string): string {
+    const repoRootDir = join(workspaceRoot, repoRel);
+    git(workspaceRoot, `mkdir -p ${repoRel}`);
+    git(repoRootDir, "git init -b main");
+    git(repoRootDir, 'git config user.email "test@example.com"');
+    git(repoRootDir, 'git config user.name "Test User"');
+    git(repoRootDir, "git config commit.gpgsign false");
+    writeFileSync(join(repoRootDir, initialFile), initialContent);
+    git(repoRootDir, `git add ${initialFile} && git commit -m 'init'`);
+    return repoRootDir;
+  }
+
+  function workspaceFixture() {
+    const workspaceRoot = mkdtempSync(join(tmpdir(), "kb-revert-ws-pr-"));
+    dirs.push(workspaceRoot);
+    const repoA = subRepoFixture(workspaceRoot, "repo-a", "a.ts", "line1\n");
+    const repoB = subRepoFixture(workspaceRoot, "repo-b", "b.ts", "line1\n");
+    return { workspaceRoot, repoA, repoB };
+  }
+
+  function landTaskCommit(repoRootDir: string, file: string, content: string, commitSubject: string): string {
+    writeFileSync(join(repoRootDir, file), content);
+    git(repoRootDir, `git commit -am ${JSON.stringify(commitSubject)}`);
+    return git(repoRootDir, "git rev-parse HEAD");
+  }
+
+  function makeWorkspaceTask(shaA: string, shaB: string, overrides: Partial<Task> = {}): Task {
+    return makeTask({
+      column: "done",
+      workspaceWorktrees: {
+        "repo-a": { worktreePath: "repo-a", branch: "fusion/FN-A", landedSha: shaA },
+        "repo-b": { worktreePath: "repo-b", branch: "fusion/FN-A", landedSha: shaB },
+      },
+      mergeDetails: { commitSha: shaA, workspaceLandedShas: { "repo-a": shaA, "repo-b": shaB } },
+      ...overrides,
+    });
+  }
+
+  it("all clean → eligible, per-sub-repo branches, integration branches unwritten", async () => {
+    const { workspaceRoot, repoA, repoB } = workspaceFixture();
+    const shaA = landTaskCommit(repoA, "a.ts", "line1\nfeature-a\n", "feat(FN-A): add feature in repo-a");
+    const shaB = landTaskCommit(repoB, "b.ts", "line1\nfeature-a\n", "feat(FN-A): add feature in repo-b");
+
+    const mainHeadBeforeA = git(repoA, "git rev-parse main");
+    const mainHeadBeforeB = git(repoB, "git rev-parse main");
+
+    const task = makeWorkspaceTask(shaA, shaB);
+    const result = await prepareWorkspaceRevertPrBranches({
+      task,
+      workspaceRootDir: workspaceRoot,
+      settings: {},
+      revertBranch: "fusion/revert-fn-a",
+    });
+
+    expect(result).toMatchObject({ eligible: true });
+    if (result.eligible) {
+      expect(result.repos).toHaveLength(2);
+      const byRepo = Object.fromEntries(result.repos.map((r) => [r.repo, r]));
+      expect(byRepo["repo-a"]).toMatchObject({ revertBranch: "fusion/revert-fn-a", integrationBranch: "main" });
+      expect(byRepo["repo-b"]).toMatchObject({ revertBranch: "fusion/revert-fn-a", integrationBranch: "main" });
+      expect(byRepo["repo-a"].revertCommitShas).toHaveLength(1);
+      expect(byRepo["repo-b"].revertCommitShas).toHaveLength(1);
+    }
+
+    for (const repoRootDir of [repoA, repoB]) {
+      const branchTipSubject = git(repoRootDir, "git log -1 --format=%s fusion/revert-fn-a");
+      expect(branchTipSubject).toMatch(/^revert\(FN-A\):/);
+      const branchTipBody = git(repoRootDir, "git log -1 --format=%B fusion/revert-fn-a");
+      expect(branchTipBody).toContain("Fusion-Task-Id: FN-A");
+      // checkout restored to main, clean.
+      expect(git(repoRootDir, "git rev-parse --abbrev-ref HEAD")).toBe("main");
+      expect(git(repoRootDir, "git status --porcelain")).toBe("");
+    }
+
+    // (b) each sub-repo's main HEAD is byte-identical to before — integration
+    // branch never written.
+    expect(git(repoA, "git rev-parse main")).toBe(mainHeadBeforeA);
+    expect(git(repoB, "git rev-parse main")).toBe(mainHeadBeforeB);
+    expect(git(repoA, "git show fusion/revert-fn-a:a.ts")).toBe("line1");
+    expect(git(repoB, "git show fusion/revert-fn-a:b.ts")).toBe("line1");
+  });
+
+  it("one sub-repo conflicting → whole-task aborted, NO branches anywhere (Symptom Verification)", async () => {
+    const { workspaceRoot, repoA, repoB } = workspaceFixture();
+    const shaA = landTaskCommit(repoA, "a.ts", "line1\nfeature-a\n", "feat(FN-A): add feature in repo-a");
+    const shaB = landTaskCommit(repoB, "b.ts", "line1\nfeature-a\n", "feat(FN-A): add feature in repo-b");
+
+    // Task B later modifies the exact same region touched by task A in repo-b only.
+    landTaskCommit(repoB, "b.ts", "line1\nfeature-a-modified-by-b\n", "feat(FN-B): modify same region in repo-b");
+
+    const mainHeadBeforeA = git(repoA, "git rev-parse main");
+    const mainHeadBeforeB = git(repoB, "git rev-parse main");
+
+    const task = makeWorkspaceTask(shaA, shaB);
+    const result = await prepareWorkspaceRevertPrBranches({
+      task,
+      workspaceRootDir: workspaceRoot,
+      settings: {},
+      revertBranch: "fusion/revert-fn-a",
+    });
+
+    expect(result).toMatchObject({ eligible: false, classification: "conflicting" });
+    if (!result.eligible && result.classification === "conflicting") {
+      expect(result.conflicts.some((c) => c.repo === "repo-b")).toBe(true);
+    }
+
+    for (const repoRootDir of [repoA, repoB]) {
+      expect(git(repoRootDir, "git branch --list fusion/revert-fn-a")).toBe("");
+    }
+    expect(git(repoA, "git rev-parse main")).toBe(mainHeadBeforeA);
+    expect(git(repoB, "git rev-parse main")).toBe(mainHeadBeforeB);
+    expect(git(repoA, "git rev-parse --abbrev-ref HEAD")).toBe("main");
+    expect(git(repoB, "git rev-parse --abbrev-ref HEAD")).toBe("main");
+  });
+
+  it("all already-reverted → eligible with empty repos, no branches, integration branches unchanged", async () => {
+    const { workspaceRoot, repoA, repoB } = workspaceFixture();
+    const shaA = landTaskCommit(repoA, "a.ts", "line1\nfeature-a\n", "feat(FN-A): add feature in repo-a");
+    const shaB = landTaskCommit(repoB, "b.ts", "line1\nfeature-a\n", "feat(FN-A): add feature in repo-b");
+
+    // Manually revert both sub-repos on main before calling the branch-prep primitive.
+    git(repoA, `git revert --no-edit ${shaA}`);
+    git(repoB, `git revert --no-edit ${shaB}`);
+    const mainHeadBeforeA = git(repoA, "git rev-parse main");
+    const mainHeadBeforeB = git(repoB, "git rev-parse main");
+
+    const task = makeWorkspaceTask(shaA, shaB);
+    const result = await prepareWorkspaceRevertPrBranches({
+      task,
+      workspaceRootDir: workspaceRoot,
+      settings: {},
+      revertBranch: "fusion/revert-fn-a",
+    });
+
+    expect(result).toMatchObject({ eligible: true, repos: [] });
+    for (const repoRootDir of [repoA, repoB]) {
+      expect(git(repoRootDir, "git branch --list fusion/revert-fn-a")).toBe("");
+    }
+    expect(git(repoA, "git rev-parse main")).toBe(mainHeadBeforeA);
+    expect(git(repoB, "git rev-parse main")).toBe(mainHeadBeforeB);
+  });
+
+  it("mixed clean + already-reverted → only the still-clean sub-repo gets a branch", async () => {
+    const { workspaceRoot, repoA, repoB } = workspaceFixture();
+    const shaA = landTaskCommit(repoA, "a.ts", "line1\nfeature-a\n", "feat(FN-A): add feature in repo-a");
+    const shaB = landTaskCommit(repoB, "b.ts", "line1\nfeature-a\n", "feat(FN-A): add feature in repo-b");
+
+    // Manually revert repo-b only.
+    git(repoB, `git revert --no-edit ${shaB}`);
+    const mainHeadBeforeA = git(repoA, "git rev-parse main");
+    const mainHeadBeforeB = git(repoB, "git rev-parse main");
+
+    const task = makeWorkspaceTask(shaA, shaB);
+    const result = await prepareWorkspaceRevertPrBranches({
+      task,
+      workspaceRootDir: workspaceRoot,
+      settings: {},
+      revertBranch: "fusion/revert-fn-a",
+    });
+
+    expect(result).toMatchObject({ eligible: true });
+    if (result.eligible) {
+      expect(result.repos).toHaveLength(1);
+      expect(result.repos[0].repo).toBe("repo-a");
+    }
+
+    const branchTipSubject = git(repoA, "git log -1 --format=%s fusion/revert-fn-a");
+    expect(branchTipSubject).toMatch(/^revert\(FN-A\):/);
+    expect(git(repoB, "git branch --list fusion/revert-fn-a")).toBe("");
+    expect(git(repoA, "git rev-parse main")).toBe(mainHeadBeforeA);
+    expect(git(repoB, "git rev-parse main")).toBe(mainHeadBeforeB);
+  });
+
+  it("non-workspace task → unsupported", async () => {
+    const { workspaceRoot } = workspaceFixture();
+    const task = makeTask({ column: "done" });
+
+    const result = await prepareWorkspaceRevertPrBranches({
+      task,
+      workspaceRootDir: workspaceRoot,
+      settings: {},
+      revertBranch: "fusion/revert-fn-a",
+    });
+
+    expect(result).toMatchObject({ eligible: false, unsupported: true, reason: "not-a-workspace-task" });
+  });
+
+  it("idempotent local branch reset: a stale local branch in one sub-repo is reset off integration with the fresh revert commit", async () => {
+    const { workspaceRoot, repoA, repoB } = workspaceFixture();
+    const shaA = landTaskCommit(repoA, "a.ts", "line1\nfeature-a\n", "feat(FN-A): add feature in repo-a");
+    const shaB = landTaskCommit(repoB, "b.ts", "line1\nfeature-a\n", "feat(FN-A): add feature in repo-b");
+
+    // Pre-create a stale local revert branch in repo-a pointing at an unrelated commit.
+    git(repoA, "git branch fusion/revert-fn-a main~1");
+    const staleTip = git(repoA, "git rev-parse fusion/revert-fn-a");
+    expect(staleTip).not.toBe(git(repoA, "git rev-parse main"));
+
+    const task = makeWorkspaceTask(shaA, shaB);
+    const result = await prepareWorkspaceRevertPrBranches({
+      task,
+      workspaceRootDir: workspaceRoot,
+      settings: {},
+      revertBranch: "fusion/revert-fn-a",
+    });
+
+    expect(result).toMatchObject({ eligible: true });
+    const branchTipSubject = git(repoA, "git log -1 --format=%s fusion/revert-fn-a");
+    expect(branchTipSubject).toMatch(/^revert\(FN-A\):/);
+    expect(git(repoA, "git rev-parse --abbrev-ref HEAD")).toBe("main");
+  });
+
+  it("dirty-tree refusal: refuses without mutating any sub-repo when one has a stray uncommitted change", async () => {
+    const { workspaceRoot, repoA, repoB } = workspaceFixture();
+    const shaA = landTaskCommit(repoA, "a.ts", "line1\nfeature-a\n", "feat(FN-A): add feature in repo-a");
+    const shaB = landTaskCommit(repoB, "b.ts", "line1\nfeature-a\n", "feat(FN-A): add feature in repo-b");
+
+    writeFileSync(join(repoB, "b.ts"), "line1\nfeature-a\nSTRAY UNCOMMITTED CHANGE\n");
+
+    const mainHeadBeforeA = git(repoA, "git rev-parse main");
+    const mainHeadBeforeB = git(repoB, "git rev-parse main");
+
+    const task = makeWorkspaceTask(shaA, shaB);
+    await expect(
+      prepareWorkspaceRevertPrBranches({
+        task,
+        workspaceRootDir: workspaceRoot,
+        settings: {},
+        revertBranch: "fusion/revert-fn-a",
+      }),
+    ).rejects.toMatchObject({ code: "dirty-working-tree" });
+
+    for (const repoRootDir of [repoA, repoB]) {
+      expect(git(repoRootDir, "git branch --list fusion/revert-fn-a")).toBe("");
+    }
+    expect(git(repoA, "git rev-parse main")).toBe(mainHeadBeforeA);
+    expect(git(repoB, "git rev-parse main")).toBe(mainHeadBeforeB);
+  });
+
+  it("branch-mismatch refusal: refuses without mutating any sub-repo when one is checked out on a different branch", async () => {
+    const { workspaceRoot, repoA, repoB } = workspaceFixture();
+    const shaA = landTaskCommit(repoA, "a.ts", "line1\nfeature-a\n", "feat(FN-A): add feature in repo-a");
+    const shaB = landTaskCommit(repoB, "b.ts", "line1\nfeature-a\n", "feat(FN-A): add feature in repo-b");
+
+    git(repoB, "git checkout -b some-other-branch");
+
+    const mainHeadBeforeA = git(repoA, "git rev-parse main");
+    const mainHeadBeforeB = git(repoB, "git rev-parse main");
+
+    const task = makeWorkspaceTask(shaA, shaB);
+    await expect(
+      prepareWorkspaceRevertPrBranches({
+        task,
+        workspaceRootDir: workspaceRoot,
+        settings: {},
+        revertBranch: "fusion/revert-fn-a",
+      }),
+    ).rejects.toMatchObject({ code: "branch-mismatch" });
+
+    for (const repoRootDir of [repoA, repoB]) {
+      expect(git(repoRootDir, "git branch --list fusion/revert-fn-a")).toBe("");
+    }
+    expect(git(repoA, "git rev-parse main")).toBe(mainHeadBeforeA);
+    expect(git(repoB, "git rev-parse main")).toBe(mainHeadBeforeB);
+  });
+
+  it("late-conflict multi-branch cleanup: repo-a's prepped branch is deleted when repo-b conflicts during apply (branch moved between classify and apply)", async () => {
+    const { workspaceRoot, repoA, repoB } = workspaceFixture();
+    const shaA = landTaskCommit(repoA, "a.ts", "line1\nfeature-a\n", "feat(FN-A): add feature in repo-a");
+    const shaB = landTaskCommit(repoB, "b.ts", "line1\nfeature-a\n", "feat(FN-A): add feature in repo-b");
+
+    const mainHeadBeforeA = git(repoA, "git rev-parse main");
+    const mainHeadBeforeB = git(repoB, "git rev-parse main");
+
+    const task = makeWorkspaceTask(shaA, shaB);
+
+    /*
+    FNXC:TaskRevert 2026-07-05-00:00 (FN-7577 test): both sub-repos classify
+    CLEAN in Phase 1 (repo-b's main is still untouched at that point). Once
+    Phase 2 starts checking out repo-a's branch (repo-a sorts first), inject a
+    conflicting commit directly onto repo-b's `main` — simulating repo-b's
+    branch moving between classify and apply. When Phase 2 reaches repo-b,
+    `checkout -B fusion/revert-fn-a main` branches off the NEW (conflicting)
+    tip, so applying repo-b's revert commit now conflicts — a genuine late
+    conflict. Assert repo-a's already-prepped branch is rolled back too.
+    */
+    let injected = false;
+    const execAsyncImpl: typeof realExecAsync = (async (command: string, options: Record<string, unknown>) => {
+      if (!injected && options?.cwd === repoA && /git checkout -B/.test(command)) {
+        injected = true;
+        writeFileSync(join(repoB, "b.ts"), "line1\nfeature-a-modified-by-b\n");
+        execSync("git commit -am 'feat(FN-B): modify same region in repo-b'", { cwd: repoB, stdio: "pipe" });
+      }
+      return realExecAsync(command, options as never);
+    }) as typeof realExecAsync;
+
+    const result = await prepareWorkspaceRevertPrBranches({
+      task,
+      workspaceRootDir: workspaceRoot,
+      settings: {},
+      revertBranch: "fusion/revert-fn-a",
+      execAsyncImpl,
+    });
+
+    expect(result).toMatchObject({ eligible: false, classification: "conflicting" });
+    if (!result.eligible && result.classification === "conflicting") {
+      expect(result.conflicts.some((c) => c.repo === "repo-b")).toBe(true);
+    }
+    // repo-a's already-prepped branch from this pass is rolled back too — all-or-nothing.
+    expect(git(repoA, "git branch --list fusion/revert-fn-a")).toBe("");
+    expect(git(repoB, "git branch --list fusion/revert-fn-a")).toBe("");
+    expect(git(repoA, "git rev-parse main")).toBe(mainHeadBeforeA);
+    // repo-b's main legitimately advanced due to the injected commit (this test
+    // simulates an external actor landing work mid-preparation) — the
+    // invariant is that NO revert branch/commit was created anywhere, not that
+    // repo-b's HEAD is frozen (that HEAD moved before this function ever ran
+    // Phase 2 for repo-b).
+    expect(git(repoB, "git rev-parse main")).not.toBe(mainHeadBeforeB);
+  });
+});
diff --git a/packages/engine/src/index.ts b/packages/engine/src/index.ts
index 90721e2a4e..cdd22c1c47 100644
--- a/packages/engine/src/index.ts
+++ b/packages/engine/src/index.ts
@@ -295,6 +295,10 @@ export {
   prepareRevertPrBranch,
   type PrepareRevertPrBranchResult,
   type PrepareRevertPrBranchOptions,
+  prepareWorkspaceRevertPrBranches,
+  type PrepareWorkspaceRevertPrBranchesResult,
+  type PrepareWorkspaceRevertPrBranchesOptions,
+  type WorkspaceRepoRevertPrBranch,
 } from "./task-revert.js";
 export {
   resolveBranchGroupMergeRouting,
diff --git a/packages/engine/src/task-revert.ts b/packages/engine/src/task-revert.ts
index 47299fdb88..7d4bea5745 100644
--- a/packages/engine/src/task-revert.ts
+++ b/packages/engine/src/task-revert.ts
@@ -35,6 +35,17 @@
  * captures `preRevertHead` before touching the tree and guarantees a full
  * `git revert --abort` + `git reset --hard <preRevertHead>` rollback in a
  * `finally` block, regardless of how the dry-run terminates.
+ *
+ * FNXC:TaskRevert 2026-07-05-00:00 (FN-7577 — PR-based revert extended to
+ * workspace tasks): `prepareRevertPrBranch` (FN-7554) explicitly refuses
+ * workspace tasks (`workspace-task-pr-revert-unsupported`) because a single
+ * PR against a single base branch cannot represent a multi-repo revert.
+ * `prepareWorkspaceRevertPrBranches` fills that gap: it mirrors
+ * `revertWorkspaceTask`'s classify-all-then-commit-all skeleton but, instead
+ * of force-committing onto each sub-repo's integration branch, prepares one
+ * dedicated `<revertBranch>` per sub-repo (never writing any integration
+ * branch) so the caller can open one PR per sub-repo. See its own doc
+ * comment below for the full contract.
  */
 import { exec } from "node:child_process";
 import { join } from "node:path";
@@ -1225,6 +1236,290 @@ export async function revertWorkspaceTask(opts: RevertWorkspaceTaskOptions): Pro
   return { mode: "git", clean: true, workspace: { repos } };
 }
 
+// ---------------------------------------------------------------------------
+// FN-7577: PR-based revert for WORKSPACE (multi-repo) tasks under autoMerge:false.
+// ---------------------------------------------------------------------------
+
+export interface WorkspaceRepoRevertPrBranch {
+  repo: string;
+  /** Same branch NAME across every sub-repo (`fusion/revert-<task-id-lowercase>`). */
+  revertBranch: string;
+  /** This sub-repo's resolved integration branch — the PR base. NEVER written to. */
+  integrationBranch: string;
+  revertCommitShas: string[];
+}
+
+export type PrepareWorkspaceRevertPrBranchesResult =
+  | { eligible: true; repos: WorkspaceRepoRevertPrBranch[] }
+  | {
+      eligible: false;
+      classification: "conflicting";
+      conflicts: (TaskRevertConflict & { repo: string })[];
+      repos: WorkspaceRepoRevertResult[];
+    }
+  | { eligible: false; unsupported: true; reason: string };
+
+export interface PrepareWorkspaceRevertPrBranchesOptions {
+  task: Pick<Task, "id" | "lineageId" | "column" | "mergeDetails" | "workspaceWorktrees">;
+  /** Project root dir; each sub-repo lives at `join(workspaceRootDir, repoRel)` (mirrors `revertWorkspaceTask`). */
+  workspaceRootDir: string;
+  /** Project settings, passed through to `resolveIntegrationBranch` per sub-repo with `integrationBranch`/`baseBranch` stripped (KTD1). */
+  settings: IntegrationBranchSettings;
+  /** e.g. `fusion/revert-<task-id-lowercase>` — the SAME branch name prepared in every sub-repo. */
+  revertBranch: string;
+  execAsyncImpl?: ExecAsyncImpl;
+  commitAssociationSource?: TaskCommitAssociationSource;
+}
+
+interface WorkspaceRepoRevertPrContext {
+  repo: string;
+  repoRootDir: string;
+  integrationBranch: string;
+  commits: string[];
+  classification: ClassifyTaskRevertResult;
+}
+
+type PrepareOneWorkspaceRepoBranchOutcome =
+  | { kind: "applied"; revertCommitSha: string }
+  | { kind: "already-reverted" }
+  | { kind: "conflicts"; conflicts: TaskRevertConflict[] };
+
+/**
+ * FNXC:TaskRevert 2026-07-05-00:00 (FN-7577 — per-sub-repo branch prep
+ * primitive, mirrors FN-7554's single-repo `prepareRevertPrBranch` body):
+ * Prepares ONE sub-repo's dedicated `revertBranch` off `integrationBranch`
+ * HEAD (`-B`, idempotent re-run), applies+commits via the shared
+ * `applyAndCommitRevert` (REUSE, not reimplementation — same helper
+ * `performTaskRevert`/`revertWorkspaceTask`/`prepareRevertPrBranch` all use),
+ * and ALWAYS restores the sub-repo checkout back to `integrationBranch`
+ * before returning — `integrationBranch`'s ref itself is never advanced,
+ * reset, or committed to. A redundant/failed local `revertBranch` (nothing
+ * to commit, or a late apply-time conflict) is deleted so this sub-repo is
+ * left byte-identical to its pre-call state whenever no PR branch results.
+ */
+async function prepareOneWorkspaceRepoRevertBranch(opts: {
+  execImpl: ExecAsyncImpl;
+  repoRootDir: string;
+  integrationBranch: string;
+  revertBranch: string;
+  commits: string[];
+  taskId: string;
+}): Promise<PrepareOneWorkspaceRepoBranchOutcome> {
+  const { execImpl, repoRootDir, integrationBranch, revertBranch, commits, taskId } = opts;
+  let branchCreated = false;
+  try {
+    // FNXC:TaskRevert 2026-07-05-00:00: `-B` (create-or-reset) makes
+    // re-running this idempotent when a stale local `revertBranch` already
+    // exists from a prior failed/aborted attempt — reset off
+    // `integrationBranch` HEAD rather than accumulating on top of whatever it
+    // previously pointed at. `integrationBranch` is only ever READ here.
+    await runGit(execImpl, `git checkout -B ${quoteShellArg(revertBranch)} ${quoteShellArg(integrationBranch)}`, repoRootDir);
+    branchCreated = true;
+
+    const applied = await applyAndCommitRevert({ worktreePath: repoRootDir, commits, taskId, execAsyncImpl: execImpl });
+
+    if ("alreadyReverted" in applied) {
+      // Defensive: the branch moved between classify and apply — nothing to
+      // commit on the fresh revertBranch. Delete the now-redundant branch so
+      // this sub-repo contributes no branch to the caller.
+      await runGit(execImpl, `git checkout ${quoteShellArg(integrationBranch)}`, repoRootDir).catch(() => undefined);
+      await runGit(execImpl, `git branch -D ${quoteShellArg(revertBranch)}`, repoRootDir).catch(() => undefined);
+      return { kind: "already-reverted" };
+    }
+    if ("conflicts" in applied) {
+      // Late conflict — applyAndCommitRevert already rolled repoRootDir back to
+      // the tip of revertBranch (== integrationBranch HEAD). Delete the
+      // now-redundant branch; the caller handles multi-repo rollback.
+      await runGit(execImpl, `git checkout ${quoteShellArg(integrationBranch)}`, repoRootDir).catch(() => undefined);
+      await runGit(execImpl, `git branch -D ${quoteShellArg(revertBranch)}`, repoRootDir).catch(() => undefined);
+      return { kind: "conflicts", conflicts: applied.conflicts };
+    }
+
+    // applied.applied === true — leave `revertBranch` in place (it IS the PR
+    // branch) but restore the sub-repo checkout back to `integrationBranch`,
+    // never leaving it mid-revert on `revertBranch`.
+    await runGit(execImpl, `git checkout ${quoteShellArg(integrationBranch)}`, repoRootDir).catch(() => undefined);
+    return { kind: "applied", revertCommitSha: applied.revertCommitSha };
+  } catch (error) {
+    // On any thrown failure after branch creation, never leave a dangling
+    // partial revert branch behind — best-effort restore + delete.
+    if (branchCreated) {
+      await runGit(execImpl, `git checkout ${quoteShellArg(integrationBranch)}`, repoRootDir).catch(() => undefined);
+      await runGit(execImpl, `git branch -D ${quoteShellArg(revertBranch)}`, repoRootDir).catch(() => undefined);
+    }
+    throw error instanceof TaskRevertError
+      ? error
+      : new TaskRevertError("failed to prepare revert branch for sub-repo", "revert-pr-branch-prepare-failed", error);
+  }
+}
+
+/**
+ * FNXC:TaskRevert 2026-07-05-00:00 (FN-7577 — workspace PR-revert branch prep,
+ * the all-or-nothing gate this task adds on top of FN-7554/FN-7547):
+ *
+ * NEVER-WRITE-TO-INTEGRATION-BRANCH INVARIANT: mirrors `prepareRevertPrBranch`
+ * (single-repo) extended to N sub-repos — no sub-repo's integration branch
+ * ref is EVER advanced, reset, or committed to. Every revert commit lives
+ * ONLY on that sub-repo's `<revertBranch>` (same branch NAME across every
+ * sub-repo, distinct branch OBJECT per sub-repo git history).
+ *
+ * CLASSIFY-ALL-THEN-PREP-ALL (Phase 1 / Phase 2), mirroring
+ * `revertWorkspaceTask`'s whole-task all-or-nothing contract: Phase 1
+ * dry-run classifies EVERY sub-repo first (reusing the shared
+ * `classifyTaskRevert`, itself always rolling each tree back
+ * byte-identical). If ANY sub-repo classifies `conflicting`, this function
+ * returns immediately with NO branch created anywhere — Phase 2 (branch
+ * prep) never runs for ANY sub-repo. Only when every sub-repo classifies
+ * clean/already-reverted does Phase 2 run, preparing one dedicated
+ * `<revertBranch>` per sub-repo that actually has commits to revert
+ * (`prepareOneWorkspaceRepoRevertBranch`, reusing `applyAndCommitRevert` — no
+ * commit-message/trailer duplication). A LATE conflict during Phase 2 (a
+ * sub-repo's branch moved between classify and apply) rolls back every
+ * PREVIOUSLY prepped sub-repo's branch in this pass (checkout back +
+ * `git branch -D`) before returning conflicting, so the whole preparation
+ * stays all-or-nothing even when the failure surfaces mid-pass rather than
+ * during classification.
+ *
+ * THIS FUNCTION DOES NOT GATE ON `autoMerge` — the caller (the API route)
+ * decides when to invoke this primitive; it stays a pure branch-prep
+ * building block usable independent of that policy decision.
+ */
+export async function prepareWorkspaceRevertPrBranches(
+  opts: PrepareWorkspaceRevertPrBranchesOptions,
+): Promise<PrepareWorkspaceRevertPrBranchesResult> {
+  const { task, workspaceRootDir, revertBranch } = opts;
+  const execImpl = opts.execAsyncImpl ?? defaultExecAsync;
+
+  if (!isWorkspaceTask(task) || Object.keys(task.workspaceWorktrees ?? {}).length === 0) {
+    return { eligible: false, unsupported: true, reason: "not-a-workspace-task" };
+  }
+
+  const workspaceWorktrees = task.workspaceWorktrees ?? {};
+  const repoKeys = Object.keys(workspaceWorktrees).sort();
+
+  const attribution = await resolveWorkspaceTaskRevertCommits(task, {
+    workspaceRootDir,
+    execAsyncImpl: execImpl,
+    commitAssociationSource: opts.commitAssociationSource,
+  });
+
+  // Phase 1: resolve each sub-repo's integration branch, refuse (without
+  // mutating) on branch-mismatch/dirty-tree, then dry-run classify EVERY
+  // sub-repo — mirrors `revertWorkspaceTask`'s Phase 1 verbatim.
+  const contexts: WorkspaceRepoRevertPrContext[] = [];
+  for (const repoRel of repoKeys) {
+    const repoRootDir = join(workspaceRootDir, repoRel);
+
+    let integrationBranch: string;
+    try {
+      integrationBranch = await resolveIntegrationBranch(repoRootDir, { ...opts.settings, integrationBranch: undefined, baseBranch: undefined });
+    } catch (error) {
+      throw new TaskRevertError(`failed to resolve integration branch for sub-repo ${repoRel}`, "integration-branch-resolve-failed", error);
+    }
+
+    const currentBranch = (await runGit(execImpl, "git rev-parse --abbrev-ref HEAD", repoRootDir)).stdout.trim();
+    if (currentBranch !== integrationBranch) {
+      throw new TaskRevertError(
+        `sub-repo ${repoRel} checkout is on "${currentBranch}", not its integration branch "${integrationBranch}"; switch to "${integrationBranch}" before preparing a revert PR branch`,
+        "branch-mismatch",
+      );
+    }
+
+    const { stdout: statusOut } = await runGit(execImpl, "git status --porcelain", repoRootDir);
+    if (statusOut.trim().length > 0) {
+      throw new TaskRevertError(
+        `working tree for sub-repo ${repoRel} is dirty; refusing to prepare a revert PR branch`,
+        "dirty-working-tree",
+      );
+    }
+
+    const commits = attribution[repoRel]?.commits ?? [];
+    const classification = await classifyTaskRevert({ worktreePath: repoRootDir, commits, execAsyncImpl: execImpl });
+
+    contexts.push({ repo: repoRel, repoRootDir, integrationBranch, commits, classification });
+  }
+
+  const anyConflicting = contexts.some((ctx) => ctx.classification.classification === "conflicting");
+  if (anyConflicting) {
+    const repos: WorkspaceRepoRevertResult[] = contexts.map((ctx) => ({
+      repo: ctx.repo,
+      classification: ctx.classification.classification,
+      conflicts: ctx.classification.conflicts,
+      alreadyReverted: ctx.classification.alreadyReverted,
+    }));
+    const conflicts = contexts.flatMap((ctx) =>
+      (ctx.classification.conflicts ?? []).map((conflict) => ({ ...conflict, repo: ctx.repo })),
+    );
+    return { eligible: false, classification: "conflicting", conflicts, repos };
+  }
+
+  // Phase 2: every sub-repo classified clean/already-reverted — prepare a
+  // dedicated revert branch per sub-repo that actually has commits to revert.
+  const preppedRepos: WorkspaceRepoRevertPrBranch[] = [];
+  const preppedForRollback: { repo: string; repoRootDir: string; integrationBranch: string }[] = [];
+
+  try {
+    for (const ctx of contexts) {
+      if (ctx.classification.classification === "already-reverted" || ctx.commits.length === 0) {
+        // Nothing to revert in this sub-repo — contributes no branch.
+        continue;
+      }
+
+      const outcome = await prepareOneWorkspaceRepoRevertBranch({
+        execImpl,
+        repoRootDir: ctx.repoRootDir,
+        integrationBranch: ctx.integrationBranch,
+        revertBranch,
+        commits: ctx.commits,
+        taskId: task.id,
+      });
+
+      if (outcome.kind === "already-reverted") {
+        continue;
+      }
+
+      if (outcome.kind === "conflicts") {
+        // Late conflict — roll back every PREVIOUSLY prepped sub-repo's branch
+        // in this pass so the whole preparation stays all-or-nothing.
+        for (const prepped of preppedForRollback) {
+          await runGit(execImpl, `git checkout ${quoteShellArg(prepped.integrationBranch)}`, prepped.repoRootDir).catch(() => undefined);
+          await runGit(execImpl, `git branch -D ${quoteShellArg(revertBranch)}`, prepped.repoRootDir).catch(() => undefined);
+        }
+        const conflicts = outcome.conflicts.map((conflict) => ({ ...conflict, repo: ctx.repo }));
+        const repos: WorkspaceRepoRevertResult[] = contexts.map((c) => ({
+          repo: c.repo,
+          classification: c.repo === ctx.repo ? "conflicting" : c.classification.classification,
+          conflicts: c.repo === ctx.repo ? outcome.conflicts : c.classification.conflicts,
+          alreadyReverted: c.classification.alreadyReverted,
+        }));
+        return { eligible: false, classification: "conflicting", conflicts, repos };
+      }
+
+      // outcome.kind === "applied"
+      preppedRepos.push({
+        repo: ctx.repo,
+        revertBranch,
+        integrationBranch: ctx.integrationBranch,
+        revertCommitShas: [outcome.revertCommitSha],
+      });
+      preppedForRollback.push({ repo: ctx.repo, repoRootDir: ctx.repoRootDir, integrationBranch: ctx.integrationBranch });
+    }
+  } catch (error) {
+    // Unexpected thrown failure mid-pass — best-effort restore + delete every
+    // already-prepped sub-repo branch so a failed prep never leaves dangling
+    // half-built revert branches.
+    for (const prepped of preppedForRollback) {
+      await runGit(execImpl, `git checkout ${quoteShellArg(prepped.integrationBranch)}`, prepped.repoRootDir).catch(() => undefined);
+      await runGit(execImpl, `git branch -D ${quoteShellArg(revertBranch)}`, prepped.repoRootDir).catch(() => undefined);
+    }
+    throw error instanceof TaskRevertError
+      ? error
+      : new TaskRevertError("failed to prepare workspace revert PR branches", "workspace-revert-pr-branch-prepare-failed", error);
+  }
+
+  return { eligible: true, repos: preppedRepos };
+}
+
 // ────────────────────────────────────────────────────────────────────────
 // FN-7524: AI-undo fallback
 // ────────────────────────────────────────────────────────────────────────

From 42bbe58c03434fd826e950955a3980b3141d2348 Mon Sep 17 00:00:00 2001
From: gsxdsm <gsxdsm@users.noreply.github.com>
Date: Sun, 5 Jul 2026 11:10:02 -0700
Subject: [PATCH 34/65] FN-7579: add ask-user and exit-gate workflow nodes

Add workflow nodes for mid-flow user reach-out and early exit from a workflow run.

- Add `ask-user` IR node kind that reuses the await-input park/resume mechanism and surfaces the question in the task chat for brainstorming/clarification.
- Add `exit-gate` IR node kind that terminates the workflow early, with an optional condition.
- Wire both node kinds through the engine executor and workflow-node-handlers, including a new exit-gate-runner.
- Update the WorkflowNodeEditor palette, node summaries, and node help text for the two new node types.
- Extend workflow-flow-mapping to support the new node kinds.
- Keep `prompt`+`awaitInput` as a back-compat alias.
- Add core/engine/dashboard tests covering the new node kinds.
- Document the new nodes in docs/workflow-steps.md.
- Add changeset for the new minor feature.

Files changed:
 .changeset/fn-7579-ask-user-exit-gate-nodes.md     |   7 +
 docs/workflow-steps.md                             |  28 ++++
 packages/core/src/__tests__/workflow-ir.test.ts    | 120 ++++++++++++++
 packages/core/src/workflow-ir-types.ts             |  12 +-
 packages/core/src/workflow-ir.ts                   |  47 ++++++
 .../app/components/WorkflowNodeEditor.tsx          | 181 ++++++++++++++++++++-
 .../app/components/__tests__/node-summary.test.ts  |  43 +++++
 .../__tests__/workflow-flow-mapping.test.ts        |  49 ++++++
 .../app/components/nodes/WorkflowNodeTypes.tsx     |  14 +-
 .../dashboard/app/components/nodes/node-help.ts    |  24 +++
 .../dashboard/app/components/nodes/node-summary.ts |  28 ++++
 .../app/components/workflow-flow-mapping.ts        |   4 +
 .../workflow-graph-executor-handlers.test.ts       | 115 +++++++++++++
 .../src/__tests__/workflow-node-handlers.test.ts   |  66 ++++++++
 packages/engine/src/executor.ts                    |  23 ++-
 packages/engine/src/workflow-node-handlers.ts      |  18 +-
 .../src/workflow-node-runners/exit-gate-runner.ts  |  81 +++++++++
 17 files changed, 849 insertions(+), 11 deletions(-)

Fusion-Task-Id: FN-7579
Fusion-Task-Lineage: 9a89ff49-200d-4a6c-b97c-15d219349ee5
Co-authored-by: Fusion (runfusion.ai) <noreply@runfusion.ai>
---
 .../fn-7579-ask-user-exit-gate-nodes.md       |   7 +
 docs/workflow-steps.md                        |  28 +++
 .../core/src/__tests__/workflow-ir.test.ts    | 120 ++++++++++++
 packages/core/src/workflow-ir-types.ts        |  12 +-
 packages/core/src/workflow-ir.ts              |  47 +++++
 .../app/components/WorkflowNodeEditor.tsx     | 181 +++++++++++++++++-
 .../components/__tests__/node-summary.test.ts |  43 +++++
 .../__tests__/workflow-flow-mapping.test.ts   |  49 +++++
 .../components/nodes/WorkflowNodeTypes.tsx    |  14 +-
 .../app/components/nodes/node-help.ts         |  24 +++
 .../app/components/nodes/node-summary.ts      |  28 +++
 .../app/components/workflow-flow-mapping.ts   |   4 +
 .../workflow-graph-executor-handlers.test.ts  | 115 +++++++++++
 .../__tests__/workflow-node-handlers.test.ts  |  66 +++++++
 packages/engine/src/executor.ts               |  23 ++-
 packages/engine/src/workflow-node-handlers.ts |  18 +-
 .../workflow-node-runners/exit-gate-runner.ts |  81 ++++++++
 17 files changed, 849 insertions(+), 11 deletions(-)
 create mode 100644 .changeset/fn-7579-ask-user-exit-gate-nodes.md
 create mode 100644 packages/engine/src/workflow-node-runners/exit-gate-runner.ts

diff --git a/.changeset/fn-7579-ask-user-exit-gate-nodes.md b/.changeset/fn-7579-ask-user-exit-gate-nodes.md
new file mode 100644
index 0000000000..66172c6c82
--- /dev/null
+++ b/.changeset/fn-7579-ask-user-exit-gate-nodes.md
@@ -0,0 +1,7 @@
+---
+"@runfusion/fusion": minor
+---
+
+summary: Add "Ask user question" and "Exit gate" workflow nodes for mid-flow chat reach-out and early exit.
+category: feature
+dev: New IR node kinds `ask-user` (reuses await-input park/resume; surfaces the question in the task chat) and `exit-gate` (terminates the workflow early, optional condition). Editor palette + summaries + help updated; `prompt`+`awaitInput` remains a back-compat alias.
diff --git a/docs/workflow-steps.md b/docs/workflow-steps.md
index eb89aace9e..3100eea654 100644
--- a/docs/workflow-steps.md
+++ b/docs/workflow-steps.md
@@ -356,6 +356,34 @@ Parallelism is opt-in *per step by the planner*, not asserted by the workflow au
 
 Notification delivery is intentionally best-effort: a missing/unconfigured notification service, an empty `event`, or a provider delivery failure is logged/audited but does not fail the workflow node. Providers receive the rendered title/message in notification metadata so ntfy and webhook notifications can show workflow-specific copy. `workflow-notify` is **not** part of the default ntfy event allowlist; add it to `ntfyEvents` or the provider `events` filter when you want workflow-authored notifications delivered.
 
+#### `ask-user` node — chat reach-out (FN-7579)
+
+`ask-user` (`{ question? }`) reaches out to the user from inside a running task: it parks the task with `status: "awaiting-user-input"`, `paused: true`, and `pausedReason` carrying a `workflow-input:<nodeId>@<pauseEpochMs>: <question>` marker; the question surfaces in the task chat/detail (and via the `planning-awaiting-input` notification). Once the user replies (a steering comment at/after the pause watermark) and unpauses the task, the node resumes, clears its marker, and publishes the answer downstream at context key `input:<nodeId>` (readable by, for example, a downstream `exit-gate`'s condition). `question` falls back to `config.prompt`, then the shared default string ("This workflow is waiting for your input.") when both are omitted.
+
+`ask-user` is a first-class, discoverable promotion of plumbing that already existed: a `prompt` node with `config.awaitInput: true` pauses/resumes identically (`runAwaitInputNode`). That shape remains a **fully supported back-compat alias** — existing workflows using it are unaffected — `ask-user` is simply the dedicated palette entry and IR node kind for new authoring.
+
+#### `exit-gate` node — early workflow termination (FN-7579)
+
+`exit-gate` (`{ condition? }`) lets a workflow route directly to the terminal `end` node instead of always walking the full graph. It is validated to always have a (transitive, non-rework) path to `end` so it can never strand the graph, but it is **not** itself an `end` node — only a router onto one.
+
+With no `condition`, an exit-gate always exits (`outcome:exit`). With a `condition` (the same shape as a `loop` node's `exitWhen`: `{ type: "output-contains", nodeId?, value }` or `{ type: "output-matches", nodeId?, pattern, flags? }`), the gate reads `context["input:<nodeId>"]` — the same key an `ask-user` node's answer is published under — and exits (`outcome:exit`) when it matches, or falls through (`outcome:continue`) otherwise. Route `outcome:exit` to `end` and `outcome:continue` back into the loop (or onward) as needed. A malformed condition (bad regex, missing referenced value) degrades to "no match" rather than throwing.
+
+#### Brainstorming / chat reach-out composition
+
+Compose `ask-user` + `exit-gate` for a brainstorming phase that loops until the user approves, then proceeds:
+
+```
+start → ask (ask-user: "Anything to refine?")
+     → exit (exit-gate: condition { type: "output-contains", nodeId: "ask", value: "looks good" })
+         ── outcome:exit ──→ end   (or onward into the normal plan/execute path)
+         ── outcome:continue ──→ ask   (rework edge back to the ask-user node; mark the ask-user
+                                       node `config.reworkRegion: true` and the edge `kind: "rework"`,
+                                       mirroring the top-level rework-region convention U6 uses for
+                                       the PR review loop)
+```
+
+Each turn, the user is asked to refine; once they reply "looks good" (or whatever the condition matches), the exit-gate routes the task out of the brainstorm loop. This is a documented composition, not a registered built-in workflow — copy the shape into a custom workflow's IR via `fn_workflow_create`/`fn_workflow_update`.
+
 #### Workflow-defined custom task fields
 
 Workflows declare typed task fields via IR `fields: [{ id, name, type, required?, default?, options?, render? }]` (`type ∈ string | text | number | boolean | enum | multi-enum | date | url`; `options` for enum kinds; `render.placement ∈ card | detail | detail-section`, `render.widget`, `render.badge`). Values live in `tasks.customFields` and are validated through a single store authority (`updateTaskCustomFields`) with typed rejections (offending `fieldId` + `code`). Editing or switching a workflow **orphans** (never destroys) values for removed/incompatible fields — orphans are retained and shown under a detail disclosure. The task UI renders the schema dynamically (detail-form widgets by type, up to 3 card badges by placement). Agents read/write fields via `fn_task_update`'s `custom_fields` patch; authors set them via `fn_workflow_create/update`. Field values are surfaced in task/session context.
diff --git a/packages/core/src/__tests__/workflow-ir.test.ts b/packages/core/src/__tests__/workflow-ir.test.ts
index b1f28d1277..9b5624250b 100644
--- a/packages/core/src/__tests__/workflow-ir.test.ts
+++ b/packages/core/src/__tests__/workflow-ir.test.ts
@@ -439,6 +439,126 @@ describe("parseWorkflowIr — notify nodes", () => {
   });
 });
 
+describe("parseWorkflowIr — ask-user / exit-gate nodes (FN-7579)", () => {
+  const cols = [{ id: "c", name: "C", traits: [] }];
+
+  it("accepts a well-formed graph using both new kinds", () => {
+    const ir = v2(
+      cols,
+      [
+        { id: "start", kind: "start", column: "c" },
+        { id: "ask", kind: "ask-user", column: "c", config: { question: "Looks good?" } },
+        { id: "exit", kind: "exit-gate", column: "c" },
+        { id: "end", kind: "end", column: "c" },
+      ],
+      [
+        { from: "start", to: "ask" },
+        { from: "ask", to: "exit" },
+        { from: "exit", to: "end" },
+      ],
+    );
+    expect(() => parseWorkflowIr(ir)).not.toThrow();
+  });
+
+  it("keeps v2 when ask-user/exit-gate nodes are present (v2-only, not in V1_NODE_KINDS)", () => {
+    const ir = v2(
+      cols,
+      [
+        { id: "start", kind: "start", column: "c" },
+        { id: "ask", kind: "ask-user", column: "c" },
+        { id: "exit", kind: "exit-gate", column: "c" },
+        { id: "end", kind: "end", column: "c" },
+      ],
+      [
+        { from: "start", to: "ask" },
+        { from: "ask", to: "exit" },
+        { from: "exit", to: "end" },
+      ],
+    );
+    const parsed = parseWorkflowIr(ir);
+    expect(downgradeIrToV1IfPure(parsed).version).toBe("v2");
+  });
+
+  it("rejects an ask-user node with an empty question", () => {
+    const ir = v2(
+      cols,
+      [
+        { id: "start", kind: "start", column: "c" },
+        { id: "ask", kind: "ask-user", column: "c", config: { question: "   " } },
+        { id: "end", kind: "end", column: "c" },
+      ],
+      [
+        { from: "start", to: "ask" },
+        { from: "ask", to: "end" },
+      ],
+    );
+    expect(() => parseWorkflowIr(ir)).toThrow(/ask-user node 'ask' question must be a non-empty string/);
+  });
+
+  it("accepts an ask-user node with no question (falls back to the default prompt)", () => {
+    const ir = v2(
+      cols,
+      [
+        { id: "start", kind: "start", column: "c" },
+        { id: "ask", kind: "ask-user", column: "c" },
+        { id: "end", kind: "end", column: "c" },
+      ],
+      [
+        { from: "start", to: "ask" },
+        { from: "ask", to: "end" },
+      ],
+    );
+    expect(() => parseWorkflowIr(ir)).not.toThrow();
+  });
+
+  it("rejects an exit-gate node that cannot reach the terminal end node (stranded)", () => {
+    const ir = v2(
+      cols,
+      [
+        { id: "start", kind: "start", column: "c" },
+        { id: "exit", kind: "exit-gate", column: "c" },
+        { id: "dead", kind: "prompt", column: "c" },
+        { id: "end", kind: "end", column: "c" },
+      ],
+      [
+        { from: "start", to: "exit" },
+        { from: "exit", to: "dead" },
+        { from: "start", to: "end" },
+      ],
+    );
+    expect(() => parseWorkflowIr(ir)).toThrow(/exit-gate node 'exit' must have a path to the terminal 'end' node/);
+  });
+
+  it("accepts a brainstorming loop composition: ask-user -> exit-gate (approved) or back to ask-user (refine)", () => {
+    const ir = v2(
+      cols,
+      [
+        { id: "start", kind: "start", column: "c" },
+        {
+          id: "ask",
+          kind: "ask-user",
+          column: "c",
+          config: { question: "Anything to refine?", reworkRegion: true },
+        },
+        {
+          id: "exit",
+          kind: "exit-gate",
+          column: "c",
+          config: { condition: { type: "output-contains", value: "looks good" } },
+        },
+        { id: "end", kind: "end", column: "c" },
+      ],
+      [
+        { from: "start", to: "ask" },
+        { from: "ask", to: "exit" },
+        { from: "exit", to: "end" },
+        { from: "exit", to: "ask", kind: "rework" },
+      ],
+    );
+    expect(() => parseWorkflowIr(ir)).not.toThrow();
+  });
+});
+
 describe("parseWorkflowIr — hold release kinds", () => {
   const holdCols = [{ id: "c", name: "C", traits: [] }];
   function holdIr(release: unknown): WorkflowIrV2 {
diff --git a/packages/core/src/workflow-ir-types.ts b/packages/core/src/workflow-ir-types.ts
index 0da9d5b6e6..46c39f2f11 100644
--- a/packages/core/src/workflow-ir-types.ts
+++ b/packages/core/src/workflow-ir-types.ts
@@ -11,7 +11,13 @@
  *  `branch-group-promotion`;
  *  and the unified PR-entity additions (U3):
  *  `pr-create` (open/reuse the PR + write the entity), `pr-respond` (the
- *  review-response run), and `pr-merge` (tool-side merge with expectedHeadOid). */
+ *  review-response run), and `pr-merge` (tool-side merge with expectedHeadOid);
+ *  and the brainstorming / chat reach-out additions (FN-7579):
+ *  `ask-user` (first-class surface over the existing await-input park/resume
+ *  plumbing — parks the task awaiting a user reply and surfaces `config.question`
+ *  in the task chat/detail) and `exit-gate` (routes the walk early to the
+ *  terminal `end` node when `config.condition` matches, or unconditionally when
+ *  absent — lets a workflow break out of a brainstorming loop once approved). */
 export type WorkflowIrNodeKind =
   | "start"
   | "prompt"
@@ -37,7 +43,9 @@ export type WorkflowIrNodeKind =
   | "branch-group-promotion"
   | "pr-create"
   | "pr-respond"
-  | "pr-merge";
+  | "pr-merge"
+  | "ask-user"
+  | "exit-gate";
 
 export interface WorkflowIrNode {
   id: string;
diff --git a/packages/core/src/workflow-ir.ts b/packages/core/src/workflow-ir.ts
index 782a3fc4e4..47f0adc173 100644
--- a/packages/core/src/workflow-ir.ts
+++ b/packages/core/src/workflow-ir.ts
@@ -1034,6 +1034,52 @@ function validateNotifyNodes(nodes: WorkflowIrNode[]): void {
   }
 }
 
+/*
+FNXC:WorkflowAskUserExitGate 2026-07-05-00:00:
+FN-7579 adds two brainstorming/chat reach-out node kinds. `ask-user` reuses the
+existing await-input park/resume plumbing (runAwaitInputNode) rather than a new
+runner: it must carry a non-empty `config.question` (falling back to
+`config.prompt`) OR omit both, in which case the engine's existing default
+question string is used — validation only rejects a present-but-empty/non-string
+value so authors cannot ship a blank prompt. `exit-gate` terminates the walk
+early toward the terminal `end` node: it must have at least one outgoing edge
+that (transitively, ignoring rework edges) reaches `end`, so an exit-gate can
+never strand the graph. It is NOT itself an `end` node (the one-start/one-end
+invariant is unaffected) — it only routes to one.
+*/
+function validateAskUserAndExitGateNodes(
+  nodes: WorkflowIrNode[],
+  outgoing: Map<string, WorkflowIrEdge[]>,
+): void {
+  const endNode = nodes.find((n) => n.kind === "end");
+
+  for (const node of nodes) {
+    if (node.kind === "ask-user") {
+      const cfg = node.config as { question?: unknown; prompt?: unknown } | undefined;
+      if (cfg?.question !== undefined && (typeof cfg.question !== "string" || cfg.question.trim() === "")) {
+        throw new WorkflowIrError(
+          `ask-user node '${node.id}' question must be a non-empty string when present`,
+        );
+      }
+      if (cfg?.prompt !== undefined && (typeof cfg.prompt !== "string" || cfg.prompt.trim() === "")) {
+        throw new WorkflowIrError(
+          `ask-user node '${node.id}' prompt must be a non-empty string when present`,
+        );
+      }
+    }
+
+    if (node.kind === "exit-gate") {
+      if (!endNode) continue; // exactly-one-end invariant already failed elsewhere.
+      const reachable = reachableFrom(node.id, outgoing);
+      if (!reachable.has(endNode.id)) {
+        throw new WorkflowIrError(
+          `exit-gate node '${node.id}' must have a path to the terminal 'end' node`,
+        );
+      }
+    }
+  }
+}
+
 /** Validate `fields` declarations (KTD-13). */
 function validateFields(fields: WorkflowFieldDefinition[] | undefined): void {
   if (fields === undefined) return;
@@ -1432,6 +1478,7 @@ function validateV2(ir: WorkflowIrV2): void {
   validateParseStepsNodes(ir);
   validateCodeNodes(ir.nodes);
   validateNotifyNodes(ir.nodes);
+  validateAskUserAndExitGateNodes(ir.nodes, outgoing);
   validateFields(ir.fields);
   validateSettings(ir.settings);
   // FNXC:WorkflowOptionalGroup 2026-06-21-18:00:
diff --git a/packages/dashboard/app/components/WorkflowNodeEditor.tsx b/packages/dashboard/app/components/WorkflowNodeEditor.tsx
index c540d10fbe..c70d94b256 100644
--- a/packages/dashboard/app/components/WorkflowNodeEditor.tsx
+++ b/packages/dashboard/app/components/WorkflowNodeEditor.tsx
@@ -18,7 +18,7 @@ import {
 } from "@xyflow/react";
 import { createPortal } from "react-dom";
 import { useTranslation } from "react-i18next";
-import { X, Plus, Trash2, Save, MessageSquare, Terminal, Shield, GitMerge, Loader2, HelpCircle, PauseCircle, Split, Merge, Repeat, ToggleRight, ClipboardCheck, ListChecks, Code2, Bell, LayoutGrid, Workflow, Download, Upload, ChevronDown, ChevronRight, ChevronLeft, Library, Sparkles, Maximize2, Minimize2 } from "lucide-react";
+import { X, Plus, Trash2, Save, MessageSquare, Terminal, Shield, GitMerge, Loader2, HelpCircle, PauseCircle, Split, Merge, Repeat, ToggleRight, ClipboardCheck, ListChecks, Code2, Bell, LayoutGrid, Workflow, Download, Upload, ChevronDown, ChevronRight, ChevronLeft, Library, Sparkles, Maximize2, Minimize2, DoorOpen } from "lucide-react";
 import type { WorkflowDefinition, WorkflowIrColumn, TraitViolation, WorkflowStepTemplate, WorkflowIrNodeKind } from "@fusion/core";
 import { getErrorMessage } from "@fusion/core";
 import {
@@ -263,7 +263,19 @@ const WORKFLOW_NOTIFY_MESSAGE_PLACEHOLDER = "Task {{taskId}} reached {{workflowN
 
 const PALETTE: Array<{ kind: WorkflowEditorNodeKind; label: string; icon: typeof MessageSquare; presetConfig?: Record<string, unknown> }> = [
   { kind: "prompt", label: "Prompt", icon: MessageSquare },
-  { kind: "prompt", label: "User input", icon: HelpCircle, presetConfig: { awaitInput: true } },
+  // FNXC:WorkflowAskUser 2026-07-05-00:00: FN-7579 promotes the formerly generic
+  // "User input" entry (a `prompt` node with a hidden `awaitInput: true` preset)
+  // into the first-class "Ask user question" node (`kind: "ask-user"`). The old
+  // `prompt` + `config.awaitInput: true` shape still validates and parks/resumes
+  // unchanged (back-compat alias) — it is just no longer offered from the
+  // palette, so there is one discoverable entry point, not two.
+  // FNXC:WorkflowAskUser 2026-07-05-01:30: no presetConfig here — an ask-user
+  // node's `config.question` key must be ABSENT (not an empty string) to fall
+  // back to the engine's default prompt; validateAskUserAndExitGateNodes
+  // rejects a present-but-empty question, so seeding `{ question: "" }` here
+  // would make every freshly dropped, untouched node fail to save.
+  { kind: "ask-user", label: "Ask user question", icon: HelpCircle },
+  { kind: "exit-gate", label: "Exit gate", icon: DoorOpen },
   { kind: "script", label: "Script", icon: Terminal },
   { kind: "gate", label: "Gate", icon: Shield },
   { kind: "merge", label: "Merge boundary", icon: GitMerge },
@@ -331,6 +343,8 @@ const USER_NODE_KINDS: ReadonlySet<WorkflowEditorNodeKind> = new Set<WorkflowEdi
   "parse-steps",
   "notify",
   "merge",
+  "ask-user",
+  "exit-gate",
 ]);
 
 /** A pickable creation template: "Blank" (id null) or a copyable source
@@ -4726,6 +4740,169 @@ function InnerEditor({
                 })()
               ) : null}
 
+              {/* FNXC:WorkflowAskUser 2026-07-05-00:00: the ask-user question is the only
+                  author-facing field; it reuses the same default-string fallback the
+                  engine's runAwaitInputNode applies when left blank. */}
+              {selectedNode.data.kind === "ask-user" ? (
+                <>
+                  <label className="wf-field">
+                    <span>{t("workflowNodes.askUserQuestion", "Question")}</span>
+                    <textarea
+                      rows={3}
+                      placeholder={t(
+                        "workflowNodes.askUserQuestionPlaceholder",
+                        "This workflow is waiting for your input.",
+                      )}
+                      value={String(selectedNode.data.config?.question ?? "")}
+                      onChange={(e) => updateSelectedData({ config: { question: e.target.value } })}
+                    />
+                  </label>
+                  <p className="wf-inspector-note wf-inspector-note--info">
+                    {t(
+                      "workflowNodes.askUserNote",
+                      "Parks the task and surfaces this question in the task chat/detail. Resumes once the user replies and unpauses.",
+                    )}
+                  </p>
+                </>
+              ) : null}
+
+              {/* FNXC:WorkflowExitGate 2026-07-05-00:00: condition is optional — an
+                  unconditional exit-gate always routes to end; a conditional one checks
+                  a referenced node's published input (e.g. an ask-user reply). */}
+              {selectedNode.data.kind === "exit-gate" ? (
+                (() => {
+                  const hasCondition =
+                    selectedNode.data.config?.condition != null &&
+                    typeof selectedNode.data.config.condition === "object";
+                  const condition = hasCondition
+                    ? (selectedNode.data.config!.condition as Record<string, unknown>)
+                    : { type: "output-contains", value: "" };
+                  const condType = String(condition.type ?? "output-contains");
+                  const condText = condType === "output-matches" ? String(condition.pattern ?? "") : String(condition.value ?? "");
+                  return (
+                    <>
+                      <label className="wf-field wf-field--checkbox">
+                        <input
+                          type="checkbox"
+                          checked={hasCondition}
+                          onChange={(e) => {
+                            if (e.target.checked) {
+                              updateSelectedData({
+                                config: { condition: { type: "output-contains", value: "" } },
+                              });
+                            } else {
+                              updateSelectedData({
+                                config: (prev) => {
+                                  const next = { ...prev };
+                                  delete next.condition;
+                                  return next;
+                                },
+                              });
+                            }
+                          }}
+                        />
+                        <span>{t("workflowNodes.exitGateConditional", "Exit conditionally")}</span>
+                      </label>
+                      {hasCondition ? (
+                        <>
+                          <label className="wf-field">
+                            <span>{t("workflowNodes.exitGateNodeId", "Watch node id")}</span>
+                            <input
+                              value={String(condition.nodeId ?? "")}
+                              placeholder={t("workflowNodes.exitGateNodeIdPlaceholder", "e.g. ask")}
+                              onChange={(e) => {
+                                const nodeId = e.target.value.trim();
+                                updateSelectedData({
+                                  config: (prev) => {
+                                    const current =
+                                      prev.condition && typeof prev.condition === "object"
+                                        ? (prev.condition as Record<string, unknown>)
+                                        : { type: "output-contains", value: "" };
+                                    const next = { ...current };
+                                    if (nodeId) next.nodeId = nodeId;
+                                    else delete next.nodeId;
+                                    return { ...prev, condition: next };
+                                  },
+                                });
+                              }}
+                            />
+                          </label>
+                          <label className="wf-field">
+                            <span>{t("workflowNodes.exitGateConditionType", "Exit when")}</span>
+                            <select
+                              value={condType}
+                              onChange={(e) => {
+                                const nextType = e.target.value;
+                                updateSelectedData({
+                                  config: (prev) => {
+                                    const current =
+                                      prev.condition && typeof prev.condition === "object"
+                                        ? (prev.condition as Record<string, unknown>)
+                                        : {};
+                                    const text =
+                                      nextType === "output-matches"
+                                        ? String(current.pattern ?? current.value ?? "")
+                                        : String(current.value ?? current.pattern ?? "");
+                                    const nextCondition: Record<string, unknown> = { ...current, type: nextType };
+                                    delete nextCondition.pattern;
+                                    delete nextCondition.value;
+                                    return {
+                                      ...prev,
+                                      condition:
+                                        nextType === "output-matches"
+                                          ? { ...nextCondition, pattern: text }
+                                          : { ...nextCondition, value: text },
+                                    };
+                                  },
+                                });
+                              }}
+                            >
+                              <option value="output-contains">{t("workflowNodes.loopOutputContains", "Output contains")}</option>
+                              <option value="output-matches">{t("workflowNodes.loopOutputMatches", "Output matches regex")}</option>
+                            </select>
+                          </label>
+                          <label className="wf-field">
+                            <span>
+                              {condType === "output-matches"
+                                ? t("workflowNodes.loopPattern", "Pattern")
+                                : t("workflowNodes.loopValue", "Value")}
+                            </span>
+                            <input
+                              value={condText}
+                              placeholder={condType === "output-matches" ? "looks good|approved" : "looks good"}
+                              onChange={(e) => {
+                                const value = e.target.value;
+                                updateSelectedData({
+                                  config: (prev) => {
+                                    const current =
+                                      prev.condition && typeof prev.condition === "object"
+                                        ? (prev.condition as Record<string, unknown>)
+                                        : {};
+                                    return {
+                                      ...prev,
+                                      condition:
+                                        condType === "output-matches"
+                                          ? { ...current, type: condType, pattern: value }
+                                          : { ...current, type: condType, value },
+                                    };
+                                  },
+                                });
+                              }}
+                            />
+                          </label>
+                        </>
+                      ) : null}
+                      <p className="wf-inspector-note wf-inspector-note--info">
+                        {t(
+                          "workflowNodes.exitGateNote",
+                          "Routes early to End (outcome:exit) when the condition matches, or unconditionally when none is set. Falls through (outcome:continue) otherwise.",
+                        )}
+                      </p>
+                    </>
+                  );
+                })()
+              ) : null}
+
               {selectedNode.data.kind === "prompt" ||
               selectedNode.data.kind === "gate" ||
               selectedNode.data.kind === "script" ? (
diff --git a/packages/dashboard/app/components/__tests__/node-summary.test.ts b/packages/dashboard/app/components/__tests__/node-summary.test.ts
index b58e70982b..4283896f48 100644
--- a/packages/dashboard/app/components/__tests__/node-summary.test.ts
+++ b/packages/dashboard/app/components/__tests__/node-summary.test.ts
@@ -26,4 +26,47 @@ describe("nodeConfigSummary", () => {
 
     expect(nodeConfigSummary(data)).toBe("workflow-notify · This message is intentionally long enou…");
   });
+
+  // FN-7579
+  it("summarizes an ask-user node by its question", () => {
+    const data: WorkflowFlowNodeData = {
+      kind: "ask-user",
+      label: "Ask user question",
+      config: { question: "Anything to refine before we finish?" },
+    };
+
+    expect(nodeConfigSummary(data)).toBe("Anything to refine before we finish?");
+  });
+
+  it("falls back to the default prompt summary when an ask-user node has no question", () => {
+    const data: WorkflowFlowNodeData = { kind: "ask-user", label: "Ask user question", config: {} };
+
+    expect(nodeConfigSummary(data)).toBe("Waits for user input");
+  });
+
+  it("summarizes an unconditional exit-gate", () => {
+    const data: WorkflowFlowNodeData = { kind: "exit-gate", label: "Exit gate", config: {} };
+
+    expect(nodeConfigSummary(data)).toBe("Always exits");
+  });
+
+  it("summarizes a conditional exit-gate (output-contains)", () => {
+    const data: WorkflowFlowNodeData = {
+      kind: "exit-gate",
+      label: "Exit gate",
+      config: { condition: { type: "output-contains", nodeId: "ask", value: "looks good" } },
+    };
+
+    expect(nodeConfigSummary(data)).toBe('Exits when contains "looks good"');
+  });
+
+  it("summarizes a conditional exit-gate (output-matches)", () => {
+    const data: WorkflowFlowNodeData = {
+      kind: "exit-gate",
+      label: "Exit gate",
+      config: { condition: { type: "output-matches", nodeId: "ask", pattern: "approve(d)?" } },
+    };
+
+    expect(nodeConfigSummary(data)).toBe("Exits when matches /approve(d)?/");
+  });
 });
diff --git a/packages/dashboard/app/components/__tests__/workflow-flow-mapping.test.ts b/packages/dashboard/app/components/__tests__/workflow-flow-mapping.test.ts
index 70a202ecca..d4eb40aa89 100644
--- a/packages/dashboard/app/components/__tests__/workflow-flow-mapping.test.ts
+++ b/packages/dashboard/app/components/__tests__/workflow-flow-mapping.test.ts
@@ -490,6 +490,53 @@ describe("workflow-flow-mapping v2 round-trip", () => {
       config: { event: "workflow-notify", title: "{{taskTitle}}", message: "Task {{taskId}}" },
     });
   });
+
+  // FN-7579: ask-user and exit-gate round-trip like any other first-class editor node.
+  it("round-trips ask-user and exit-gate nodes (brainstorming composition) losslessly", () => {
+    const brainstormIr: WorkflowDefinition["ir"] = {
+      version: "v2",
+      name: "brainstorm-wf",
+      columns: [{ id: "todo", name: "Todo", traits: [] }],
+      nodes: [
+        { id: "start", kind: "start", column: "todo" },
+        { id: "ask", kind: "ask-user", column: "todo", config: { question: "Anything to refine?" } },
+        {
+          id: "exit",
+          kind: "exit-gate",
+          column: "todo",
+          config: { condition: { type: "output-contains", nodeId: "ask", value: "looks good" } },
+        },
+        { id: "end", kind: "end", column: "todo" },
+      ],
+      edges: [
+        { from: "start", to: "ask", condition: "success" },
+        { from: "ask", to: "exit", condition: "success" },
+        { from: "exit", to: "end", condition: "outcome:exit" },
+      ],
+    };
+
+    const { nodes, edges } = irToFlow(v2Def(brainstormIr));
+    const askNode = nodes.find((node) => node.id === "ask");
+    expect(askNode?.type).toBe("ask-user");
+    expect(askNode?.data.kind).toBe("ask-user");
+    const exitNode = nodes.find((node) => node.id === "exit");
+    expect(exitNode?.type).toBe("exit-gate");
+    expect(exitNode?.data.kind).toBe("exit-gate");
+
+    const { ir: out } = flowToIr("brainstorm-wf", nodes, edges, columnsOf(v2Def(brainstormIr)));
+    expect(out.version).toBe("v2");
+    if (out.version !== "v2") return;
+    expect(out.nodes.find((node) => node.id === "ask")).toMatchObject({
+      kind: "ask-user",
+      column: "todo",
+      config: { question: "Anything to refine?" },
+    });
+    expect(out.nodes.find((node) => node.id === "exit")).toMatchObject({
+      kind: "exit-gate",
+      column: "todo",
+      config: { condition: { type: "output-contains", nodeId: "ask", value: "looks good" } },
+    });
+  });
 });
 
 describe("workflow-flow-mapping validation helpers", () => {
@@ -605,6 +652,8 @@ const VALID_EDITOR_NODE_KINDS: readonly WorkflowEditorNodeKind[] = [
   "parse-steps",
   "code",
   "notify",
+  "ask-user",
+  "exit-gate",
 ];
 
 const IR_ONLY_EDITOR_KIND = {
diff --git a/packages/dashboard/app/components/nodes/WorkflowNodeTypes.tsx b/packages/dashboard/app/components/nodes/WorkflowNodeTypes.tsx
index 9a58883b16..9e046b1a9e 100644
--- a/packages/dashboard/app/components/nodes/WorkflowNodeTypes.tsx
+++ b/packages/dashboard/app/components/nodes/WorkflowNodeTypes.tsx
@@ -1,5 +1,5 @@
 import { Handle, Position, type NodeProps } from "@xyflow/react";
-import { Play, Flag, MessageSquare, Terminal, Shield, GitMerge, PauseCircle, Split, Merge, AlertTriangle, Repeat, ClipboardCheck, ListChecks, Code2, Bell, ToggleRight } from "lucide-react";
+import { Play, Flag, MessageSquare, Terminal, Shield, GitMerge, PauseCircle, Split, Merge, AlertTriangle, Repeat, ClipboardCheck, ListChecks, Code2, Bell, ToggleRight, HelpCircle, DoorOpen } from "lucide-react";
 import { useTranslation } from "react-i18next";
 import { nodeConfigSummary } from "./node-summary";
 import { useWorkflowEditorCatalogs } from "./WorkflowEditorCatalogContext";
@@ -34,7 +34,13 @@ export type WorkflowEditorNodeKind =
   | WorkflowNodeKindStepReview
   | WorkflowNodeKindParseSteps
   | "code"
-  | "notify";
+  | "notify"
+  // FN-7579: brainstorming / chat reach-out additions. `ask-user` parks the
+  // task awaiting a user reply (first-class surface over the await-input
+  // park/resume plumbing); `exit-gate` routes the walk early to the terminal
+  // `end` node.
+  | "ask-user"
+  | "exit-gate";
 
 export interface WorkflowFlowNodeData {
   kind: WorkflowEditorNodeKind;
@@ -80,6 +86,8 @@ const KIND_ICON: Record<WorkflowEditorNodeKind, typeof Play> = {
   [WORKFLOW_NODE_KIND_PARSE_STEPS]: ListChecks,
   code: Code2,
   notify: Bell,
+  "ask-user": HelpCircle,
+  "exit-gate": DoorOpen,
 };
 
 /** Shared error-state component (U10): one component renders both the
@@ -270,4 +278,6 @@ export const workflowNodeTypes = {
   "parse-steps": ({ data }: NodeProps) => <NodeShell data={data as WorkflowFlowNodeData} kind="parse-steps" />,
   code: ({ data }: NodeProps) => <NodeShell data={data as WorkflowFlowNodeData} kind="code" />,
   notify: ({ data }: NodeProps) => <NodeShell data={data as WorkflowFlowNodeData} kind="notify" />,
+  "ask-user": ({ data }: NodeProps) => <NodeShell data={data as WorkflowFlowNodeData} kind="ask-user" />,
+  "exit-gate": ({ data }: NodeProps) => <NodeShell data={data as WorkflowFlowNodeData} kind="exit-gate" />,
 };
diff --git a/packages/dashboard/app/components/nodes/node-help.ts b/packages/dashboard/app/components/nodes/node-help.ts
index 0ea0000ff8..bb6e9c5646 100644
--- a/packages/dashboard/app/components/nodes/node-help.ts
+++ b/packages/dashboard/app/components/nodes/node-help.ts
@@ -193,6 +193,30 @@ const NODE_HELP: Record<string, NodeHelp> = {
     edges: "One outgoing edge (success); the node is pass-through.",
   },
 
+  // FN-7579: brainstorming / chat reach-out nodes.
+  "ask-user": {
+    title: "Ask user question",
+    summary:
+      "Reaches out to the user from inside the running task: parks the task awaiting a reply, surfaces the Question in the task chat/detail, and resumes the flow once the user replies and unpauses. First-class surface over the same park/resume plumbing a Prompt node's Wait for user input option uses.",
+    configure:
+      'Write the Question the user is asked. Leave it blank to use the default "This workflow is waiting for your input" prompt.',
+    inputs: "The task at this point in the flow.",
+    outputs: "The user's reply, available downstream as this node's input context.",
+    edges:
+      "One outgoing edge (success), taken once the user replies. Compose with an Exit gate for a brainstorm ask → refine → exit-when-approved loop.",
+  },
+  "exit-gate": {
+    title: "Exit gate",
+    summary:
+      "Lets a workflow terminate early — routing straight to the terminal End node — instead of always walking the full graph. Useful for breaking out of a brainstorming ask-user/refine loop once the user approves.",
+    configure:
+      "Optionally set an Exit condition (output contains / output matches regex) checked against a referenced node's input (e.g. an Ask user question's reply). Leave unset for an unconditional exit.",
+    inputs: "The task plus prior context (e.g. an Ask user question's reply).",
+    outputs: "An exit / continue decision.",
+    edges:
+      "outcome:exit → routes to End; outcome:continue → falls through to the next node (e.g. back into the brainstorm loop).",
+  },
+
   // ── Graph-only (engine-managed) IR kinds ──────────────────────────────────
   "merge-gate": {
     title: "Auto-merge gate",
diff --git a/packages/dashboard/app/components/nodes/node-summary.ts b/packages/dashboard/app/components/nodes/node-summary.ts
index 110f3e5edb..336f53957e 100644
--- a/packages/dashboard/app/components/nodes/node-summary.ts
+++ b/packages/dashboard/app/components/nodes/node-summary.ts
@@ -239,6 +239,34 @@ export function nodeConfigSummary(
       const message = truncate(firstLine(str(config.message)), COMMAND_TRUNCATE);
       return message ? `${event} · ${message}` : event;
     }
+    // FN-7579: ask-user surfaces its question (or the shared default prompt
+    // when omitted); exit-gate mirrors loop's exitWhen summary (unconditional
+    // when config.condition is absent).
+    case "ask-user": {
+      const question = str(config.question) || str(config.prompt);
+      return question
+        ? truncate(firstLine(question), COMMAND_TRUNCATE)
+        : t("workflowNodes.summaryAskUserDefault", "Waits for user input");
+    }
+    case "exit-gate": {
+      const condition = config.condition as unknown;
+      if (!condition || typeof condition !== "object") {
+        return t("workflowNodes.summaryExitGateUnconditional", "Always exits");
+      }
+      const c = condition as Record<string, unknown>;
+      const type = str(c.type);
+      if (type === "output-matches") {
+        return t("workflowNodes.summaryExitGateMatches", "Exits when matches /{{pattern}}/", {
+          pattern: str(c.pattern),
+        });
+      }
+      if (type === "output-contains") {
+        return t('workflowNodes.summaryExitGateContains', 'Exits when contains "{{value}}"', {
+          value: str(c.value),
+        });
+      }
+      return t("workflowNodes.summaryExitGateUnconditional", "Always exits");
+    }
     // No meaningful summary: structural/control nodes.
     case "start":
     case "end":
diff --git a/packages/dashboard/app/components/workflow-flow-mapping.ts b/packages/dashboard/app/components/workflow-flow-mapping.ts
index 85572793f7..dbf00e151f 100644
--- a/packages/dashboard/app/components/workflow-flow-mapping.ts
+++ b/packages/dashboard/app/components/workflow-flow-mapping.ts
@@ -189,6 +189,10 @@ const SAME_KIND_EDITOR_NODE_KINDS = new Set<WorkflowIrNodeKind>([
   "parse-steps",
   "code",
   "notify",
+  // FN-7579: brainstorming / chat reach-out node kinds round-trip IR ↔ editor
+  // like any other user-authored node.
+  "ask-user",
+  "exit-gate",
 ]);
 
 const GRAPH_ONLY_EDITOR_KIND: Partial<Record<WorkflowIrNodeKind, WorkflowEditorNodeKind>> = {
diff --git a/packages/engine/src/__tests__/workflow-graph-executor-handlers.test.ts b/packages/engine/src/__tests__/workflow-graph-executor-handlers.test.ts
index ea4f76eacb..5bd4f55105 100644
--- a/packages/engine/src/__tests__/workflow-graph-executor-handlers.test.ts
+++ b/packages/engine/src/__tests__/workflow-graph-executor-handlers.test.ts
@@ -424,4 +424,119 @@ describe("WorkflowGraphExecutor traversal", () => {
 
     await expect(executor.run(task, settingsOn(), ir)).rejects.toThrow("Cycle detected");
   });
+
+  // FN-7579: ask-user (chat reach-out) + exit-gate (early termination) end-to-end
+  // through the real registered handlers (no override), using deps.runCustomNode
+  // exactly as the ask-user node is dispatched in production.
+  describe("ask-user / exit-gate (FN-7579)", () => {
+    it("ask-user node parks the task awaiting-user-input via the custom-node runner", async () => {
+      const ir: WorkflowIr = {
+        version: "v1",
+        name: "ask-user",
+        nodes: [
+          { id: "start", kind: "start" },
+          { id: "ask", kind: "ask-user", config: { question: "Looks good?" } },
+          { id: "end", kind: "end" },
+        ],
+        edges: [
+          { from: "start", to: "ask" },
+          { from: "ask", to: "end", condition: "success" },
+        ],
+      };
+      const runCustomNode = vi.fn(async () => ({ outcome: "failure" as const, value: "awaiting-user-input" }));
+      const executor = new WorkflowGraphExecutor({ runCustomNode });
+
+      const result = await executor.run(task, settingsOn(), ir);
+      expect(runCustomNode).toHaveBeenCalledOnce();
+      expect(runCustomNode.mock.calls[0][0]).toMatchObject({ id: "ask", kind: "ask-user" });
+      expect(result.outcome).toBe("failure");
+      expect(result.visitedNodeIds).not.toContain("end");
+    });
+
+    it("unconditional exit-gate terminates early, skipping downstream nodes", async () => {
+      const ir: WorkflowIr = {
+        version: "v1",
+        name: "exit-gate-unconditional",
+        nodes: [
+          { id: "start", kind: "start" },
+          { id: "exit", kind: "exit-gate" },
+          { id: "never", kind: "prompt" },
+          { id: "end", kind: "end" },
+        ],
+        edges: [
+          { from: "start", to: "exit" },
+          { from: "exit", to: "end", condition: "outcome:exit" },
+          { from: "exit", to: "never", condition: "outcome:continue" },
+        ],
+      };
+      const never = vi.fn(async () => ({ outcome: "success" as const }));
+      const executor = new WorkflowGraphExecutor({ handlers: { prompt: never } });
+
+      const result = await executor.run(task, settingsOn(), ir);
+      expect(never).not.toHaveBeenCalled();
+      expect(result.outcome).toBe("success");
+      expect(result.visitedNodeIds).toContain("exit");
+      expect(result.visitedNodeIds).not.toContain("never");
+    });
+
+    it("conditional exit-gate falls through to the next node when the condition does not match", async () => {
+      const ir: WorkflowIr = {
+        version: "v1",
+        name: "exit-gate-conditional",
+        nodes: [
+          { id: "start", kind: "start" },
+          { id: "exit", kind: "exit-gate", config: { condition: { type: "output-contains", nodeId: "ask", value: "looks good" } } },
+          { id: "refine", kind: "prompt" },
+          { id: "end", kind: "end" },
+        ],
+        edges: [
+          { from: "start", to: "exit" },
+          { from: "exit", to: "end", condition: "outcome:exit" },
+          { from: "exit", to: "refine", condition: "outcome:continue" },
+        ],
+      };
+      const refine = vi.fn(async () => ({ outcome: "success" as const }));
+      const executor = new WorkflowGraphExecutor({
+        handlers: { prompt: refine },
+      });
+
+      const result = await executor.run(task, settingsOn(), ir);
+      expect(refine).toHaveBeenCalledOnce();
+      expect(result.visitedNodeIds).toContain("refine");
+    });
+
+    it("conditional exit-gate exits early when the referenced context value matches", async () => {
+      // Seed the ask-user answer via runCustomNode's contextPatch by running a
+      // graph that first visits an ask-user node, then the exit-gate reads its
+      // published `input:ask` context key.
+      const irWithAsk: WorkflowIr = {
+        version: "v1",
+        name: "exit-gate-conditional-match-full",
+        nodes: [
+          { id: "start", kind: "start" },
+          { id: "ask", kind: "ask-user", config: { question: "Anything to refine?" } },
+          { id: "exit", kind: "exit-gate", config: { condition: { type: "output-contains", nodeId: "ask", value: "looks good" } } },
+          { id: "refine", kind: "prompt" },
+          { id: "end", kind: "end" },
+        ],
+        edges: [
+          { from: "start", to: "ask" },
+          { from: "ask", to: "exit", condition: "success" },
+          { from: "exit", to: "end", condition: "outcome:exit" },
+          { from: "exit", to: "refine", condition: "outcome:continue" },
+        ],
+      };
+      const refine = vi.fn(async () => ({ outcome: "success" as const }));
+      const runCustomNode = vi.fn(async () => ({
+        outcome: "success" as const,
+        contextPatch: { "input:ask": "yes, looks good to me" },
+      }));
+      const executor2 = new WorkflowGraphExecutor({ runCustomNode, handlers: { prompt: refine } });
+
+      const result = await executor2.run(task, settingsOn(), irWithAsk);
+      expect(refine).not.toHaveBeenCalled();
+      expect(result.visitedNodeIds).toContain("exit");
+      expect(result.visitedNodeIds).not.toContain("refine");
+    });
+  });
 });
diff --git a/packages/engine/src/__tests__/workflow-node-handlers.test.ts b/packages/engine/src/__tests__/workflow-node-handlers.test.ts
index f7f31f625a..51f1732ea8 100644
--- a/packages/engine/src/__tests__/workflow-node-handlers.test.ts
+++ b/packages/engine/src/__tests__/workflow-node-handlers.test.ts
@@ -125,4 +125,70 @@ describe("workflow node handlers", () => {
     expect(result.outcome).toBe("success");
     expect(runCustomNode).not.toHaveBeenCalled();
   });
+
+  // FN-7579: ask-user is registered on the SAME custom-node seam as prompt/script
+  // (no dedicated seam string) so it always falls through to the custom-node
+  // runner, which is where the engine special-cases node.kind === "ask-user"
+  // onto the await-input park/resume path (covered end-to-end in
+  // workflow-graph-executor-handlers.test.ts).
+  it("dispatches an ask-user node to the custom-node runner (no seam)", async () => {
+    const runCustomNode = vi.fn(async () => ({ outcome: "failure" as const, value: "awaiting-user-input" }));
+    const handlers = createDefaultNodeHandlers(noopSeams(), runCustomNode);
+
+    const askNode: WorkflowIrNode = { id: "ask", kind: "ask-user", config: { question: "Anything to refine?" } };
+    const result = await handlers["ask-user"](askNode, { task, settings: undefined, context: {} });
+
+    expect(runCustomNode).toHaveBeenCalledWith(askNode, task, {});
+    expect(result).toEqual({ outcome: "failure", value: "awaiting-user-input" });
+  });
+
+  describe("exit-gate handler", () => {
+    it("exits unconditionally when no condition is configured", async () => {
+      const handlers = createDefaultNodeHandlers(noopSeams());
+      const result = await handlers["exit-gate"](
+        { id: "exit", kind: "exit-gate", config: {} },
+        { task, settings: undefined, context: {} },
+      );
+      expect(result).toEqual({ outcome: "success", value: "exit" });
+    });
+
+    it("exits when an output-contains condition matches the referenced node's context value", async () => {
+      const handlers = createDefaultNodeHandlers(noopSeams());
+      const result = await handlers["exit-gate"](
+        {
+          id: "exit",
+          kind: "exit-gate",
+          config: { condition: { type: "output-contains", nodeId: "ask", value: "looks good" } },
+        },
+        { task, settings: undefined, context: { "input:ask": "yes, looks good to me" } },
+      );
+      expect(result).toEqual({ outcome: "success", value: "exit" });
+    });
+
+    it("falls through (does not exit) when the condition does not match", async () => {
+      const handlers = createDefaultNodeHandlers(noopSeams());
+      const result = await handlers["exit-gate"](
+        {
+          id: "exit",
+          kind: "exit-gate",
+          config: { condition: { type: "output-contains", nodeId: "ask", value: "looks good" } },
+        },
+        { task, settings: undefined, context: { "input:ask": "needs more work" } },
+      );
+      expect(result).toEqual({ outcome: "success", value: "continue" });
+    });
+
+    it("exits when an output-matches regex condition matches", async () => {
+      const handlers = createDefaultNodeHandlers(noopSeams());
+      const result = await handlers["exit-gate"](
+        {
+          id: "exit",
+          kind: "exit-gate",
+          config: { condition: { type: "output-matches", nodeId: "ask", pattern: "approve(d)?", flags: "i" } },
+        },
+        { task, settings: undefined, context: { "input:ask": "Approved!" } },
+      );
+      expect(result).toEqual({ outcome: "success", value: "exit" });
+    });
+  });
 });
diff --git a/packages/engine/src/executor.ts b/packages/engine/src/executor.ts
index d274bdabb0..b63cb3cdb2 100644
--- a/packages/engine/src/executor.ts
+++ b/packages/engine/src/executor.ts
@@ -6647,9 +6647,21 @@ export class TaskExecutor {
    * placement re-walks earlier read-only nodes until CU-U5 checkpoints land.
    */
   private async runAwaitInputNode(node: WorkflowIrNode, live: TaskDetail): Promise<WorkflowNodeResult> {
-    const question = typeof node.config?.prompt === "string" && node.config.prompt.trim()
-      ? node.config.prompt.trim()
-      : "This workflow is waiting for your input.";
+    /*
+    FNXC:WorkflowAskUser 2026-07-05-00:00:
+    FN-7579's `ask-user` node is the first-class discoverable surface over this
+    SAME park/resume plumbing that a `prompt` node with `config.awaitInput: true`
+    already used. Question resolution order: `config.question` (the ask-user
+    node's dedicated field) first, then `config.prompt` (back-compat with the
+    original awaitInput alias), then the shared default string. Nothing below
+    this line branches on node.kind — both node kinds share one pause/resume
+    contract so behavior can never drift between them.
+    */
+    const question = typeof node.config?.question === "string" && node.config.question.trim()
+      ? node.config.question.trim()
+      : typeof node.config?.prompt === "string" && node.config.prompt.trim()
+        ? node.config.prompt.trim()
+        : "This workflow is waiting for your input.";
     const marker = `workflow-input:${node.id}`;
 
     const steering = Array.isArray(live.steeringComments) ? live.steeringComments : [];
@@ -7187,7 +7199,10 @@ export class TaskExecutor {
     if (staleInput === "clear") live = await this.store.getTask(nodeTask.id);
 
     // Await-input nodes never run a session — they pause for the user.
-    if (cfg.awaitInput === true) {
+    // FNXC:WorkflowAskUser 2026-07-05-00:00: `ask-user` is the dedicated,
+    // discoverable node kind for this same pause; `prompt` + `config.awaitInput:
+    // true` remains a back-compat alias (both route to the identical runner).
+    if (cfg.awaitInput === true || node.kind === "ask-user") {
       return this.runAwaitInputNode(node, live);
     }
 
diff --git a/packages/engine/src/workflow-node-handlers.ts b/packages/engine/src/workflow-node-handlers.ts
index 8b607377aa..b9a8386496 100644
--- a/packages/engine/src/workflow-node-handlers.ts
+++ b/packages/engine/src/workflow-node-handlers.ts
@@ -25,6 +25,7 @@ import {
   createMergeAttemptHandler,
   createMergeGateHandler,
 } from "./workflow-node-runners/merge-runner.js";
+import { createExitGateHandler } from "./workflow-node-runners/exit-gate-runner.js";
 
 export { createGateHandler } from "./workflow-node-runners/gate-runner.js";
 export {
@@ -40,6 +41,10 @@ export {
   createNotifyHandler,
   type WorkflowNotifyDispatch,
 } from "./workflow-node-runners/notify-runner.js";
+export {
+  createExitGateHandler,
+  type WorkflowExitGateConfig,
+} from "./workflow-node-runners/exit-gate-runner.js";
 
 // FNXC:WorkflowExecution 2026-06-25-00:00: U4 (KTD-2) — the `workflow-step` seam
 // was removed. Workflow quality gates run as the graph's own optional-group /
@@ -592,7 +597,9 @@ export function createDefaultNodeHandlers(
   | "branch-group-promotion"
   | "pr-create"
   | "pr-respond"
-  | "pr-merge",
+  | "pr-merge"
+  | "ask-user"
+  | "exit-gate",
   WorkflowNodeHandler
 > {
   const promptLike = deps?.primitives
@@ -626,6 +633,15 @@ export function createDefaultNodeHandlers(
   return {
     prompt: promptLike,
     script: promptLike,
+    // FNXC:WorkflowAskUser 2026-07-05-00:00: `ask-user` is a first-class node
+    // kind over the SAME custom-node seam as prompt/script — it carries no
+    // seam config, so it always falls through to the injected custom-node
+    // runner (runGraphCustomNode in executor.ts), which special-cases
+    // `node.kind === "ask-user"` onto the existing await-input park/resume path.
+    "ask-user": promptLike,
+    // FNXC:WorkflowExitGate 2026-07-05-00:00: dedicated small runner (mirrors
+    // notify-runner's shape) — no legacy seam, no custom-node execution.
+    "exit-gate": createExitGateHandler(),
     gate,
     "step-review": deps?.primitives
       ? createPrimitiveStepReviewHandler(deps.primitives)
diff --git a/packages/engine/src/workflow-node-runners/exit-gate-runner.ts b/packages/engine/src/workflow-node-runners/exit-gate-runner.ts
new file mode 100644
index 0000000000..cc03f12496
--- /dev/null
+++ b/packages/engine/src/workflow-node-runners/exit-gate-runner.ts
@@ -0,0 +1,81 @@
+import type { WorkflowLoopExitCondition } from "@fusion/core";
+
+import type { WorkflowNodeHandler, WorkflowNodeResult } from "../workflow-graph-executor.js";
+import type { WorkflowNodeRunner, WorkflowNodeRunnerContext } from "../workflow-node-runner.js";
+
+/*
+FNXC:WorkflowExitGate 2026-07-05-00:00:
+FN-7579's `exit-gate` node lets a workflow terminate early instead of always
+walking to the terminal `end` node the long way (e.g. breaking out of a
+brainstorming ask-user/refine loop once the user approves). It is validated
+(workflow-ir.ts) to always have a path to `end`, but it is NOT itself an `end`
+node — it only routes there.
+
+Contract: `config.condition` is optional and reuses the same shape as a `loop`
+node's `exitWhen` (`WorkflowLoopExitCondition`: `output-contains` /
+`output-matches`), read against `context[\`input:${condition.nodeId}\`]` — the
+same context key an `ask-user` node's answer is published under — so an
+exit-gate can gate directly on what the user said. Absent `condition`, the gate
+is unconditional and always exits. The runner never throws on a malformed
+condition; it degrades to "does not match" so a bad author config can't crash
+the walk, it just falls through instead of exiting early.
+
+Routing: the runner returns `outcome: "success"` with `value: "exit"` (match /
+unconditional) or `value: "continue"` (no match). Workflow edges select on
+`outcome:exit` / `outcome:continue` (or a single unconditional edge, which
+matches any `success` outcome) exactly like the existing gate/step-review
+outcome-edge convention.
+*/
+export interface WorkflowExitGateConfig {
+  condition?: WorkflowLoopExitCondition;
+}
+
+function resolveConditionText(
+  condition: WorkflowLoopExitCondition,
+  context: Record<string, unknown>,
+): string {
+  const key = typeof condition.nodeId === "string" && condition.nodeId ? `input:${condition.nodeId}` : undefined;
+  const raw = key ? context[key] : undefined;
+  if (raw === undefined || raw === null) return "";
+  return typeof raw === "string" ? raw : String(raw);
+}
+
+function matchesExitCondition(
+  condition: WorkflowLoopExitCondition,
+  context: Record<string, unknown>,
+): boolean {
+  const text = resolveConditionText(condition, context);
+  if (condition.type === "output-contains") {
+    return typeof condition.value === "string" && text.includes(condition.value);
+  }
+  if (condition.type === "output-matches") {
+    try {
+      return new RegExp(condition.pattern, condition.flags).test(text);
+    } catch {
+      // Malformed author-supplied regex: degrade to no-match rather than throw.
+      return false;
+    }
+  }
+  return false;
+}
+
+export class ExitGateNodeRunner implements WorkflowNodeRunner {
+  public readonly kind = "exit-gate" as const;
+
+  public async run(
+    node: Parameters<WorkflowNodeHandler>[0],
+    context: WorkflowNodeRunnerContext,
+  ): Promise<WorkflowNodeResult> {
+    const cfg = (node.config ?? {}) as WorkflowExitGateConfig;
+    if (!cfg.condition) {
+      return { outcome: "success", value: "exit" };
+    }
+    const matched = matchesExitCondition(cfg.condition, context.context);
+    return { outcome: "success", value: matched ? "exit" : "continue" };
+  }
+}
+
+export function createExitGateHandler(): WorkflowNodeHandler {
+  const runner = new ExitGateNodeRunner();
+  return (node, context) => runner.run(node, context);
+}

From ab28e7811cbeacd4ba6c9341a38b19f3986d69c4 Mon Sep 17 00:00:00 2001
From: gsxdsm <gsxdsm@users.noreply.github.com>
Date: Sun, 5 Jul 2026 11:12:48 -0700
Subject: [PATCH 35/65] FN-7581: make Intervention Timeline activity panel full
 width on mobile

Stop the Interventions Activity segment from reserving padding for an overlay toggle button it never renders, which was insetting the FN-7519 timeline from the right edge (worse on mobile).

- Add `.detail-activity--interventions` CSS modifier that zeroes `padding-inline-end` for the Interventions segment, both base and mobile breakpoints, while leaving Live/Feed/Raw's reserved padding untouched
- Apply the new modifier class to the Interventions `.detail-activity` container in TaskDetailModal.tsx
- Add a regression test asserting the Interventions container carries `detail-activity--interventions` while the Feed container (which still renders the overlay toggle) does not

Files changed:
 .../dashboard/app/components/TaskDetailModal.css   | 18 ++++++++++
 .../dashboard/app/components/TaskDetailModal.tsx   |  2 +-
 .../TaskDetailModal.oversight-controls.test.tsx    | 38 ++++++++++++++++++++++
 3 files changed, 57 insertions(+), 1 deletion(-)

Fusion-Task-Id: FN-7581

Fusion-Task-Lineage: d5c55773-7df3-4eb4-aa70-01f6e0a622c6

Co-authored-by: Fusion (runfusion.ai) <noreply@runfusion.ai>
---
 .../app/components/TaskDetailModal.css        | 18 +++++++++
 .../app/components/TaskDetailModal.tsx        |  2 +-
 ...askDetailModal.oversight-controls.test.tsx | 38 +++++++++++++++++++
 3 files changed, 57 insertions(+), 1 deletion(-)

diff --git a/packages/dashboard/app/components/TaskDetailModal.css b/packages/dashboard/app/components/TaskDetailModal.css
index 536d4b074c..ebac44574b 100644
--- a/packages/dashboard/app/components/TaskDetailModal.css
+++ b/packages/dashboard/app/components/TaskDetailModal.css
@@ -3049,6 +3049,19 @@ The body-portaled menu must paint above the owning task-detail modal/popup while
   padding-inline-end: calc(var(--space-2xl) + var(--space-md));
 }
 
+/*
+FNXC:PlannerOversight 2026-07-05-00:00:
+The Interventions Activity segment (FN-7571) renders no `.activity-expand-toggle--overlay`
+button, so it must not reserve the shared `.detail-activity` padding-inline-end that exists
+solely to keep that overlay toggle from covering Live/Feed content. Without this override the
+FN-7519 Intervention Timeline is inset from the right edge (worse on mobile, where the base
+reserved padding grows). FN-7581 zeroes the reserved padding for this segment only; Live/Feed/
+Raw keep the base rule unchanged.
+*/
+.detail-activity--interventions {
+  padding-inline-end: 0;
+}
+
 /*
 FNXC:TaskDetailActivity 2026-07-01-00:00:
 Live and Feed Activity expansion overlays the content instead of reserving a toolbar row. Feed keeps enough tokenized inline padding that the fixed affordance does not cover log text; Raw uses AgentLogViewer's fullscreen button and does not render this Activity toggle.
@@ -3091,6 +3104,11 @@ Live and Feed Activity expansion overlays the content instead of reserving a too
     padding-inline-end: calc(var(--space-2xl) + var(--space-lg));
   }
 
+  /* FNXC:PlannerOversight 2026-07-05-00:00: mobile reserves more padding for the overlay toggle; neutralize it for Interventions too so FN-7519's timeline stays full width on mobile per FN-7581. */
+  .detail-activity--interventions {
+    padding-inline-end: 0;
+  }
+
   .activity-expand-toggle {
     min-inline-size: calc(var(--space-2xl) + var(--space-sm));
     min-block-size: calc(var(--space-2xl) + var(--space-sm));
diff --git a/packages/dashboard/app/components/TaskDetailModal.tsx b/packages/dashboard/app/components/TaskDetailModal.tsx
index 2d240dc293..e5c612c4b0 100644
--- a/packages/dashboard/app/components/TaskDetailModal.tsx
+++ b/packages/dashboard/app/components/TaskDetailModal.tsx
@@ -4598,7 +4598,7 @@ export function TaskDetailContent({
                 // Intervention Timeline from the inline oversight cluster into this
                 // Activity segment. Reachable only via the dropdown, which already gates
                 // on oversightActive, so no `hidden` prop is needed here.
-                <div className="detail-activity" role="tabpanel">
+                <div className="detail-activity detail-activity--interventions" role="tabpanel">
                   <PlannerInterventionTimeline taskId={task.id} projectId={projectId} />
                 </div>
               ) : (
diff --git a/packages/dashboard/app/components/__tests__/TaskDetailModal.oversight-controls.test.tsx b/packages/dashboard/app/components/__tests__/TaskDetailModal.oversight-controls.test.tsx
index 69e65c3224..f403fbfb7b 100644
--- a/packages/dashboard/app/components/__tests__/TaskDetailModal.oversight-controls.test.tsx
+++ b/packages/dashboard/app/components/__tests__/TaskDetailModal.oversight-controls.test.tsx
@@ -604,6 +604,44 @@ describe("Intervention Timeline relocation into the Activity dropdown (FN-7571)"
       expect(screen.getByRole("menuitem", { name: "Live" })).toHaveAttribute("aria-current", "true");
     });
 
+    it("gives the Interventions Activity container the full-width modifier while Feed keeps the toggle-reserving container (FN-7581)", async () => {
+      // FNXC:PlannerOversight 2026-07-05-00:00: FN-7581 regression — the Interventions
+      // segment's `.detail-activity` container must carry `detail-activity--interventions`
+      // so it stops reserving `padding-inline-end` for the `.activity-expand-toggle--overlay`
+      // button it never renders (the FN-7519 timeline was inset from the right edge on
+      // mobile as a result). Feed (the only other segment sharing the raw `.detail-activity`
+      // wrapper and rendering that overlay toggle) must NOT carry the modifier since it still
+      // needs the reserved padding to keep the toggle from covering its content. (Live mounts
+      // its own overlay toggle inside TaskChatTab and never wraps in `.detail-activity` at all.)
+      render(
+        <TaskDetailModal
+          task={makeTask({ id: "FN-215", column: "in-progress", plannerOversightLevel: "autonomous", plannerOverseerState: activeSnapshot })}
+          onClose={noop}
+          onMoveTask={noopMove}
+          onDeleteTask={noopDelete}
+          onMergeTask={noopMerge}
+          onOpenDetail={noopOpenDetail}
+          addToast={noop}
+        />,
+      );
+
+      await screen.findByTestId("detail-overseer-nudge");
+
+      openActivityViewMenu();
+      fireEvent.click(screen.getByRole("menuitem", { name: "Feed" }));
+
+      const feedContainer = (await screen.findByText("Feed")).closest(".detail-activity");
+      expect(feedContainer).not.toBeNull();
+      expect(feedContainer).not.toHaveClass("detail-activity--interventions");
+
+      openActivityViewMenu();
+      fireEvent.click(screen.getByRole("menuitem", { name: "Interventions" }));
+
+      const interventionsContainer = (await screen.findByTestId("planner-intervention-timeline")).closest(".detail-activity");
+      expect(interventionsContainer).not.toBeNull();
+      expect(interventionsContainer).toHaveClass("detail-activity--interventions");
+    });
+
     it("still renders the empty state inside the Activity segment when there are no interventions", async () => {
       render(
         <TaskDetailModal

From 53fe0d71b9b7865b50d7377bc5770b6edf5e9df0 Mon Sep 17 00:00:00 2001
From: gsxdsm <gsxdsm@users.noreply.github.com>
Date: Sun, 5 Jul 2026 11:19:40 -0700
Subject: [PATCH 36/65] FN-7584: register builtin:brainstorming workflow with
 ask-user/exit-gate loop

Adds a discoverable built-in Brainstorming workflow composing the ask-user + exit-gate reach-out loop ahead of the standard coding plan/execute/review/merge spine, plus a WorkflowNodeEditor fix so clearing the ask-user question textarea deletes the config key instead of persisting an empty string.

- Add packages/core/src/builtin-brainstorming-workflow-ir.ts registering builtin:brainstorming (non-default, default-enabled): ask-user -> refine prompt -> exit-gate-on-approval ahead of the unmodified Coding plan/execute/review/merge spine
- Wire the new builtin into packages/core/src/builtin-workflows.ts and extend the builtin-workflows parity test suite
- Add builtin-brainstorming-workflow-ir.test.ts covering the new workflow's IR shape and validation
- Fix WorkflowNodeEditor.tsx ask-user question textarea onChange to delete the config.question key when cleared to empty (validateAskUserAndExitGateNodes rejects present-but-empty question; only an absent key falls back to the engine default)
- Update docs/workflow-steps.md to document builtin:brainstorming as a selectable built-in composition
- Add .changeset/fn-7584-brainstorming-builtin.md (minor, feature)

Files changed:
 .changeset/fn-7584-brainstorming-builtin.md        |   7 ++
 docs/workflow-steps.md                             |   2 +-
 .../builtin-brainstorming-workflow-ir.test.ts      |  79 ++++++++++++++++
 .../core/src/__tests__/builtin-workflows.test.ts   |  66 +++++++++++++
 .../core/src/builtin-brainstorming-workflow-ir.ts  | 103 +++++++++++++++++++++
 packages/core/src/builtin-workflows.ts             |  46 +++++++++
 .../app/components/WorkflowNodeEditor.tsx          |  18 +++-
 7 files changed, 319 insertions(+), 2 deletions(-)

Fusion-Task-Id: FN-7584

Fusion-Task-Lineage: 2c0258c2-9a35-403a-8688-ee49393a7231

Co-authored-by: Fusion (runfusion.ai) <noreply@runfusion.ai>
---
 .changeset/fn-7584-brainstorming-builtin.md   |   7 ++
 docs/workflow-steps.md                        |   2 +-
 .../builtin-brainstorming-workflow-ir.test.ts |  79 ++++++++++++++
 .../src/__tests__/builtin-workflows.test.ts   |  66 +++++++++++
 .../src/builtin-brainstorming-workflow-ir.ts  | 103 ++++++++++++++++++
 packages/core/src/builtin-workflows.ts        |  46 ++++++++
 .../app/components/WorkflowNodeEditor.tsx     |  18 ++-
 7 files changed, 319 insertions(+), 2 deletions(-)
 create mode 100644 .changeset/fn-7584-brainstorming-builtin.md
 create mode 100644 packages/core/src/__tests__/builtin-brainstorming-workflow-ir.test.ts
 create mode 100644 packages/core/src/builtin-brainstorming-workflow-ir.ts

diff --git a/.changeset/fn-7584-brainstorming-builtin.md b/.changeset/fn-7584-brainstorming-builtin.md
new file mode 100644
index 0000000000..21c73e7257
--- /dev/null
+++ b/.changeset/fn-7584-brainstorming-builtin.md
@@ -0,0 +1,7 @@
+---
+"@runfusion/fusion": minor
+---
+
+summary: Add a built-in "Brainstorming" workflow that talks to you before planning.
+category: feature
+dev: Registers `builtin:brainstorming` (non-default, default-enabled) composing FN-7579's `ask-user` → refine → `exit-gate`-on-approval phase ahead of the normal coding plan/execute/review/merge spine. Parity suite (`builtin-workflows.test.ts`) extended for the new entry.
diff --git a/docs/workflow-steps.md b/docs/workflow-steps.md
index 3100eea654..9e453b6d98 100644
--- a/docs/workflow-steps.md
+++ b/docs/workflow-steps.md
@@ -382,7 +382,7 @@ start → ask (ask-user: "Anything to refine?")
                                        the PR review loop)
 ```
 
-Each turn, the user is asked to refine; once they reply "looks good" (or whatever the condition matches), the exit-gate routes the task out of the brainstorm loop. This is a documented composition, not a registered built-in workflow — copy the shape into a custom workflow's IR via `fn_workflow_create`/`fn_workflow_update`.
+Each turn, the user is asked to refine; once they reply "looks good" (or whatever the condition matches), the exit-gate routes the task out of the brainstorm loop. This composition is also available as a discoverable built-in: `builtin:brainstorming` (FN-7584) registers exactly this shape — `ask-user` → a refine prompt step → `exit-gate`-on-approval — ahead of the unmodified default Coding plan/execute/review/merge spine, selectable directly from the workflow picker. Copy the shape into a custom workflow's IR via `fn_workflow_create`/`fn_workflow_update` when you need a different downstream pipeline than the standard coding one.
 
 #### Workflow-defined custom task fields
 
diff --git a/packages/core/src/__tests__/builtin-brainstorming-workflow-ir.test.ts b/packages/core/src/__tests__/builtin-brainstorming-workflow-ir.test.ts
new file mode 100644
index 0000000000..6ca93de2c6
--- /dev/null
+++ b/packages/core/src/__tests__/builtin-brainstorming-workflow-ir.test.ts
@@ -0,0 +1,79 @@
+import { describe, expect, it } from "vitest";
+import { BUILTIN_BRAINSTORMING_WORKFLOW_IR } from "../builtin-brainstorming-workflow-ir.js";
+import { parseWorkflowIr, serializeWorkflowIr } from "../workflow-ir.js";
+import type { WorkflowIrV2 } from "../workflow-ir-types.js";
+
+/*
+FNXC:WorkflowBrainstorming 2026-07-05-00:00:
+FN-7584 registers builtin:brainstorming as a discoverable built-in composing
+FN-7579's ask-user -> refine -> exit-gate-on-approval phase ahead of the normal
+coding plan/execute path. These tests pin the IR shape: it parses, orders the
+brainstorm nodes before the plan/execute spine, and round-trips through
+serialize/parse.
+*/
+
+describe("builtin brainstorming workflow IR", () => {
+  it("parses through parseWorkflowIr", () => {
+    expect(() => parseWorkflowIr(BUILTIN_BRAINSTORMING_WORKFLOW_IR)).not.toThrow();
+    const ir = BUILTIN_BRAINSTORMING_WORKFLOW_IR as WorkflowIrV2;
+    expect(ir.version).toBe("v2");
+  });
+
+  it("contains an ask-user and an exit-gate node ordered before the plan/execute spine", () => {
+    const ir = BUILTIN_BRAINSTORMING_WORKFLOW_IR as WorkflowIrV2;
+
+    const askUser = ir.nodes.find((node) => node.kind === "ask-user");
+    const exitGate = ir.nodes.find((node) => node.kind === "exit-gate");
+    expect(askUser?.id).toBe("brainstorm-ask");
+    expect(exitGate?.id).toBe("brainstorm-exit");
+
+    const startIndex = ir.nodes.findIndex((node) => node.id === "start");
+    const askIndex = ir.nodes.findIndex((node) => node.id === "brainstorm-ask");
+    const refineIndex = ir.nodes.findIndex((node) => node.id === "brainstorm-refine");
+    const exitIndex = ir.nodes.findIndex((node) => node.id === "brainstorm-exit");
+    const planIndex = ir.nodes.findIndex((node) => node.id === "plan");
+    const parseIndex = ir.nodes.findIndex((node) => node.id === "parse");
+    const stepsIndex = ir.nodes.findIndex((node) => node.id === "steps");
+
+    expect(startIndex).toBeGreaterThanOrEqual(0);
+    expect(askIndex).toBeGreaterThan(startIndex);
+    expect(refineIndex).toBeGreaterThan(askIndex);
+    expect(exitIndex).toBeGreaterThan(refineIndex);
+    expect(planIndex).toBeGreaterThan(exitIndex);
+    expect(parseIndex).toBeGreaterThan(planIndex);
+    expect(stepsIndex).toBeGreaterThan(parseIndex);
+
+    // Graph wiring: start feeds the brainstorm loop, and the exit-gate's
+    // outcome:exit edge is what rejoins the unmodified plan/execute spine.
+    expect(ir.edges).toContainEqual({ from: "start", to: "brainstorm-ask", condition: "success" });
+    expect(ir.edges).toContainEqual({ from: "brainstorm-ask", to: "brainstorm-refine", condition: "success" });
+    expect(ir.edges).toContainEqual({ from: "brainstorm-refine", to: "brainstorm-exit", condition: "success" });
+    expect(ir.edges).toContainEqual({ from: "brainstorm-exit", to: "plan", condition: "outcome:exit" });
+    expect(ir.edges).toContainEqual({
+      from: "brainstorm-exit",
+      to: "brainstorm-ask",
+      condition: "outcome:continue",
+      kind: "rework",
+    });
+
+    // The exit-gate's rework edge targets a declared top-level rework-region head.
+    expect(askUser?.config?.reworkRegion).toBe(true);
+    expect(typeof askUser?.config?.maxReworkCycles).toBe("number");
+
+    // ask-user carries a non-empty question (validator-enforced when present).
+    expect(typeof askUser?.config?.question).toBe("string");
+    expect((askUser?.config?.question as string).trim().length).toBeGreaterThan(0);
+  });
+
+  it("round-trips serialize -> parse to identical bytes", () => {
+    const serialized = serializeWorkflowIr(BUILTIN_BRAINSTORMING_WORKFLOW_IR);
+    const reparsed = parseWorkflowIr(serialized);
+    expect(serializeWorkflowIr(reparsed)).toBe(serialized);
+  });
+
+  it("carries the shared built-in workflow settings", () => {
+    const ir = BUILTIN_BRAINSTORMING_WORKFLOW_IR as WorkflowIrV2;
+    expect(ir.settings?.some((setting) => setting.id === "planReviewMaxRevisions")).toBe(true);
+    expect(ir.settings?.some((setting) => setting.id === "codeReviewMaxRevisions")).toBe(true);
+  });
+});
diff --git a/packages/core/src/__tests__/builtin-workflows.test.ts b/packages/core/src/__tests__/builtin-workflows.test.ts
index c695958ccf..0fbcff0039 100644
--- a/packages/core/src/__tests__/builtin-workflows.test.ts
+++ b/packages/core/src/__tests__/builtin-workflows.test.ts
@@ -343,6 +343,72 @@ describe("built-in workflows", () => {
     );
   });
 
+  /*
+   * FNXC:WorkflowBrainstorming 2026-07-05-00:00:
+   * FN-7584 parity coverage for the registered builtin:brainstorming built-in
+   * (FN-7579's ask-user -> refine -> exit-gate-on-approval composition,
+   * discoverable from the workflow picker ahead of the normal coding spine).
+   */
+  it("registers builtin:brainstorming as a default-enabled workflow ordered after the existing built-ins", () => {
+    const brainstorming = getBuiltinWorkflow("builtin:brainstorming");
+    expect(brainstorming).toBeDefined();
+    expect(brainstorming!.kind).toBe("workflow");
+    expect(() => parseWorkflowIr(brainstorming!.ir)).not.toThrow();
+    expect(defaultEnabledBuiltinWorkflowIds()).toContain("builtin:brainstorming");
+    expect(BUILTIN_WORKFLOWS.findIndex((workflow) => workflow.id === "builtin:brainstorming")).toBeGreaterThan(
+      BUILTIN_WORKFLOWS.findIndex((workflow) => workflow.id === "builtin:lead-generation"),
+    );
+    // Ordering assertion the suite pins elsewhere (`.slice(0, 5)`) must stay untouched.
+    expect(defaultEnabledBuiltinWorkflowIds().slice(0, 5)).toEqual([
+      "builtin:coding",
+      "builtin:coding-ideas",
+      "builtin:legacy-coding",
+      "builtin:quick-fix",
+      "builtin:review-heavy",
+    ]);
+  });
+
+  it("orders builtin:brainstorming's ask-user/exit-gate loop ahead of the plan/execute spine", () => {
+    const brainstorming = getBuiltinWorkflow("builtin:brainstorming")!;
+    const nodes = brainstorming.ir.nodes;
+    const askIndex = nodes.findIndex((node) => node.kind === "ask-user");
+    const exitIndex = nodes.findIndex((node) => node.kind === "exit-gate");
+    const planIndex = nodes.findIndex((node) => node.id === "plan");
+    const parseIndex = nodes.findIndex((node) => node.id === "parse");
+    const stepsIndex = nodes.findIndex((node) => node.id === "steps");
+
+    expect(askIndex).toBeGreaterThanOrEqual(0);
+    expect(exitIndex).toBeGreaterThan(askIndex);
+    expect(planIndex).toBeGreaterThan(exitIndex);
+    expect(parseIndex).toBeGreaterThan(planIndex);
+    expect(stepsIndex).toBeGreaterThan(parseIndex);
+  });
+
+  it("builtin:brainstorming still satisfies every merge-capable built-in invariant (completion summary, post-merge-verification, merge primitives, settings)", () => {
+    const brainstorming = getBuiltinWorkflow("builtin:brainstorming")!;
+    const summaryNodes = brainstorming.ir.nodes.filter(
+      (node) => node.kind === "prompt" && (node.config as { summaryTarget?: unknown } | undefined)?.summaryTarget === "task",
+    );
+    expect(summaryNodes).toHaveLength(1);
+    expect((summaryNodes[0]!.config as { toolMode?: unknown }).toolMode).toBe("readonly");
+
+    expect(brainstorming.ir.nodes.some((node) => node.id === "post-merge-verification")).toBe(true);
+    for (const id of [
+      "merge-gate",
+      "merge-retry",
+      "merge-manual-hold",
+      "branch-group-member-integration",
+      "branch-group-promotion",
+      "merge-attempt",
+      "recovery-router",
+    ]) {
+      expect(brainstorming.ir.nodes.some((node) => node.id === id)).toBe(true);
+    }
+
+    expect(brainstorming.ir.settings?.some((setting) => setting.id === "planReviewMaxRevisions")).toBe(true);
+    expect(brainstorming.ir.settings?.some((setting) => setting.id === "codeReviewMaxRevisions")).toBe(true);
+  });
+
   it("default workflow column ids equal the legacy enum values, in legacy order (KTD-1)", () => {
     expect(BUILTIN_CODING_WORKFLOW_IR.version).toBe("v2");
     if (BUILTIN_CODING_WORKFLOW_IR.version !== "v2") throw new Error("expected v2");
diff --git a/packages/core/src/builtin-brainstorming-workflow-ir.ts b/packages/core/src/builtin-brainstorming-workflow-ir.ts
new file mode 100644
index 0000000000..0c69fbc7bf
--- /dev/null
+++ b/packages/core/src/builtin-brainstorming-workflow-ir.ts
@@ -0,0 +1,103 @@
+import type { WorkflowIr, WorkflowIrV2 } from "./workflow-ir-types.js";
+import { parseWorkflowIr } from "./workflow-ir.js";
+import { BUILTIN_STEPWISE_FINAL_REVIEW_CODING_WORKFLOW_IR } from "./builtin-stepwise-final-review-coding-workflow-ir.js";
+import { BUILTIN_WORKFLOW_SETTINGS } from "./builtin-workflow-settings.js";
+
+/*
+FNXC:WorkflowBrainstorming 2026-07-05-00:00:
+FN-7584 closes the loop FN-7579 opened: `ask-user` and `exit-gate` node kinds
+existed only as a documented composition (docs/workflow-steps.md, "Brainstorming
+/ chat reach-out composition"), not a discoverable built-in. This module clones
+the default Coding graph (BUILTIN_STEPWISE_FINAL_REVIEW_CODING_WORKFLOW_IR,
+the same IR backing `builtin:coding`) and prepends a bounded brainstorming phase
+between `start` and `plan`:
+
+  start -> brainstorm-ask (ask-user: "what do you want to brainstorm?")
+        -> brainstorm-refine (prompt, seam:"planning": turn the conversation
+           so far into a refined brief)
+        -> brainstorm-exit (exit-gate: condition on the ask-user's answer
+           containing an approval phrase)
+             outcome:exit     -> plan (rejoins the unmodified coding spine)
+             outcome:continue -> brainstorm-ask (rework edge; the ask-user node
+                                 carries config.reworkRegion:true so this is a
+                                 legal top-level rework-region head per the U6
+                                 convention validateWorkflowIr enforces)
+
+The reused coding spine (parse-steps/foreach/step-review, optional
+browser-verification/code-review groups, completion-summary,
+post-merge-verification, and the full merge-primitive region) is left byte-for-byte
+identical to `builtin:coding`'s graph, so every parity invariant that graph
+already satisfies carries over unchanged; only the three new brainstorm nodes
+and their four edges are new surface for the parity suite to cover.
+*/
+
+const APPROVAL_PHRASE = "looks good";
+
+const RAW_BUILTIN_BRAINSTORMING_WORKFLOW_IR: WorkflowIr = (() => {
+  const ir = JSON.parse(JSON.stringify(BUILTIN_STEPWISE_FINAL_REVIEW_CODING_WORKFLOW_IR)) as WorkflowIrV2;
+  ir.name = "builtin-brainstorming";
+
+  // Insert the three brainstorm nodes right after `start` (order is cosmetic —
+  // edges determine the walk — but keeping them near `start` mirrors the
+  // reading order of the graph).
+  const startIndex = ir.nodes.findIndex((node) => node.id === "start");
+  if (startIndex < 0) {
+    throw new Error("brainstorming built-in requires the cloned graph's start node");
+  }
+  const startColumn = ir.nodes[startIndex]!.column;
+  const planNode = ir.nodes.find((node) => node.id === "plan");
+  const brainstormColumn = planNode?.column ?? startColumn;
+
+  ir.nodes.splice(
+    startIndex + 1,
+    0,
+    {
+      id: "brainstorm-ask",
+      kind: "ask-user",
+      column: brainstormColumn,
+      config: {
+        question:
+          `What would you like to brainstorm? Share your idea and any constraints; reply "${APPROVAL_PHRASE}" once you're ready to move into planning.`,
+        // FNXC:WorkflowBrainstorming 2026-07-05-00:00: top-level rework-region
+        // head (U6 convention) — the loop bound the exit-gate's rework edge
+        // resets to when it targets this node.
+        reworkRegion: true,
+        maxReworkCycles: 5,
+      },
+    },
+    {
+      id: "brainstorm-refine",
+      kind: "prompt",
+      column: brainstormColumn,
+      config: {
+        seam: "planning",
+        name: "Refine brainstorm",
+        prompt:
+          "You are helping the user brainstorm before this task is planned. Read the task description and the user's latest reply. Turn the conversation so far into a short, structured refined brief: 1) the core idea/goal, 2) key constraints or requirements mentioned so far, 3) open questions still unresolved, 4) a one-line readiness assessment (ready to plan, or what's still missing). Keep it concise — this is a running scratchpad the user reviews each turn, not a final spec.",
+      },
+    },
+    {
+      id: "brainstorm-exit",
+      kind: "exit-gate",
+      column: brainstormColumn,
+      config: {
+        condition: { type: "output-contains", nodeId: "brainstorm-ask", value: APPROVAL_PHRASE },
+      },
+    },
+  );
+
+  // Rewire start -> plan through the new brainstorm loop.
+  ir.edges = ir.edges.filter((edge) => !(edge.from === "start" && edge.to === "plan"));
+  ir.edges.unshift(
+    { from: "start", to: "brainstorm-ask", condition: "success" },
+    { from: "brainstorm-ask", to: "brainstorm-refine", condition: "success" },
+    { from: "brainstorm-refine", to: "brainstorm-exit", condition: "success" },
+    { from: "brainstorm-exit", to: "plan", condition: "outcome:exit" },
+    { from: "brainstorm-exit", to: "brainstorm-ask", condition: "outcome:continue", kind: "rework" },
+  );
+
+  ir.settings = BUILTIN_WORKFLOW_SETTINGS;
+  return ir;
+})();
+
+export const BUILTIN_BRAINSTORMING_WORKFLOW_IR = parseWorkflowIr(RAW_BUILTIN_BRAINSTORMING_WORKFLOW_IR);
diff --git a/packages/core/src/builtin-workflows.ts b/packages/core/src/builtin-workflows.ts
index 1575033940..1a0cb882df 100644
--- a/packages/core/src/builtin-workflows.ts
+++ b/packages/core/src/builtin-workflows.ts
@@ -1,5 +1,6 @@
 import { BUILTIN_CODING_WORKFLOW_IR } from "./builtin-coding-workflow-ir.js";
 import { BUILTIN_CODING_IDEAS_WORKFLOW_IR } from "./builtin-coding-ideas-workflow-ir.js";
+import { BUILTIN_BRAINSTORMING_WORKFLOW_IR } from "./builtin-brainstorming-workflow-ir.js";
 import { BUILTIN_LEAD_GENERATION_WORKFLOW_IR } from "./builtin-lead-generation-workflow-ir.js";
 import { BUILTIN_MARKETING_WORKFLOW_IR } from "./builtin-marketing-workflow-ir.js";
 import { BUILTIN_PR_WORKFLOW_IR } from "./builtin-pr-workflow-ir.js";
@@ -708,6 +709,51 @@ export const BUILTIN_WORKFLOWS: WorkflowDefinition[] = [
     createdAt: BUILTIN_TS,
     updatedAt: BUILTIN_TS,
   },
+  /*
+   * FNXC:WorkflowBrainstorming 2026-07-05-00:00:
+   * FN-7584 registers a discoverable built-in for FN-7579's ask-user -> refine ->
+   * exit-gate-on-approval brainstorming composition (docs/workflow-steps.md). It
+   * clones the default Coding graph (BUILTIN_STEPWISE_FINAL_REVIEW_CODING_WORKFLOW_IR)
+   * and prepends the brainstorm loop between `start` and `plan`, so every downstream
+   * node/edge is byte-identical to `builtin:coding`. Appended LAST (after
+   * lead-generation) so it does not disturb the defaultEnabledBuiltinWorkflowIds()
+   * `.slice(0, 5)` ordering assertion in builtin-workflows.test.ts.
+   */
+  {
+    id: "builtin:brainstorming",
+    name: "Brainstorming",
+    description:
+      "Brainstorm with the user first: ask a question, refine the idea, and exit the loop on approval, then run the standard coding plan/execute/review/merge pipeline.",
+    kind: "workflow",
+    ir: BUILTIN_BRAINSTORMING_WORKFLOW_IR,
+    layout: {
+      start: { x: 60, y: 160 },
+      "brainstorm-ask": { x: 230, y: 160 },
+      "brainstorm-refine": { x: 400, y: 160 },
+      "brainstorm-exit": { x: 570, y: 160 },
+      plan: { x: 740, y: 160 },
+      "plan-review": { x: 910, y: 160 },
+      "plan-replan": { x: 910, y: 320 },
+      parse: { x: 1080, y: 160 },
+      steps: { x: 1250, y: 160 },
+      "browser-verification": { x: 1420, y: 160 },
+      "browser-verification-remediation": { x: 1420, y: 320 },
+      "code-review": { x: 1590, y: 160 },
+      "code-review-remediation": { x: 1590, y: 320 },
+      "completion-summary": { x: 1760, y: 160 },
+      "merge-gate": { x: 1930, y: 160 },
+      "branch-group-member-integration": { x: 2100, y: 80 },
+      "branch-group-promotion": { x: 2270, y: 80 },
+      "merge-attempt": { x: 2440, y: 160 },
+      "merge-retry": { x: 2610, y: 80 },
+      "recovery-router": { x: 2610, y: 240 },
+      "merge-manual-hold": { x: 2100, y: 240 },
+      "post-merge-verification": { x: 2780, y: 160 },
+      end: { x: 2950, y: 160 },
+    },
+    createdAt: BUILTIN_TS,
+    updatedAt: BUILTIN_TS,
+  },
 ];
 
 const BUILTIN_BY_ID = new Map(BUILTIN_WORKFLOWS.map((wf) => [wf.id, wf]));
diff --git a/packages/dashboard/app/components/WorkflowNodeEditor.tsx b/packages/dashboard/app/components/WorkflowNodeEditor.tsx
index c70d94b256..9dfbf10cad 100644
--- a/packages/dashboard/app/components/WorkflowNodeEditor.tsx
+++ b/packages/dashboard/app/components/WorkflowNodeEditor.tsx
@@ -4754,7 +4754,23 @@ function InnerEditor({
                         "This workflow is waiting for your input.",
                       )}
                       value={String(selectedNode.data.config?.question ?? "")}
-                      onChange={(e) => updateSelectedData({ config: { question: e.target.value } })}
+                      onChange={(e) => {
+                        const value = e.target.value;
+                        // FNXC:WorkflowAskUser 2026-07-05-02:00: validateAskUserAndExitGateNodes
+                        // rejects a PRESENT-but-empty `question` (only an ABSENT question falls
+                        // back to the engine default). Clearing the textarea back to "" must
+                        // therefore delete the key, not persist `question: ""`, or the node
+                        // silently becomes unsavable the moment an author reverts to the
+                        // documented "leave blank for the default" behavior.
+                        updateSelectedData({
+                          config: (prev) => {
+                            const next = { ...prev };
+                            if (value.trim() === "") delete next.question;
+                            else next.question = value;
+                            return next;
+                          },
+                        });
+                      }}
                     />
                   </label>
                   <p className="wf-inspector-note wf-inspector-note--info">

From a1a6b09a4f01473e7fb5997de07fb57ff38c5081 Mon Sep 17 00:00:00 2001
From: gsxdsm <gsxdsm@users.noreply.github.com>
Date: Sun, 5 Jul 2026 11:24:43 -0700
Subject: [PATCH 37/65] FN-7582: clarify oversight nudge-disabled guideline
 copy

Reword the disabled-Nudge tooltip/helper text so it no longer reads as an overseer fault, and split it into two distinct reasons.
- Add taskDetail.oversight.nudgeSuppressedTitle for the human-control-suppressed case (user-paused, done/archived, autoMerge:false human-review terminal), naming manual control as the cause
- Reword taskDetail.oversight.nudgeDisabledTitle to a reassuring periodic-poll framing for the no-observation-yet case instead of implying the overseer is idle
- Compute the shared nudgeDisabledReason once and reuse it at all four render sites (mobile menu + desktop inline title/helper) so the two copies can't drift
- Add a changeset (patch) documenting the operator-facing copy fix
- Extend TaskDetailModal.oversight-controls tests and test-helpers to cover the new suppressed-vs-disabled copy branching

Files changed:
 .changeset/fn-7582-oversight-guideline-copy.md     |  7 ++
 .../dashboard/app/components/TaskDetailModal.tsx   | 37 +++++++++--
 .../TaskDetailModal.oversight-controls.test.tsx    | 76 +++++++++++++++++++++-
 .../__tests__/TaskDetailModal.test-helpers.ts      |  7 ++
 4 files changed, 121 insertions(+), 6 deletions(-)

Fusion-Task-Id: FN-7582

Fusion-Task-Lineage: bf2ceab4-2fb0-4686-a9e1-9e015502a521

Co-authored-by: Fusion (runfusion.ai) <noreply@runfusion.ai>
---
 .../fn-7582-oversight-guideline-copy.md       |  7 ++
 .../app/components/TaskDetailModal.tsx        | 37 ++++++++-
 ...askDetailModal.oversight-controls.test.tsx | 76 ++++++++++++++++++-
 .../__tests__/TaskDetailModal.test-helpers.ts |  7 ++
 4 files changed, 121 insertions(+), 6 deletions(-)
 create mode 100644 .changeset/fn-7582-oversight-guideline-copy.md

diff --git a/.changeset/fn-7582-oversight-guideline-copy.md b/.changeset/fn-7582-oversight-guideline-copy.md
new file mode 100644
index 0000000000..4041f9f1c4
--- /dev/null
+++ b/.changeset/fn-7582-oversight-guideline-copy.md
@@ -0,0 +1,7 @@
+---
+"@runfusion/fusion": patch
+---
+
+summary: Clarify the oversight "Nudge unavailable" guideline so it no longer reads as an overseer fault.
+category: fix
+dev: TaskDetailModal oversight controls — reworded taskDetail.oversight.nudgeDisabledTitle and added taskDetail.oversight.nudgeSuppressedTitle to differentiate periodic-observation vs. manual-control states. No enablement/engine logic changed.
diff --git a/packages/dashboard/app/components/TaskDetailModal.tsx b/packages/dashboard/app/components/TaskDetailModal.tsx
index e5c612c4b0..294362fe83 100644
--- a/packages/dashboard/app/components/TaskDetailModal.tsx
+++ b/packages/dashboard/app/components/TaskDetailModal.tsx
@@ -3163,6 +3163,23 @@ export function TaskDetailContent({
   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.
+
+  FNXC:PlannerOversight 2026-07-05-00:00:
+  FN-7582: the original disabled-Nudge copy ("overseer is not actively
+  watching this task") read as a fault report — operators seeing it on a
+  healthy IN PROGRESS task assumed the overseer had broken, when the real
+  cause is benign: `pollPlannerOverseer` observes in-progress/in-review tasks
+  on a bounded ~45s poll, and `plannerOverseerState` is only populated once
+  that poll records a live observation for the current stage (FN-7531). The
+  reworded copy below differentiates two distinct disabled reasons instead of
+  one alarming message: (1) no observation yet — reassuring, periodic-poll
+  framing (`nudgeDisabledTitle`); (2) human-control suppressed — user-paused,
+  done/archived, or the `autoMerge:false` in-review human-review terminal —
+  which gets its own distinct copy (`nudgeSuppressedTitle`) naming manual
+  control as the reason instead of implying the overseer is idle. Neither
+  `canNudgeOverseer` nor any other enablement/gating boolean changed; this is
+  copy-only, selected via the already-computed `overseerHumanControlSuppressed`
+  / `overseerActive` booleans below.
   */
   const overseerSnapshot = task.plannerOverseerState ?? null;
   const overseerActive = Boolean(overseerSnapshot);
@@ -3173,6 +3190,18 @@ export function TaskDetailContent({
   const canNudgeOverseer = overseerActive && !oversightIsOff && !overseerHumanControlSuppressed;
   const canExplainOverseer = overseerActive && !oversightIsOff;
   const showStopOverseer = !oversightIsOff;
+  /*
+  FNXC:PlannerOversight 2026-07-05-00:00:
+  FN-7582 shared disabled-reason string, computed once and reused at all four
+  render sites (mobile menu title + helper, desktop inline title + helper) so
+  the two copies can never drift out of sync. Picks the human-control-suppressed
+  copy when suppression is the active cause even though `!overseerActive` may
+  also be true in that state (e.g. a paused task that never got observed) —
+  suppression is the more actionable/accurate explanation for the operator.
+  */
+  const nudgeDisabledReason = overseerHumanControlSuppressed
+    ? t("taskDetail.oversight.nudgeSuppressedTitle", "Nudge is paused while this task is under manual control.")
+    : t("taskDetail.oversight.nudgeDisabledTitle", "Nudge becomes available once the overseer is observing this task's current stage — it checks periodically.");
   const isActivityExpanded = activityExpanded && activeTab === "chat" && !isEditing;
   const isPlannerChatExpanded = plannerChatExpanded && activeTab === "planner-chat" && !isEditing;
   /*
@@ -4006,7 +4035,7 @@ export function TaskDetailContent({
                                 }}
                                 onKeyDown={handleOversightMenuKeyDown}
                                 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")}
+                                title={canNudgeOverseer ? t("taskDetail.oversight.nudgeTitle", "Inject steering guidance into the current stage now") : nudgeDisabledReason}
                                 aria-label={t("taskDetail.oversight.nudgeAriaLabel", "Manual nudge")}
                               >
                                 {isNudgingOverseer ? <Loader2 className="spin" aria-hidden="true" /> : <Send aria-hidden="true" />}
@@ -4015,7 +4044,7 @@ export function TaskDetailContent({
                             )}
                             {!oversightIsOff && !canNudgeOverseer && (
                               <span className="detail-oversight-controls-helper" data-testid="detail-overseer-nudge-disabled-reason">
-                                {t("taskDetail.oversight.nudgeDisabledTitle", "Nudge unavailable: overseer is not actively watching this task")}
+                                {nudgeDisabledReason}
                               </span>
                             )}
                             {showStopOverseer && (
@@ -4126,7 +4155,7 @@ export function TaskDetailContent({
                             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")}
+                          title={canNudgeOverseer ? t("taskDetail.oversight.nudgeTitle", "Inject steering guidance into the current stage now") : nudgeDisabledReason}
                           aria-label={t("taskDetail.oversight.nudgeAriaLabel", "Manual nudge")}
                         >
                           {isNudgingOverseer ? <Loader2 className="spin" aria-hidden="true" /> : <Send aria-hidden="true" />}
@@ -4135,7 +4164,7 @@ export function TaskDetailContent({
                       )}
                       {(hasTaskOversightOverride || workflowOversightResolved) && !oversightIsOff && !canNudgeOverseer && (
                         <span className="detail-oversight-controls-helper" data-testid="detail-overseer-nudge-disabled-reason">
-                          {t("taskDetail.oversight.nudgeDisabledTitle", "Nudge unavailable: overseer is not actively watching this task")}
+                          {nudgeDisabledReason}
                         </span>
                       )}
                       {(hasTaskOversightOverride || workflowOversightResolved) && showStopOverseer && (
diff --git a/packages/dashboard/app/components/__tests__/TaskDetailModal.oversight-controls.test.tsx b/packages/dashboard/app/components/__tests__/TaskDetailModal.oversight-controls.test.tsx
index f403fbfb7b..768ed722a7 100644
--- a/packages/dashboard/app/components/__tests__/TaskDetailModal.oversight-controls.test.tsx
+++ b/packages/dashboard/app/components/__tests__/TaskDetailModal.oversight-controls.test.tsx
@@ -140,7 +140,7 @@ describe("TaskDetailModal oversight controls", () => {
     expect(nudgeBtn).toBeDisabled();
   });
 
-  it("shows a visible group label and an in-DOM disabled-reason helper (not just a hover title) when Nudge is unavailable (FN-7546)", async () => {
+  it("shows a visible group label and an in-DOM disabled-reason helper (not just a hover title) when Nudge is unavailable (FN-7546, reworded copy FN-7582)", async () => {
     render(
       <TaskDetailModal
         task={makeTask({ id: "FN-111", column: "todo", plannerOversightLevel: "autonomous" })}
@@ -159,8 +159,57 @@ describe("TaskDetailModal oversight controls", () => {
     const nudgeBtn = await screen.findByTestId("detail-overseer-nudge");
     expect(nudgeBtn).toBeDisabled();
 
+    // FN-7582: the old copy ("Nudge unavailable: overseer is not actively
+    // watching this task") read as a fault report. The reworded copy must
+    // frame the no-observation state as periodic/benign instead.
     const reason = await screen.findByTestId("detail-overseer-nudge-disabled-reason");
-    expect(reason).toHaveTextContent("Nudge unavailable: overseer is not actively watching this task");
+    expect(reason).not.toHaveTextContent("not actively watching this task");
+    expect(reason).toHaveTextContent("Nudge becomes available once the overseer is observing this task's current stage");
+    expect(nudgeBtn).toHaveAttribute("title", expect.stringContaining("Nudge becomes available once the overseer is observing this task's current stage"));
+  });
+
+  it("desktop: shows the periodic-observation copy (not the old alarming phrase) for an in-progress task with no plannerOverseerState (FN-7582)", async () => {
+    render(
+      <TaskDetailModal
+        task={makeTask({ id: "FN-116", column: "in-progress", 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();
+
+    const reason = await screen.findByTestId("detail-overseer-nudge-disabled-reason");
+    expect(reason).not.toHaveTextContent("not actively watching this task");
+    expect(reason).toHaveTextContent("Nudge becomes available once the overseer is observing this task's current stage");
+    expect(nudgeBtn).toHaveAttribute("title", expect.stringContaining("Nudge becomes available once the overseer is observing this task's current stage"));
+  });
+
+  it("desktop: shows the human-control-suppressed copy (not the periodic-observation copy) when the task is user-paused (FN-7582)", async () => {
+    render(
+      <TaskDetailModal
+        task={makeTask({ id: "FN-117", 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();
+
+    const reason = await screen.findByTestId("detail-overseer-nudge-disabled-reason");
+    expect(reason).toHaveTextContent("Nudge is paused while this task is under manual control.");
+    expect(reason).not.toHaveTextContent("Nudge becomes available once the overseer is observing this task's current stage");
+    expect(nudgeBtn).toHaveAttribute("title", expect.stringContaining("Nudge is paused while this task is under manual control."));
   });
 
   it("does not show the disabled-reason helper when Nudge is enabled", async () => {
@@ -453,6 +502,29 @@ describe("TaskDetailModal oversight controls — mobile breakpoint (FN-7521, FN-
     expect(await screen.findByTestId("detail-overseer-explain")).toBeTruthy();
   });
 
+  it("still shows the reworded periodic-observation copy (not the old alarming phrase) behind the mobile overflow menu (FN-7582)", async () => {
+    render(
+      <TaskDetailModal
+        task={makeTask({ id: "FN-216", column: "in-progress", plannerOversightLevel: "autonomous" })}
+        onClose={noop}
+        onMoveTask={noopMove}
+        onDeleteTask={noopDelete}
+        onMergeTask={noopMerge}
+        onOpenDetail={noopOpenDetail}
+        addToast={noop}
+      />,
+    );
+
+    await openOversightMenu();
+
+    const nudgeBtn = await screen.findByTestId("detail-overseer-nudge");
+    expect(nudgeBtn).toBeDisabled();
+
+    const reason = await screen.findByTestId("detail-overseer-nudge-disabled-reason");
+    expect(reason).not.toHaveTextContent("not actively watching this task");
+    expect(reason).toHaveTextContent("Nudge becomes available once the overseer is observing this task's current stage");
+  });
+
   it("still renders no oversight-control leftover shell behind the mobile overflow menu for the off+inactive default case", async () => {
     render(
       <TaskDetailModal
diff --git a/packages/dashboard/app/components/__tests__/TaskDetailModal.test-helpers.ts b/packages/dashboard/app/components/__tests__/TaskDetailModal.test-helpers.ts
index 689383d5b4..b635107f80 100644
--- a/packages/dashboard/app/components/__tests__/TaskDetailModal.test-helpers.ts
+++ b/packages/dashboard/app/components/__tests__/TaskDetailModal.test-helpers.ts
@@ -130,6 +130,13 @@ vi.mock("lucide-react", () => ({
   Bell: () => null,
   // FNXC:PlannerOversight 2026-07-04-19:00: FN-7545 mobile oversight overflow-menu trigger icon.
   MoreVertical: (props: any) => React.createElement("svg", { "data-testid": "more-vertical-icon", ...props }),
+  // FNXC:Test 2026-07-05-11:20: FN-7579 added "ask-user"/"exit-gate" workflow node types to
+  // WorkflowNodeTypes.tsx (HelpCircle, DoorOpen), which WorkflowNodeEditor/WorkflowResultsTab
+  // import transitively behind TaskDetailModal's lazy workflow surfaces. The explicit mock list
+  // omitted them, breaking every TaskDetailModal suite at import (pre-existing gap, unrelated to
+  // FN-7582's copy change) — keep this list in sync with the node-editor icon set.
+  HelpCircle: () => null,
+  DoorOpen: () => null,
 }));
 
 vi.mock("../../hooks/useAgentLogs", () => ({

From 72b77bf621615cf3498033aa0e70de87b64b8cf6 Mon Sep 17 00:00:00 2001
From: gsxdsm <gsxdsm@users.noreply.github.com>
Date: Sun, 5 Jul 2026 11:27:23 -0700
Subject: [PATCH 38/65] fix(FN-7561): stop Plan Review replan loop and fix
 "can't find the plan" reviews
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The Plan Review pre-merge gate could loop a task through triage↔plan-review
indefinitely (FN-7525 ran 13+ replans overnight with no operator visibility),
and its reviewer frequently produced "no PROMPT.md found / data lives in a DB"
non-verdicts that fed the loop.

Root cause of the non-verdicts: the reviewer runs readonly with cwd set to the
task worktree, but the spec lives at project-root .fusion/tasks/<id>/PROMPT.md —
outside the worktree — so telling it to "Read PROMPT.md" had it search the wrong
tree and give up. Four fixes:

1. Inject the PROMPT.md content (via readTaskArtifact, store-backed) directly
   into the Plan Review reviewer prompt so the verdict never depends on the
   agent locating the file.
2. Self-retry a malformed reviewer response once on the primary model when no
   fallback model is configured, so a single fumbled response gets a second
   chance instead of feeding the replan loop.
3. A malformed (advisory_failure, no parsed verdict) plan-review result can
   never trigger a triage replan — it is an infra failure, not a plan defect.
4. Cap the unbounded plan-review replan default at 15 attempts; past the cap it
   emits a loud halting log entry and leaves the task for a human instead of
   looping forever. Explicit numeric operator budgets are unchanged.

Tests: cap halts at 15 / still replans at 14 / malformed never replans. Existing
Plan Review replan and malformed-verdict-gate tests still pass.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 .changeset/fn-7561-plan-review-replan-loop.md |  7 ++
 .../workflow-graph-optional-step-fix.test.ts  | 84 +++++++++++++++++++
 packages/engine/src/executor.ts               | 56 ++++++++++++-
 3 files changed, 143 insertions(+), 4 deletions(-)
 create mode 100644 .changeset/fn-7561-plan-review-replan-loop.md

diff --git a/.changeset/fn-7561-plan-review-replan-loop.md b/.changeset/fn-7561-plan-review-replan-loop.md
new file mode 100644
index 0000000000..3bae0fe9b9
--- /dev/null
+++ b/.changeset/fn-7561-plan-review-replan-loop.md
@@ -0,0 +1,7 @@
+---
+"@runfusion/fusion": patch
+---
+
+summary: Stop Plan Review from looping tasks forever and fix its "can't find the plan" reviews.
+category: fix
+dev: FN-7561 — Plan Review pre-merge gate hardening in packages/engine/src/executor.ts. (1) The reviewer ran readonly with cwd=worktree but the spec lives at project-root .fusion/tasks/<id>/PROMPT.md, so "Read PROMPT.md" produced "no PROMPT.md found / data is in a DB" non-verdicts; the spec text is now injected into the reviewer prompt via readTaskArtifact. (2) A malformed reviewer response now self-retries once on the primary model when no fallback is configured. (3) A malformed (advisory_failure, no verdict) plan-review result can never trigger a triage replan. (4) The unbounded plan-review replan default is capped at 15 attempts with a loud halting log entry, so a persistently-disagreeing planner/reviewer no longer burns LLM calls indefinitely (FN-7525 ran 13+ attempts overnight).
diff --git a/packages/engine/src/__tests__/workflow-graph-optional-step-fix.test.ts b/packages/engine/src/__tests__/workflow-graph-optional-step-fix.test.ts
index f6ad486d13..457db672e3 100644
--- a/packages/engine/src/__tests__/workflow-graph-optional-step-fix.test.ts
+++ b/packages/engine/src/__tests__/workflow-graph-optional-step-fix.test.ts
@@ -219,6 +219,90 @@ describe("TaskExecutor pre-merge optional-step fix seam", () => {
     expect(cappedStore.moveTask).not.toHaveBeenCalled();
   });
 
+  /*
+   * FN-7561: the unbounded Plan Review replan default must still stop at a finite
+   * safety ceiling. Below the cap it keeps replanning; at the cap it halts with a
+   * loud log entry and leaves the task for a human instead of looping forever
+   * (FN-7525 ran 13+ attempts overnight with no operator visibility).
+   */
+  it("keeps replanning an unbounded Plan Review loop just below the safety cap", async () => {
+    const store = createMockStore();
+    const belowLog = Array.from({ length: 14 }, (_, i) => revisionLog("Plan Review", "plan-review", i + 1));
+    const loopingTask = task({ postReviewFixCount: 14, column: "in-progress", log: belowLog });
+    store.getTask.mockResolvedValue(loopingTask);
+    store.getSettings.mockResolvedValue({ maxPostReviewFixes: 9 }); // no planReviewMaxRevisions → unbounded
+    const executor = new TaskExecutor(store, "/tmp/test");
+
+    await expect((executor as any).requestPreMergeOptionalStepFix(loopingTask.id, loopingTask, {
+      stepName: "Plan Review",
+      feedback: "one more disagreement",
+      phase: "pre-merge" as const,
+      status: "failed" as const,
+      verdict: "REVISE",
+      nodeId: "plan-review",
+      maxRevisions: "unbounded",
+    })).resolves.toBe(true);
+
+    expect(store.moveTask).toHaveBeenCalledWith("FN-7066", "triage");
+    expect(store.logEntry).toHaveBeenCalledWith(
+      "FN-7066",
+      "Plan Review failed — moved to triage for automatic replan (attempt 15/unbounded)",
+      expect.anything(),
+      undefined,
+    );
+  });
+
+  it("halts the unbounded Plan Review replan loop at the safety cap and leaves the task for a human", async () => {
+    const store = createMockStore();
+    const cappedLog = Array.from({ length: 15 }, (_, i) => revisionLog("Plan Review", "plan-review", i + 1));
+    const loopingTask = task({ postReviewFixCount: 15, column: "in-progress", log: cappedLog });
+    store.getTask.mockResolvedValue(loopingTask);
+    store.getSettings.mockResolvedValue({ maxPostReviewFixes: 9 }); // unbounded default
+    const executor = new TaskExecutor(store, "/tmp/test");
+
+    await expect((executor as any).requestPreMergeOptionalStepFix(loopingTask.id, loopingTask, {
+      stepName: "Plan Review",
+      feedback: "still disagreeing after fifteen tries",
+      phase: "pre-merge" as const,
+      status: "failed" as const,
+      verdict: "REVISE",
+      nodeId: "plan-review",
+      maxRevisions: "unbounded",
+    })).resolves.toBe(false);
+
+    // Halted: no replan side effects.
+    expect(store.moveTask).not.toHaveBeenCalled();
+    expect(store.updateTask).not.toHaveBeenCalledWith("FN-7066", { postReviewFixCount: 16 }, undefined);
+    // Loud, human-visible halt log.
+    expect(store.logEntry).toHaveBeenCalledWith(
+      "FN-7066",
+      expect.stringContaining("Plan Review replan safety cap reached (15/15)"),
+      expect.stringContaining("still disagreeing after fifteen tries"),
+      undefined,
+    );
+  });
+
+  it("does not replan a malformed (advisory_failure, no verdict) Plan Review result", async () => {
+    // FN-7561 invariant: a malformed reviewer response (no parseable verdict) is an
+    // infra/formatting failure, not a plan defect, and must never bounce the task to triage.
+    const store = createMockStore();
+    const liveTask = task({ column: "in-progress" });
+    store.getTask.mockResolvedValue(liveTask);
+    store.getSettings.mockResolvedValue({ maxPostReviewFixes: 3 });
+    const executor = new TaskExecutor(store, "/tmp/test");
+
+    await expect((executor as any).requestPreMergeOptionalStepFix(liveTask.id, liveTask, {
+      stepName: "Plan Review",
+      feedback: "unparseable reviewer output",
+      phase: "pre-merge" as const,
+      status: "advisory_failure" as const,
+      verdict: undefined,
+      nodeId: "plan-review",
+    })).resolves.toBe(false);
+
+    expect(store.moveTask).not.toHaveBeenCalled();
+  });
+
   it("clears stale pause-abort provenance silently before a fresh unpaused execution dispatch", async () => {
     const store = createMockStore();
     const liveTask = task({ column: "todo", paused: false, userPaused: false });
diff --git a/packages/engine/src/executor.ts b/packages/engine/src/executor.ts
index b63cb3cdb2..bc69e6bcb6 100644
--- a/packages/engine/src/executor.ts
+++ b/packages/engine/src/executor.ts
@@ -4209,6 +4209,11 @@ export class TaskExecutor {
     const liveTask = await this.store.getTask(taskId).catch(() => fallbackTask);
     const isPlanReview = info.nodeId === "plan-review" || info.stepName === "Plan Review";
     if (isPlanReview) {
+      /*
+       * FNXC:PlanReviewReplan 2026-07-05-17:32:
+       * FN-7561: a malformed reviewer response arrives as `advisory_failure` with NO parsed verdict. That is an infra/formatting failure (e.g. the reviewer could not locate the spec, or fumbled its trailing JSON), not a plan defect — it must NEVER bounce the task to a triage replan. The graph already excludes malformed advisories from the fix handoff (shouldRequestPreMergeFix); this guard defends the explicit remediation-node path and any future caller so a malformed advisory can never drive the replan loop. A genuine REVISE (verdict === "REVISE", also carried as advisory_failure) still replans below.
+       */
+      if (info.status === "advisory_failure" && info.verdict !== "REVISE") return false;
       if (info.verdict !== undefined && info.verdict !== "REVISE") return false;
       /*
        * FNXC:PlanReviewReplan 2026-06-29-00:41:
@@ -4231,6 +4236,21 @@ export class TaskExecutor {
       const revisionKey = optionalStepRevisionKey(info.nodeId ?? "plan-review", info.stepName);
       const currentCount = countOptionalStepRevisionAttempts(liveTask, revisionKey, info.stepName);
       if (!budget.unbounded && currentCount >= budget.max) return false;
+      /*
+       * FNXC:PlanReviewReplanCap 2026-07-05-17:28:
+       * FN-7561: an unset Plan Review revision budget resolves to "unbounded" (see FNXC:WorkflowRevisionBudget above), which by design skips the ceiling check — so a task whose planner and reviewer persistently disagree, or whose reviewer keeps hard-failing, replans triage↔plan-review forever, silently burning a triage + review LLM call every cycle (FN-7525 ran 13+ attempts overnight with zero operator visibility). Enforce a finite safety ceiling even when unbounded: once hit, emit a loud halting log entry and STOP replanning (return false) so the gate falls through to a visible failed/parked state a human can act on, instead of looping indefinitely. Explicit numeric operator budgets are still honored as-is above; this only backstops the unbounded DEFAULT.
+       */
+      const PLAN_REVIEW_REPLAN_HARD_CAP = 15;
+      if (budget.unbounded && currentCount >= PLAN_REVIEW_REPLAN_HARD_CAP) {
+        await this.store.logEntry(
+          taskId,
+          `Plan Review replan safety cap reached (${currentCount}/${PLAN_REVIEW_REPLAN_HARD_CAP}) — halting automatic replan and leaving the task for human review`,
+          `Plan Review requested another planning revision but the unbounded replan loop hit its safety ceiling of ${PLAN_REVIEW_REPLAN_HARD_CAP} attempts. This usually means the reviewer and planner disagree persistently, or the reviewer keeps failing to produce a verdict. The task is being left in place for a human to inspect rather than looping further. Latest feedback:\n${feedback}`,
+          this.getRunContextFor(taskId),
+        );
+        executorLog.warn(`${taskId}: Plan Review replan safety cap (${PLAN_REVIEW_REPLAN_HARD_CAP}) reached after ${currentCount} attempts — halting automatic replan`);
+        return false;
+      }
       const nextCount = currentCount + 1;
       const totalFixCount = (liveTask.postReviewFixCount ?? 0) + 1;
       const budgetLabel = budget.unbounded ? "unbounded" : String(budget.max);
@@ -14546,14 +14566,22 @@ ${scopeGuard}
     const requireExternalIntegrationEvidence =
       workflowStepMetadata.requireExternalIntegrationEvidence === true;
 
+    /*
+     * FNXC:PlanReviewSpecInjection 2026-07-05-17:20:
+     * FN-7561: the Plan Review reviewer runs readonly with cwd=worktree, but the spec artifact lives at the project root under `.fusion/tasks/<id>/PROMPT.md` — OUTSIDE the task worktree. Instructing the agent to "Read PROMPT.md" therefore had it search the worktree, fail to find the file, and emit "no PROMPT.md file was found / task data lives in a DB" prose instead of a parseable verdict. That malformed/hard-failed output fed the unbounded triage↔plan-review replan loop (FN-7525 looped 13+ times overnight; FN-7575 too). Load the spec text from the store (document layer → on-disk PROMPT.md) ONCE and inject it directly into the reviewer prompt so the verdict never depends on the agent locating the file. Read from the store, not fs, so it is correct regardless of worktree vs project-root layout.
+     */
+    const planReviewSpecArtifact = isPlanReviewStep
+      ? await this.readTaskArtifact(task.id, "PROMPT.md")
+      : undefined;
+    const planReviewSpecText = typeof planReviewSpecArtifact === "string" ? planReviewSpecArtifact : "";
+
     if (isPlanReviewStep && requireExternalIntegrationEvidence) {
       /*
        * FNXC:PlanValidation 2026-06-30-09:03:
        * Coding (per-step review) intentionally keeps external-integration evidence as a Plan Review gate. Enforce it here, not in triage, so only workflows that set `requireExternalIntegrationEvidence` block and failures route through the graph's normal plan-replan loop.
        */
-      const promptContent = await this.readTaskArtifact(task.id, "PROMPT.md");
       const evidenceGaps = detectExternalIntegrationEvidenceGaps({
-        promptContent: typeof promptContent === "string" ? promptContent : "",
+        promptContent: planReviewSpecText,
       });
       if (evidenceGaps.length > 0) {
         const diagnostic = formatExternalIntegrationEvidenceDiagnostic(evidenceGaps);
@@ -14608,9 +14636,14 @@ ${scopeGuard}
      */
     const scopeBlock = isPlanReviewStep
       ? `Plan Review Scope:
-- Review the task plan artifact (PROMPT.md) and task metadata only.
+- Review the task plan artifact (PROMPT.md), reproduced verbatim below, and task metadata only.
+- The plan is embedded in this prompt — do NOT go looking for a PROMPT.md file in the worktree; it lives at the project root (\`.fusion/tasks/${task.id}/PROMPT.md\`), outside this worktree, so review the embedded copy.
 - Do NOT judge current implementation diffs, uncommitted worktree changes, or unrelated repository changes.
-- If PROMPT.md is internally consistent, complete, scoped, and verifiable, approve even when the worktree contains unrelated changes from another task.`
+- If the plan is internally consistent, complete, scoped, and verifiable, approve even when the worktree contains unrelated changes from another task.
+
+--- BEGIN PROMPT.md ---
+${planReviewSpecText || `(The plan artifact could not be loaded into this prompt. Read it read-only from the project root at .fusion/tasks/${task.id}/PROMPT.md before judging; do not treat an unavailable artifact as a plan defect.)`}
+--- END PROMPT.md ---`
       : `Diff Scope (files changed by THIS task vs base):
 ${scopeFileBlock}${diffShortstat ? `\nDiff stat: ${diffShortstat}` : ""}
 
@@ -15067,6 +15100,21 @@ You have access to the file system to review changes.${inlineFixBlock}${verdictB
     if (!primaryOutcome.timedOut && !primaryMalformed) return primaryOutcome;
 
     if (!fallback) {
+      /*
+       * FNXC:ReviewLeniency 2026-07-05-17:24:
+       * FN-7561: when NO fallback model is configured, a MALFORMED primary (unparseable verdict — a single fumbled response) still deserves one retry so a transient formatting fumble does not feed the plan-review replan loop. Self-retry once on the SAME primary model. Timeouts are NOT self-retried — they would likely just time out again and burn another full budget. If the self-retry is still malformed it is returned as a non-blocking advisory downstream.
+       */
+      if (primaryMalformed && !primaryOutcome.timedOut) {
+        executorLog.log(`${task.id}: workflow step '${workflowStep.name}' produced malformed output and no fallback is configured — retrying once on the primary model`);
+        const retryOutcome = await runOnce(primaryProvider, primaryModelId, "primary-retry");
+        const retryMalformed = (retryOutcome as { malformed?: boolean }).malformed === true;
+        if (!retryMalformed) return retryOutcome;
+        await this.store.logEntry(
+          task.id,
+          `Workflow step '${workflowStep.name}' produced malformed output on both the primary attempt and one self-retry — no fallback model configured (set settings.validatorFallbackProvider/Id or fallbackProvider/Id)`,
+        );
+        return retryOutcome;
+      }
       const reason = primaryOutcome.timedOut ? "timed out" : "produced malformed output";
       executorLog.warn(`${task.id}: workflow step '${workflowStep.name}' ${reason} and no fallback model is configured`);
       await this.store.logEntry(

From 15c2c831a85575f04a210282ee308615abb9b80d Mon Sep 17 00:00:00 2001
From: fusion-merge-train <merge-train@topkoli.local>
Date: Sun, 5 Jul 2026 20:41:20 +0200
Subject: [PATCH 39/65] fix(engine): self-heal failed in-review cards whose PR
 merged on the remote
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

A transient error at merge time can flag an in-review card `failed` even
when its PR actually squash-merged on the remote. `recoverAlreadyMergedReviewTasks`
only ran the already-merged evidence detector against the LOCAL base ref, so
when this process never fetched the merge, the owned commit was absent locally,
the detector returned null, and the card held its file-scope lease forever.

Fetch-then-prove: when a failed candidate has a recorded PR and the local base
yields no owned commit, best-effort `git fetch origin <base>` and re-run the
SAME evidence detector against `origin/<base>`. The owned-commit proof and every
foreign-ownership guard inside the detector remain the sole finalize gate, so
this only un-wedges a genuinely-merged task — it never phantom-finalizes on
unproven state. Gated on a recorded PR (no PR ⇒ nothing merged remotely ⇒ no
fetch); fail-closed on fetch error.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 ...lf-healing-already-merged.real-git.test.ts | 103 ++++++++++++++++++
 packages/engine/src/self-healing.ts           |  58 +++++++++-
 2 files changed, 160 insertions(+), 1 deletion(-)

diff --git a/packages/engine/src/__tests__/self-healing-already-merged.real-git.test.ts b/packages/engine/src/__tests__/self-healing-already-merged.real-git.test.ts
index e2adf0f508..7b40393100 100644
--- a/packages/engine/src/__tests__/self-healing-already-merged.real-git.test.ts
+++ b/packages/engine/src/__tests__/self-healing-already-merged.real-git.test.ts
@@ -467,4 +467,107 @@ describeIfGit("SelfHealingManager recoverAlreadyMergedReviewTasks (real git)", (
     await enginePausedManager.recoverAlreadyMergedReviewTasks();
     expect(enginePausedStore.listTasks).not.toHaveBeenCalled();
   }, 20_000);
+
+  // PR3: the local base ref can be stale. When a PR squash-merged on the remote
+  // but this process never fetched, the owned commit is absent from the LOCAL
+  // base branch, so the detector finds nothing and the failed card holds its
+  // file-scope lease forever. Recovery now fetches origin/<base> (gated on a
+  // recorded PR) and re-runs the SAME evidence detector against origin/<base>.
+  function setupRepoWithRemote(): { repo: string; remote: string } {
+    const remoteParent = mkdtempSync(path.join(os.tmpdir(), "fn-stale-remote-"));
+    repos.push(remoteParent);
+    const remote = path.join(remoteParent, "origin.git");
+    execSync(`git init --bare -b main ${JSON.stringify(remote)}`, { stdio: ["pipe", "pipe", "pipe"] });
+    const repo = setupRepo();
+    git(repo, `git remote add origin ${JSON.stringify(remote)}`);
+    git(repo, "git push origin main");
+    return { repo, remote };
+  }
+
+  // Clone the bare remote, run `mutate` in it, push main back. Advances the
+  // remote's main WITHOUT touching the primary repo's local main / origin/main
+  // tracking ref — i.e. it manufactures a genuinely stale local base.
+  function landOnRemoteMain(remote: string, mutate: (clone: string) => void): string {
+    const cloneParent = mkdtempSync(path.join(os.tmpdir(), "fn-stale-clone-"));
+    repos.push(cloneParent);
+    const clone = path.join(cloneParent, "clone");
+    execSync(`git clone ${JSON.stringify(remote)} ${JSON.stringify(clone)}`, { stdio: ["pipe", "pipe", "pipe"] });
+    git(clone, 'git config user.email "test@example.com"');
+    git(clone, 'git config user.name "Test"');
+    mutate(clone);
+    git(clone, "git push origin main");
+    return git(clone, "git rev-parse HEAD");
+  }
+
+  it("fetch-then-prove: finalizes a failed card whose PR merged on the remote (stale local base)", async () => {
+    const { repo, remote } = setupRepoWithRemote();
+
+    // Task branch tip lives locally (owned by nothing foreign).
+    git(repo, "git checkout -b fusion/fn-stale");
+    mkdirSync(path.join(repo, "src"), { recursive: true });
+    writeFileSync(path.join(repo, "src", "stale.txt"), "work\n", "utf-8");
+    git(repo, "git add src/stale.txt && git commit -m 'task work'");
+    git(repo, "git checkout main");
+
+    const worktreePath = path.join(repo, ".worktrees", "fn-stale");
+    mkdirSync(path.dirname(worktreePath), { recursive: true });
+    git(repo, `git worktree add ${JSON.stringify(worktreePath)} fusion/fn-stale`);
+
+    // Simulate the merge-train squash landing on the remote — never fetched locally.
+    const landedSha = landOnRemoteMain(remote, (clone) => {
+      git(clone, "git commit --allow-empty -m 'feat: landed' -m 'Fusion-Task-Id: FN-STALE'");
+    });
+
+    // Local base is stale: neither main nor origin/main has the owned commit yet.
+    expect(git(repo, "git rev-parse origin/main")).not.toBe(landedSha);
+
+    const tasks: TaskMap = new Map([
+      ["FN-STALE", makeTask({ id: "FN-STALE", column: "in-review", status: "failed", mergeRetries: 3, paused: false, baseBranch: "main", branch: "fusion/fn-stale", worktree: worktreePath, prInfo: { number: 77 } as any })],
+    ]);
+    const store = createStore(tasks);
+    const manager = new SelfHealingManager(store, { rootDir: repo, getExecutingTaskIds: () => new Set() });
+
+    await (manager as any).recoverAlreadyMergedReviewTasks();
+
+    // Fetch advanced origin/main, and the detector proved the owned commit against it.
+    expect(git(repo, "git rev-parse origin/main")).toBe(landedSha);
+    const task = tasks.get("FN-STALE")!;
+    expect(task.column).toBe("done");
+    expect(task.status).toBeNull();
+    expect(task.mergeRetries).toBe(0);
+    expect(task.mergeDetails?.commitSha).toBe(landedSha);
+    expect(task.mergeDetails?.mergeConfirmed).toBe(true);
+    expect(existsSync(worktreePath)).toBe(false);
+  }, 30_000);
+
+  it("fetch-then-prove: does NOT heal when the remote base carries only a foreign commit", async () => {
+    const { repo, remote } = setupRepoWithRemote();
+
+    git(repo, "git checkout -b fusion/fn-guard");
+    mkdirSync(path.join(repo, "src"), { recursive: true });
+    writeFileSync(path.join(repo, "src", "guard.txt"), "work\n", "utf-8");
+    git(repo, "git add src/guard.txt && git commit -m 'task work'");
+    git(repo, "git checkout main");
+
+    // Remote base advances, but the landed commit is owned by a DIFFERENT task.
+    const foreignSha = landOnRemoteMain(remote, (clone) => {
+      git(clone, "git commit --allow-empty -m 'feat: other' -m 'Fusion-Task-Id: FN-OTHER'");
+    });
+
+    const tasks: TaskMap = new Map([
+      ["FN-GUARD", makeTask({ id: "FN-GUARD", column: "in-review", status: "failed", mergeRetries: 3, paused: false, baseBranch: "main", branch: "fusion/fn-guard", prInfo: { number: 88 } as any })],
+    ]);
+    const store = createStore(tasks);
+    const manager = new SelfHealingManager(store, { rootDir: repo, getExecutingTaskIds: () => new Set() });
+
+    await (manager as any).recoverAlreadyMergedReviewTasks();
+
+    // The fetch still ran (proves the guard, not a missing fetch), but no owned
+    // commit exists → the card is left untouched, never phantom-finalized.
+    expect(git(repo, "git rev-parse origin/main")).toBe(foreignSha);
+    const task = tasks.get("FN-GUARD")!;
+    expect(task.column).toBe("in-review");
+    expect(task.status).toBe("failed");
+    expect(task.mergeDetails?.mergeConfirmed).not.toBe(true);
+  }, 30_000);
 });
diff --git a/packages/engine/src/self-healing.ts b/packages/engine/src/self-healing.ts
index b4a1c7e423..5519255135 100644
--- a/packages/engine/src/self-healing.ts
+++ b/packages/engine/src/self-healing.ts
@@ -1970,6 +1970,39 @@ export class SelfHealingManager {
     return findAlreadyMergedTaskCommit(input);
   }
 
+  /**
+   * Best-effort refresh of the remote-tracking base ref so the already-merged
+   * evidence detector can see a squash that landed on the remote after this
+   * process last fetched. Returns the `origin/<base>` ref to re-run the detector
+   * against, or null when there is nothing fresher to prove against.
+   *
+   * Fail-closed: a fetch error (offline / auth / no remote) is swallowed and we
+   * still attempt to resolve the (possibly stale) remote-tracking ref; if even
+   * that is absent we return null and the caller leaves the card untouched.
+   */
+  private async refreshRemoteBaseRef(baseBranch: string): Promise<string | null> {
+    // Already a remote ref — nothing local to refresh.
+    if (baseBranch.startsWith("origin/")) return null;
+    const remoteRef = `origin/${baseBranch}`;
+    try {
+      await execAsync(`git fetch origin ${shellQuote(baseBranch)}`, {
+        cwd: this.options.rootDir,
+        timeout: 60_000,
+      });
+    } catch {
+      // Swallow: fall through to the existing remote-tracking ref if present.
+    }
+    try {
+      await execAsync(`git rev-parse --verify ${shellQuote(remoteRef)}`, {
+        cwd: this.options.rootDir,
+        timeout: 30_000,
+      });
+      return remoteRef;
+    } catch {
+      return null;
+    }
+  }
+
   private async readCommitTaskOwnership(sha: string, taskId: string, lineageId?: string) {
     const { stdout } = await execAsync(`git show -s --format=%s%x1f%b ${shellQuote(sha)}`, {
       cwd: this.options.rootDir,
@@ -8635,7 +8668,7 @@ export class SelfHealingManager {
             }
           }
 
-          const landed = await this.findAlreadyMergedTaskCommit({
+          let landed = await this.findAlreadyMergedTaskCommit({
             taskId: task.id,
             lineageId: task.lineageId,
             repoDir: this.options.rootDir,
@@ -8643,6 +8676,29 @@ export class SelfHealingManager {
             taskBranch: task.branch,
             baseCommitSha: task.baseCommitSha,
           });
+          if (!landed && getPrimaryPrInfo(task)) {
+            // Fetch-then-prove: the LOCAL base ref can be stale. When a PR merged
+            // on the remote (human / merge-train squash) but this process never
+            // fetched, the owned commit is absent from the local base branch, so
+            // the detector finds nothing and the failed card holds its file-scope
+            // lease forever. Best-effort refresh the remote-tracking base ref and
+            // re-run the SAME evidence detector against it. The owned-commit proof
+            // (and every foreign-ownership guard inside the detector) still gates
+            // the heal, so this only un-wedges a genuinely-merged task — it never
+            // phantom-finalizes on unproven state. Gated on a recorded PR: no PR
+            // ⇒ nothing could have merged remotely ⇒ no fetch.
+            const refreshedBaseRef = await this.refreshRemoteBaseRef(baseBranch);
+            if (refreshedBaseRef) {
+              landed = await this.findAlreadyMergedTaskCommit({
+                taskId: task.id,
+                lineageId: task.lineageId,
+                repoDir: this.options.rootDir,
+                baseBranch: refreshedBaseRef,
+                taskBranch: task.branch,
+                baseCommitSha: task.baseCommitSha,
+              });
+            }
+          }
           if (!landed) continue;
 
           const mergeDetails: MergeDetails = {

From 0f1cd0a36acb1704a510a6a54ffd18200f4b2653 Mon Sep 17 00:00:00 2001
From: gsxdsm <gsxdsm@users.noreply.github.com>
Date: Sun, 5 Jul 2026 11:49:42 -0700
Subject: [PATCH 40/65] FN-7585: unify border, radius, and height across
 task-detail Priority/Execution-mode/Oversight controls

Unifies the visual styling of the task-detail modal's Priority, Execution-mode, and Oversight quick-control chips so the cluster reads as one consistent control group.

- Add a shared --detail-control-border-radius token (resolving to --radius-md) alongside the existing --detail-priority-control-min-height token
- Override .detail-priority-chip's inherited transparent border with a visible --btn-border-width/--border pairing so the "normal" priority level renders as a bordered box instead of borderless text
- Pin the same border-width/color/radius trio on .detail-execution-mode-toggle so a future change to .btn defaults can't desync the cluster
- Apply the same trio to .detail-oversight-chip, overriding .card-oversight-badge's transparent border (covers the neutral "off" tint too)
- Apply the same trio to the mobile .detail-oversight-menu-trigger swap-in so the mobile overflow-trigger variant matches the desktop chip
- Add a changeset (patch) documenting the fix for @runfusion/fusion
- Extend TaskDetailModal.responsive-and-dependencies.test.tsx coverage for the unified styling

Files changed:
 .changeset/FN-7585-unify-task-detail-quick-control-styling.md                         |  7 +++
 packages/dashboard/app/components/TaskDetailModal.css                                 | 55 ++++++++++++++++++++++
 packages/dashboard/app/components/__tests__/TaskDetailModal.responsive-and-dependencies.test.tsx | 27 +++++++++++
 3 files changed, 89 insertions(+)

Fusion-Task-Id: FN-7585

Fusion-Task-Lineage: 0cca8c82-c9fb-4410-af48-51861a743f96

Co-authored-by: Fusion (runfusion.ai) <noreply@runfusion.ai>
---
 ...unify-task-detail-quick-control-styling.md |  7 +++
 .../app/components/TaskDetailModal.css        | 55 +++++++++++++++++++
 ...Modal.responsive-and-dependencies.test.tsx | 27 +++++++++
 3 files changed, 89 insertions(+)
 create mode 100644 .changeset/FN-7585-unify-task-detail-quick-control-styling.md

diff --git a/.changeset/FN-7585-unify-task-detail-quick-control-styling.md b/.changeset/FN-7585-unify-task-detail-quick-control-styling.md
new file mode 100644
index 0000000000..b536ea7b2a
--- /dev/null
+++ b/.changeset/FN-7585-unify-task-detail-quick-control-styling.md
@@ -0,0 +1,7 @@
+---
+"@runfusion/fusion": patch
+---
+
+summary: Unify border, radius, and height of the task-detail Priority/Execution/Oversight controls.
+category: fix
+dev: Adds a shared --detail-control-border-radius token alongside --detail-priority-control-min-height so .detail-priority-chip, .detail-execution-mode-toggle, .detail-oversight-chip, and .detail-oversight-menu-trigger all resolve the same border-width/color/radius/height.
diff --git a/packages/dashboard/app/components/TaskDetailModal.css b/packages/dashboard/app/components/TaskDetailModal.css
index ebac44574b..d3300f17c2 100644
--- a/packages/dashboard/app/components/TaskDetailModal.css
+++ b/packages/dashboard/app/components/TaskDetailModal.css
@@ -370,8 +370,23 @@ The task-detail modal metadata must keep priority, execution mode, provenance, P
   /*
   FNXC:TaskDetail 2026-06-22-20:00:
   Priority chip and speed (execution-mode) toggle share one min-height token so they render at identical, equal height. Reduced from the old calc(space-2xl + space-xs) (~too tall) to a compact 30px that stays legible and tappable. Both controls also get trimmed vertical padding to match.
+
+  FNXC:TaskDetail 2026-07-05-00:00:
+  FN-7585 — Priority, Execution-mode, and Oversight (both the desktop chip and
+  the mobile overflow-trigger variant) previously diverged: Priority inherited
+  `.card-priority-badge`'s pill radius with a *transparent* border (so the
+  common `normal` level rendered as borderless text), while Execution-mode and
+  the Oversight mobile trigger are `.btn.btn-sm` pills with `--radius-md` and a
+      visible `--border` color. Add one shared `--detail-control-border-radius`
+  token here so all four controls resolve the same border-radius from a single
+  source; each control below also pins the same `--btn-border-width` width and
+  `--border` color so the cluster reads as one uniform control group. Only the
+  border/radius/size are unified — per-level tint backgrounds (priority
+  low/high/urgent, oversight observe/steer/autonomous/off, execution-mode
+  fast) are untouched.
   */
   --detail-priority-control-min-height: 30px;
+  --detail-control-border-radius: var(--radius-md);
 
   display: flex;
   align-items: stretch;
@@ -384,6 +399,16 @@ The task-detail modal metadata must keep priority, execution mode, provenance, P
   min-height: var(--detail-priority-control-min-height);
   padding-block: var(--space-xs);
   box-sizing: border-box;
+  /*
+  FNXC:TaskDetail 2026-07-05-00:00:
+  FN-7585 — override `.card-priority-badge`'s transparent border with a real,
+  visible border so the `normal` level (no `--low/--high/--urgent` tint) still
+  renders as a bordered box instead of borderless text, matching the
+  Execution-mode toggle and Oversight chip/trigger.
+  */
+  border-width: var(--btn-border-width);
+  border-color: var(--border);
+  border-radius: var(--detail-control-border-radius);
 }
 
 .detail-priority-chip--saving {
@@ -425,6 +450,15 @@ The task-detail modal metadata must keep priority, execution mode, provenance, P
   min-height: var(--detail-priority-control-min-height);
   padding-block: var(--space-xs);
   box-sizing: border-box;
+  /*
+  FNXC:TaskDetail 2026-07-05-00:00:
+  FN-7585 — pin the same shared border/radius token set as the Priority and
+  Oversight controls even though `.btn` already applies a border, so a future
+  change to `.btn`'s defaults cannot silently desync this cluster.
+  */
+  border-width: var(--btn-border-width);
+  border-color: var(--border);
+  border-radius: var(--detail-control-border-radius);
 }
 
 .detail-execution-mode-toggle svg {
@@ -461,12 +495,23 @@ 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.
+
+FNXC:TaskDetail 2026-07-05-00:00:
+FN-7585 — like `.detail-priority-chip`, override `.card-oversight-badge`'s
+transparent border with the shared `--btn-border-width`/`--border`/
+`--detail-control-border-radius` trio so every oversight level (including
+`--off`, which has a neutral tint) renders the same bordered box as Priority
+and Execution-mode. The mobile `.detail-oversight-menu-trigger` swap below
+gets the identical trio so both oversight variants match.
 */
 .detail-oversight-chip {
   gap: var(--space-xs);
   min-height: var(--detail-priority-control-min-height);
   padding-block: var(--space-xs);
   box-sizing: border-box;
+  border-width: var(--btn-border-width);
+  border-color: var(--border);
+  border-radius: var(--detail-control-border-radius);
 }
 
 .detail-oversight-chip--saving {
@@ -613,6 +658,16 @@ since the trigger lives in the header cluster rather than the footer, unlike
   min-height: var(--detail-priority-control-min-height);
   padding-block: var(--space-xs);
   box-sizing: border-box;
+  /*
+  FNXC:TaskDetail 2026-07-05-00:00:
+  FN-7585 — mobile swap-in for `.detail-oversight-chip` (JS `isOversightMenuMobile`
+  swap in TaskDetailModal.tsx). Pin the same shared border/radius trio so the
+  mobile overflow-trigger variant matches the desktop chip and the
+  Priority/Execution-mode controls, per the FN-7585 surface enumeration.
+  */
+  border-width: var(--btn-border-width);
+  border-color: var(--border);
+  border-radius: var(--detail-control-border-radius);
 }
 
 .detail-oversight-menu-trigger svg {
diff --git a/packages/dashboard/app/components/__tests__/TaskDetailModal.responsive-and-dependencies.test.tsx b/packages/dashboard/app/components/__tests__/TaskDetailModal.responsive-and-dependencies.test.tsx
index 5bf7f21caa..9e348aadaa 100644
--- a/packages/dashboard/app/components/__tests__/TaskDetailModal.responsive-and-dependencies.test.tsx
+++ b/packages/dashboard/app/components/__tests__/TaskDetailModal.responsive-and-dependencies.test.tsx
@@ -226,6 +226,33 @@ describe("TaskDetailModal", () => {
       expect(css).not.toMatch(/@media \(max-width: 640px\)\s*\{[^}]*\.detail-meta-inline-controls\s*\{[^}]*flex-direction:\s*column;/);
     });
 
+    it("unifies border/radius/height across the Priority, Execution-mode, and Oversight quick controls (FN-7585)", () => {
+      const css = readDashboardStylesSource();
+
+      const inlineControlsBlock = getStandaloneCssRuleBlock(css, ".detail-meta-inline-controls");
+      const priorityChipBlock = getExactCssRuleBlock(css, ".detail-priority-chip");
+      const executionToggleBlock = getExactCssRuleBlock(css, ".detail-execution-mode-toggle");
+      const oversightChipBlock = getExactCssRuleBlock(css, ".detail-oversight-chip");
+      const oversightTriggerBlock = getExactCssRuleBlock(css, ".detail-oversight-menu-trigger");
+
+      // The cluster declares one shared border-radius token; all four controls
+      // must reference it rather than four independent literal radii.
+      expect(inlineControlsBlock).toContain("--detail-control-border-radius: var(--radius-md);");
+      for (const block of [priorityChipBlock, executionToggleBlock, oversightChipBlock, oversightTriggerBlock]) {
+        expect(block).toContain("border-radius: var(--detail-control-border-radius);");
+        expect(block).toContain("border-width: var(--btn-border-width);");
+        expect(block).toContain("border-color: var(--border);");
+        // Same height token as the rest of the invariant.
+        expect(block).toContain("min-height: var(--detail-priority-control-min-height);");
+        expect(block).toContain("box-sizing: border-box;");
+      }
+
+      // Guard against regressing back to four independent literal radius values
+      // (e.g. reintroducing a bare `var(--radius-pill)` on only the chips).
+      expect(priorityChipBlock).not.toMatch(/border-radius:\s*var\(--radius-pill\)/);
+      expect(oversightChipBlock).not.toMatch(/border-radius:\s*var\(--radius-pill\)/);
+    });
+
     it("keeps grouped timestamp metadata inline on desktop and mobile", () => {
       const css = readDashboardStylesSource();
 

From aa6d21eecaa319faddd86ffe2bafe7d6f2565561 Mon Sep 17 00:00:00 2001
From: gsxdsm <gsxdsm@users.noreply.github.com>
Date: Sun, 5 Jul 2026 11:57:36 -0700
Subject: [PATCH 41/65] FN-7583: route Android back gesture through
 fusion:native-back so task detail returns to board

Fixes the Android predictive back-gesture (edge swipe) not returning from a task detail view to the board, even though the hardware/legacy Back button worked correctly.

- Patch the generated Android manifest post-sync to set android:enableOnBackInvokedCallback="true" on the <application> tag, opting into AndroidX's OnBackPressedDispatcher for predictive-back gesture completion (mitigating ionic-team/capacitor-plugins#2418 via the disableBackButtonHandler toggle shipped in @capacitor/app@7.1.0).
- Wire the patch script into Capacitor's capacitor:sync:after npm-script hook so it runs automatically after every cap sync (and therefore after cap run android / build:mobile).
- Ensure both the back gesture and the hardware Back button funnel through the same AndroidBackButtonManager backButton listener, dispatching the shared fusion:native-back event consumed by the dashboard's nav-history stack.
- Add regression coverage: a unit test for the manifest patch script's idempotent opt-in behavior, and a dashboard test asserting the task detail view returns to the board on fusion:native-back.
- Document the Android manifest patch rationale and the unchanged dashboard-side invariant in packages/mobile/README.md.

Files changed:
 .../__tests__/TaskDetail.swipe-back.test.tsx       |  13 +++
 packages/mobile/README.md                          |  31 +++++++
 packages/mobile/capacitor.config.ts                |  13 +++
 packages/mobile/package.json                       |   2 +
 packages/mobile/scripts/patch-android-manifest.ts  |  90 ++++++++++++++++++
 packages/mobile/src/__tests__/native-shell.test.ts | 102 +++++++++++++++++++++
 6 files changed, 251 insertions(+)

Fusion-Task-Id: FN-7583

Fusion-Task-Lineage: ad0cb02c-6e49-448a-8c93-607cd5ae657b

Co-authored-by: Fusion (runfusion.ai) <noreply@runfusion.ai>
---
 .../__tests__/TaskDetail.swipe-back.test.tsx  |  13 +++
 packages/mobile/README.md                     |  31 ++++++
 packages/mobile/capacitor.config.ts           |  13 +++
 packages/mobile/package.json                  |   2 +
 .../mobile/scripts/patch-android-manifest.ts  |  90 ++++++++++++++++
 .../mobile/src/__tests__/native-shell.test.ts | 102 ++++++++++++++++++
 6 files changed, 251 insertions(+)
 create mode 100644 packages/mobile/scripts/patch-android-manifest.ts

diff --git a/packages/dashboard/app/components/__tests__/TaskDetail.swipe-back.test.tsx b/packages/dashboard/app/components/__tests__/TaskDetail.swipe-back.test.tsx
index f6045f3b19..6b14800011 100644
--- a/packages/dashboard/app/components/__tests__/TaskDetail.swipe-back.test.tsx
+++ b/packages/dashboard/app/components/__tests__/TaskDetail.swipe-back.test.tsx
@@ -1,5 +1,18 @@
 /**
  * Focused regression coverage for mobile task-detail swipe-back behavior.
+ *
+ * FNXC:TaskDetailAndroidBack 2026-07-05-11:45:
+ * FN-7583 diagnosed the Android back-GESTURE regression as native-delivery-only: the
+ * generated AndroidManifest.xml never opted into `android:enableOnBackInvokedCallback`,
+ * so AndroidX's dispatcher didn't route the predictive-back gesture to
+ * `@capacitor/app`'s registered callback (fixed via `packages/mobile/scripts/
+ * patch-android-manifest.ts`). The dashboard-side dismissal invariant covered below
+ * (board main-panel / list-mobile / modal / nested detail, via both `popstate` and
+ * `dispatchNativeAndroidBack()`) was already correct and required NO change for this
+ * fix — once the gesture reaches the native `backButton` listener, it dispatches the
+ * exact same `fusion:native-back` event the hardware Back button already used, so this
+ * suite's existing coverage continues to prove the shared invariant for gesture, button,
+ * and browser Back alike.
  */
 import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
 import { render, screen, fireEvent, waitFor, act } from "@testing-library/react";
diff --git a/packages/mobile/README.md b/packages/mobile/README.md
index 6dfbe5cbc3..47925cc929 100644
--- a/packages/mobile/README.md
+++ b/packages/mobile/README.md
@@ -14,6 +14,37 @@ Mobile uses a shell-level onboarding flow for first-run connection setup before
 
 Native wrappers are isolated under `src/plugins/native-shell.ts`, `src/plugins/connection-profiles.ts`, and `src/plugins/qr-scanner.ts` so dashboard code never calls vendor-specific APIs directly.
 
+## Android Back: hardware button and predictive-back GESTURE both dismiss task detail
+
+`AndroidBackButtonManager` (`src/plugins/native-shell.ts`) subscribes to `@capacitor/app`'s
+`backButton` event and dispatches a single cancelable `fusion:native-back` browser event.
+The dashboard's shared nav-history stack (`useNavigationHistory`) consumes that event to
+dismiss the top task-detail surface (board main-panel, list-mobile, modal, and nested
+detail) and return to the board/previous detail — the exact same invariant the browser
+`popstate`/swipe-back path already uses. If nothing handles the event (`!defaultPrevented`),
+Capacitor's own fallback runs unchanged: `history.back()` when `canGoBack`, else `exitApp()`.
+
+**FN-7583:** the Android system back **gesture** (predictive back / edge swipe, Android
+13+, default-prominent at this project's `targetSdk 35`) previously did not reach that
+listener, even though the hardware/legacy Back button did — the app never opted the
+generated manifest into Android's predictive-back framework
+(`android:enableOnBackInvokedCallback="true"`), so `OnBackPressedDispatcher` silently
+dropped the gesture-completion callback while still delivering button presses via the
+ordinary `Window`/`Activity` path. Because the native `android/` project is generated by
+`cap sync` and is git-ignored, the fix lives in tracked source:
+`scripts/patch-android-manifest.ts` idempotently adds that manifest attribute to the
+generated `AndroidManifest.xml`, and is wired into Capacitor's own `capacitor:sync:after`
+npm-script hook (see `package.json`) so it runs automatically on every `cap sync` —
+including `build:mobile`, `dev:android`, and `cap run android` (which syncs first). No
+dashboard-side change was needed: once the gesture reaches the native `backButton`
+listener, gesture and button converge on the identical `fusion:native-back` dispatch.
+
+Manual invocation (e.g. after a bare `npx cap sync` outside `build:mobile`):
+
+```bash
+pnpm --filter @fusion/mobile patch:android-manifest
+```
+
 ### Regression coverage locked by tests
 
 `packages/mobile/src/__tests__/connection-profiles.test.ts`, `native-shell.test.ts`, and `qr-scanner.test.ts` now lock these contracts:
diff --git a/packages/mobile/capacitor.config.ts b/packages/mobile/capacitor.config.ts
index ffc245fe56..33fd67cede 100644
--- a/packages/mobile/capacitor.config.ts
+++ b/packages/mobile/capacitor.config.ts
@@ -22,6 +22,19 @@ const config: CapacitorConfig = {
       detectViewportFitCoverChanges: false,
       initialViewportFitCover: false,
     },
+    // FNXC:TaskDetailAndroidBack 2026-07-05-11:40:
+    // FN-7583: keep the @capacitor/app native backButton handler ENABLED (the default,
+    // pinned explicitly below). `AndroidBackButtonManager` in `src/plugins/native-shell.ts`
+    // relies on the plugin's "backButton" event to dispatch the shared `fusion:native-back`
+    // event that the dashboard's nav-history stack consumes for both the hardware Back
+    // button and the Android 13+ predictive-back GESTURE (once the gesture is actually
+    // delivered — see `scripts/patch-android-manifest.ts` for the manifest opt-in that
+    // makes that so). Setting `disableBackButtonHandler: true` would stop the plugin from
+    // emitting "backButton" entirely, breaking BOTH the button and the gesture routing —
+    // never flip this without replacing `AndroidBackButtonManager`'s dispatch seam too.
+    App: {
+      disableBackButtonHandler: false,
+    },
   },
   server: {
     url: liveReloadEnabled
diff --git a/packages/mobile/package.json b/packages/mobile/package.json
index 110d355594..aecd168db0 100644
--- a/packages/mobile/package.json
+++ b/packages/mobile/package.json
@@ -19,6 +19,8 @@
     "dev:ios": "tsx scripts/live-reload.ts --platform ios",
     "dev:android": "tsx scripts/live-reload.ts --platform android",
     "build:mobile": "pnpm --filter @fusion/dashboard build && npx cap sync",
+    "patch:android-manifest": "npx tsx scripts/patch-android-manifest.ts",
+    "capacitor:sync:after": "npx tsx scripts/patch-android-manifest.ts",
     "test": "vitest run --silent=passed-only --reporter=dot",
     "typecheck": "tsc --noEmit"
   },
diff --git a/packages/mobile/scripts/patch-android-manifest.ts b/packages/mobile/scripts/patch-android-manifest.ts
new file mode 100644
index 0000000000..caa84d668e
--- /dev/null
+++ b/packages/mobile/scripts/patch-android-manifest.ts
@@ -0,0 +1,90 @@
+/**
+ * FNXC:TaskDetailAndroidBack 2026-07-05-11:40:
+ * FN-7583: the Android system back GESTURE (predictive back / edge swipe, Android 13+,
+ * default-prominent at this project's `targetSdk 35`) was not reaching the same
+ * `@capacitor/app` `OnBackPressedCallback` ("backButton" JS event) that the hardware/
+ * legacy Back button already routes through — even though both the button and the
+ * gesture are supposed to funnel through AndroidX's `OnBackPressedDispatcher`. Per
+ * Android's predictive-back docs (https://developer.android.com/guide/navigation/custom-back/predictive-back-gesture)
+ * and the confirmed upstream defect (ionic-team/capacitor-plugins#2418, mitigated by
+ * ionic-team/capacitor-plugins#2390's `disableBackButtonHandler` toggle shipped in
+ * `@capacitor/app@7.1.0`), an app must opt in via `android:enableOnBackInvokedCallback="true"`
+ * on the manifest `<application>` tag for the gesture-completion callback to reliably
+ * reach a registered `OnBackPressedCallback`. Without that opt-in, the OS falls back to
+ * "legacy" gesture dispatch, which silently drops the callback invocation for the
+ * gesture while the hardware Back button (delivered via the ordinary Window/Activity
+ * input path) keeps working — exactly the divergence this task reported.
+ *
+ * The native `android/` project is generated by `cap sync` and is git-ignored (see
+ * AGENTS.md / `.gitignore`), so durable changes cannot live there directly. Instead this
+ * script idempotently patches the generated manifest immediately after every sync, and
+ * is wired into Capacitor's own `capacitor:sync:after` npm-script hook (see
+ * `package.json`), which the Capacitor CLI runs automatically after `cap sync` — and
+ * therefore after `cap run android` (which syncs first) and `build:mobile` too.
+ *
+ * This keeps a SINGLE dismissal invariant: gesture and button both end up delivered to
+ * `AndroidBackButtonManager`'s `backButton` listener in
+ * `packages/mobile/src/plugins/native-shell.ts`, which dispatches the cancelable
+ * `fusion:native-back` event consumed by the dashboard's shared nav-history stack.
+ */
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const ENABLE_ATTR = 'android:enableOnBackInvokedCallback="true"';
+
+export function patchManifestSource(xml: string): { changed: boolean; xml: string } {
+  const applicationTagMatch = xml.match(/<application\b[^>]*>/);
+  if (!applicationTagMatch) {
+    return { changed: false, xml };
+  }
+
+  const applicationTag = applicationTagMatch[0];
+  if (applicationTag.includes("android:enableOnBackInvokedCallback")) {
+    // Already opted in (idempotent — do not duplicate on repeat `cap sync` runs).
+    return { changed: false, xml };
+  }
+
+  const patchedTag = applicationTag.replace(/>$/, ` ${ENABLE_ATTR}>`);
+  const patchedXml = xml.slice(0, applicationTagMatch.index) + patchedTag + xml.slice((applicationTagMatch.index ?? 0) + applicationTag.length);
+  return { changed: true, xml: patchedXml };
+}
+
+export function resolveManifestPath(mobilePackageDir: string): string {
+  return join(mobilePackageDir, "android", "app", "src", "main", "AndroidManifest.xml");
+}
+
+export function patchAndroidManifest(mobilePackageDir: string): { patched: boolean; skipped: boolean; path: string } {
+  const manifestPath = resolveManifestPath(mobilePackageDir);
+
+  if (!existsSync(manifestPath)) {
+    // No Android platform added yet (e.g. iOS-only sync) — safe no-op, not an error.
+    return { patched: false, skipped: true, path: manifestPath };
+  }
+
+  const original = readFileSync(manifestPath, "utf8");
+  const { changed, xml } = patchManifestSource(original);
+
+  if (changed) {
+    writeFileSync(manifestPath, xml, "utf8");
+  }
+
+  return { patched: changed, skipped: false, path: manifestPath };
+}
+
+function isMainModule(): boolean {
+  return process.argv[1] === fileURLToPath(import.meta.url);
+}
+
+if (isMainModule()) {
+  const mobilePackageDir = dirname(fileURLToPath(import.meta.url)).replace(/[/\\]scripts$/, "");
+  const result = patchAndroidManifest(mobilePackageDir);
+
+  if (result.skipped) {
+    console.log(`[patch-android-manifest] no android/ project at ${result.path}; skipping (nothing to patch yet)`);
+  } else if (result.patched) {
+    console.log(`[patch-android-manifest] added android:enableOnBackInvokedCallback="true" to ${result.path}`);
+  } else {
+    console.log(`[patch-android-manifest] ${result.path} already opts into enableOnBackInvokedCallback; no change`);
+  }
+}
diff --git a/packages/mobile/src/__tests__/native-shell.test.ts b/packages/mobile/src/__tests__/native-shell.test.ts
index 999ca392eb..623fa4f115 100644
--- a/packages/mobile/src/__tests__/native-shell.test.ts
+++ b/packages/mobile/src/__tests__/native-shell.test.ts
@@ -1,5 +1,9 @@
+import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { buildMobileShellHandoff } from "../plugins/shell-handoff.js";
+import { patchAndroidManifest, patchManifestSource } from "../../scripts/patch-android-manifest.js";
 
 type BackButtonListener = (event: { canGoBack: boolean }) => void;
 
@@ -259,4 +263,102 @@ describe("MobileNativeShellBridge", () => {
 
     expect(capacitorState.exitApp).toHaveBeenCalledTimes(1);
   });
+
+  /*
+  FNXC:TaskDetailAndroidBack 2026-07-05-11:45:
+  FN-7583 — the Android back GESTURE (predictive back / edge swipe, Android 13+) reached
+  the OS but was never delivered to `AndroidBackButtonManager`'s `backButton` listener
+  because the generated AndroidManifest.xml never opted into
+  `android:enableOnBackInvokedCallback="true"`. The raw OS gesture cannot be dispatched
+  from a unit test, so these tests drive the actual seam the fix introduced
+  (`patch-android-manifest.ts`) and assert it converges on the exact contract the button
+  path above already proves: once the manifest opts in, gesture-completion delivery uses
+  the SAME `OnBackPressedCallback` -> "backButton" -> `dispatchNativeBackEvent()` ->
+  `fusion:native-back` chain, with the same cancelable-event and empty-stack fallback
+  semantics. This test fails against the pre-fix tree (no `patch-android-manifest.ts`
+  module, so the import above throws) and passes after.
+  */
+  describe("Android Back: gesture-delivery manifest opt-in (patch-android-manifest)", () => {
+    let workDir: string;
+
+    beforeEach(() => {
+      workDir = mkdtempSync(join(tmpdir(), "fusion-fn7583-manifest-"));
+    });
+
+    afterEach(() => {
+      rmSync(workDir, { recursive: true, force: true });
+    });
+
+    function writeManifest(xml: string): string {
+      const manifestDir = join(workDir, "android", "app", "src", "main");
+      mkdirSync(manifestDir, { recursive: true });
+      const manifestPath = join(manifestDir, "AndroidManifest.xml");
+      writeFileSync(manifestPath, xml, "utf8");
+      return manifestPath;
+    }
+
+    const baseManifest = `<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android" package="com.fusion.mobile">
+    <application
+        android:allowBackup="true"
+        android:icon="@mipmap/ic_launcher"
+        android:label="@string/app_name">
+        <activity android:name=".MainActivity" />
+    </application>
+</manifest>
+`;
+
+    it("opts the generated manifest into predictive-back gesture delivery (the seam the gesture needs)", () => {
+      const manifestPath = writeManifest(baseManifest);
+
+      const result = patchAndroidManifest(workDir);
+
+      expect(result.patched).toBe(true);
+      expect(result.skipped).toBe(false);
+      const patchedXml = readFileSync(manifestPath, "utf8");
+      expect(patchedXml).toMatch(/<application[^>]*android:enableOnBackInvokedCallback="true"[^>]*>/);
+    });
+
+    it("is idempotent across repeated cap sync runs (does not duplicate the attribute)", () => {
+      writeManifest(baseManifest);
+
+      const first = patchAndroidManifest(workDir);
+      const second = patchAndroidManifest(workDir);
+
+      expect(first.patched).toBe(true);
+      expect(second.patched).toBe(false);
+      const manifestPath = join(workDir, "android", "app", "src", "main", "AndroidManifest.xml");
+      const xml = readFileSync(manifestPath, "utf8");
+      expect(xml.match(/android:enableOnBackInvokedCallback/g)).toHaveLength(1);
+    });
+
+    it("leaves an already-opted-in manifest untouched", () => {
+      const alreadyOptedIn = baseManifest.replace(
+        '<application\n        android:allowBackup="true"',
+        '<application\n        android:enableOnBackInvokedCallback="true"\n        android:allowBackup="true"',
+      );
+      writeManifest(alreadyOptedIn);
+
+      const result = patchAndroidManifest(workDir);
+
+      expect(result.patched).toBe(false);
+      const xml = readFileSync(join(workDir, "android", "app", "src", "main", "AndroidManifest.xml"), "utf8");
+      expect(xml.match(/android:enableOnBackInvokedCallback/g)).toHaveLength(1);
+    });
+
+    it("no-ops safely (does not throw) when no android/ project has been added yet", () => {
+      const result = patchAndroidManifest(workDir);
+
+      expect(result.skipped).toBe(true);
+      expect(result.patched).toBe(false);
+    });
+
+    it("patchManifestSource preserves the rest of the manifest verbatim aside from the opt-in attribute", () => {
+      const { changed, xml } = patchManifestSource(baseManifest);
+
+      expect(changed).toBe(true);
+      expect(xml).toContain('<activity android:name=".MainActivity" />');
+      expect(xml).toContain('android:label="@string/app_name"');
+    });
+  });
 });

From da36094d7475efb29b2c403fcba09888539d46f6 Mon Sep 17 00:00:00 2001
From: gsxdsm <gsxdsm@users.noreply.github.com>
Date: Sun, 5 Jul 2026 12:24:12 -0700
Subject: [PATCH 42/65] FN-7586: add iOS edge-swipe-back gesture parity via
 AppDelegate patch

Enables the WKWebView interactive-pop (edge-swipe-back) gesture on iOS, matching the Android predictive-back parity already in place, by patching the generated AppDelegate.swift during cap sync.

- Add packages/mobile/scripts/patch-ios-webview.ts: patches AppDelegate.swift to cast the root view controller to CAPBridgeViewController and set webView?.allowsBackForwardNavigationGestures = true before the didFinishLaunchingWithOptions return, is idempotent, and no-ops safely when no ios/ project exists yet
- Wire capacitor:sync:after to run both patch-android-manifest.ts and patch-ios-webview.ts so cap sync keeps both native back-gesture opt-ins in sync; add patch:ios-webview script
- Add unit tests covering patch, idempotency, already-patched, missing-project, and source-preservation cases for the new iOS webview patch, alongside the existing Android manifest patch tests
- Add TaskDetail.swipe-back.test.tsx coverage proving the shared popstate-driven nav-history dismissal stack (no iOS-specific native-back emitter needed) already satisfies the gesture's dismissal contract
- Add mobile-scripts.test.ts dashboard coverage and update MOBILE.md / packages/mobile/README.md documenting the new iOS gesture opt-in

Files changed:
 MOBILE.md                                          |  12 ++
 .../dashboard/app/__tests__/mobile-scripts.test.ts |  31 +++++
 .../__tests__/TaskDetail.swipe-back.test.tsx       | 131 +++++++++++++++++++++
 packages/mobile/README.md                          |  36 ++++++
 packages/mobile/package.json                       |   3 +-
 packages/mobile/scripts/patch-ios-webview.ts       | 119 +++++++++++++++++++
 packages/mobile/src/__tests__/native-shell.test.ts | 122 +++++++++++++++++++
 7 files changed, 453 insertions(+), 1 deletion(-)

Fusion-Task-Id: FN-7586

Fusion-Task-Lineage: 248092a1-de1b-49b6-94ef-70675a7b93a1

Co-authored-by: Fusion (runfusion.ai) <noreply@runfusion.ai>
---
 MOBILE.md                                     |  12 ++
 .../app/__tests__/mobile-scripts.test.ts      |  31 +++++
 .../__tests__/TaskDetail.swipe-back.test.tsx  | 131 ++++++++++++++++++
 packages/mobile/README.md                     |  36 +++++
 packages/mobile/package.json                  |   3 +-
 packages/mobile/scripts/patch-ios-webview.ts  | 119 ++++++++++++++++
 .../mobile/src/__tests__/native-shell.test.ts | 122 ++++++++++++++++
 7 files changed, 453 insertions(+), 1 deletion(-)
 create mode 100644 packages/mobile/scripts/patch-ios-webview.ts

diff --git a/MOBILE.md b/MOBILE.md
index ccc13e3f3d..7b4d565ce0 100644
--- a/MOBILE.md
+++ b/MOBILE.md
@@ -89,6 +89,16 @@ Implementation notes:
 - Active-profile deletion fallback is shell-owned: deleting the active profile promotes the first remaining profile, and deleting the final profile resets to a clean empty state.
 - The dashboard consumes this through the shared `window.fusionShell` connection APIs.
 
+### Native Back Handling (Android Back + iOS Edge-Swipe-Back)
+
+Task-detail dismissal via native "back" (Android hardware Back / predictive-back gesture,
+iOS edge-swipe-back, or plain browser swipe-back) converges on a single shared invariant:
+the dashboard's `useNavigationHistory` nav-history stack. See `packages/mobile/README.md`
+→ "Native Back Handling" for the full Android (`fusion:native-back`) vs. iOS (`popstate`)
+routing details and the tracked post-`cap sync` patch scripts (`scripts/
+patch-android-manifest.ts`, `scripts/patch-ios-webview.ts`) that keep each platform's native
+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. On desktop/tablet the split view is unaffected. Once sessions are saved, mobile shows the session list as usual and the user can navigate between list and detail panes.
@@ -186,3 +196,5 @@ Mobile package scripts (`packages/mobile/package.json`):
 - `dev:ios`
 - `dev:android`
 - `build:mobile`
+- `patch:ios-webview` — idempotently enables the iOS WKWebView edge-swipe-back gesture in the generated `ios/App/App/AppDelegate.swift` (safe no-op if `ios/` doesn't exist yet)
+- `capacitor:sync:after` — Capacitor's own post-`cap sync` hook; currently runs the iOS webview patch so `cap sync` regeneration can't silently drop the gesture opt-in
diff --git a/packages/dashboard/app/__tests__/mobile-scripts.test.ts b/packages/dashboard/app/__tests__/mobile-scripts.test.ts
index c16e85021f..51e6da5a88 100644
--- a/packages/dashboard/app/__tests__/mobile-scripts.test.ts
+++ b/packages/dashboard/app/__tests__/mobile-scripts.test.ts
@@ -43,4 +43,35 @@ describe("mobile pipeline scripts", () => {
     expect(packageJson.scripts?.["mobile:ios"] ?? "").toContain("ios");
     expect(packageJson.scripts?.["mobile:android"] ?? "").toContain("android");
   });
+
+  /*
+  FNXC:TaskDetailIOSSwipeBack 2026-07-05-12:10:
+  FN-7586: `WKWebView.allowsBackForwardNavigationGestures` defaults to false and no
+  capacitor.config toggle exists for it (confirmed against the installed @capacitor/cli
+  declarations), so the fix is a tracked post-`cap sync` patch script
+  (`packages/mobile/scripts/patch-ios-webview.ts`) wired into Capacitor's own
+  `capacitor:sync:after` npm hook — mirroring FN-7583's Android manifest-patch precedent —
+  so `cap sync` regeneration of the git-ignored `ios/` project can never silently drop the
+  gesture opt-in. This asserts the patch/wiring is present in tracked source; it fails on the
+  pre-fix tree (no patch script, no hook) and passes after.
+  */
+  describe("iOS edge-swipe-back gesture patch wiring (FN-7586)", () => {
+    const mobilePackagePath = resolve(__dirname, "../../../mobile/package.json");
+    const patchScriptPath = resolve(__dirname, "../../../mobile/scripts/patch-ios-webview.ts");
+
+    it("ships a tracked post-cap-sync iOS WKWebView patch script", () => {
+      const source = readFileSync(patchScriptPath, "utf8");
+
+      expect(source).toContain("allowsBackForwardNavigationGestures");
+      expect(source).toContain("CAPBridgeViewController");
+    });
+
+    it("wires the iOS webview patch into a Capacitor sync hook so cap sync cannot drop it", () => {
+      const mobilePackageJson = JSON.parse(readFileSync(mobilePackagePath, "utf8")) as WorkspacePackageJson;
+      const scripts = mobilePackageJson.scripts ?? {};
+
+      const syncAfterHook = scripts["capacitor:sync:after"] ?? "";
+      expect(syncAfterHook).toContain("patch-ios-webview");
+    });
+  });
 });
diff --git a/packages/dashboard/app/components/__tests__/TaskDetail.swipe-back.test.tsx b/packages/dashboard/app/components/__tests__/TaskDetail.swipe-back.test.tsx
index 6b14800011..4071908d83 100644
--- a/packages/dashboard/app/components/__tests__/TaskDetail.swipe-back.test.tsx
+++ b/packages/dashboard/app/components/__tests__/TaskDetail.swipe-back.test.tsx
@@ -802,4 +802,135 @@ describe("Task detail mobile swipe-back", () => {
     expect(window.history.pushState).not.toHaveBeenCalled();
     expect(screen.queryByTestId("task-detail-modal")).toBeNull();
   });
+
+  /*
+  FNXC:TaskDetailIOSSwipeBack 2026-07-05-12:10:
+  FN-7586 diagnosed the iOS edge-swipe-back gap as native-delivery-only: WKWebView's
+  `allowsBackForwardNavigationGestures` defaults to `false` and Capacitor never sets it, so
+  the gesture never fires at all today (fixed via `packages/mobile/scripts/
+  patch-ios-webview.ts`, an AppDelegate patch wired into the `capacitor:sync:after` hook).
+  Once enabled, iOS drives ordinary WKWebView back-forward navigation, which is delivered to
+  the page as a `popstate` — the EXACT SAME seam desktop/browser swipe-back already uses.
+  This suite's existing `dispatchPopState` coverage above (board main-panel, list-mobile,
+  nested modal) therefore already proves the shared nav-history dismissal invariant for the
+  iOS gesture too, and required NO dashboard-side change. This describe block adds
+  iOS-labeled regression coverage (same `popstate` seam, explicitly named) plus the one gap
+  not yet covered above: the empty-stack fallback via `popstate` (no Fusion nav entry ->
+  safe no-op, matching how native Android Back already no-ops on an empty stack).
+  */
+  describe("iOS edge-swipe-back (popstate seam)", () => {
+    it("dismisses the board main-panel task detail on iOS edge-swipe-back (popstate)", async () => {
+      const task = makeTask("FN-1", "iOS Board Detail");
+      mockUseTasks.mockImplementation(() => ({
+        tasks: [task],
+        createTask: mockCreateTask,
+        moveTask: vi.fn(),
+        deleteTask: vi.fn(),
+        mergeTask: vi.fn(),
+        retryTask: vi.fn(),
+        updateTask: vi.fn(),
+        duplicateTask: vi.fn(),
+        archiveTask: vi.fn(),
+        unarchiveTask: vi.fn(),
+        archiveAllDone: vi.fn(),
+        refreshTasks: vi.fn(),
+      }));
+
+      await renderAppAndWait("board-view");
+      fireEvent.click(screen.getByTestId("open-task-FN-1"));
+
+      await waitFor(() => {
+        expect(screen.getByTestId("task-detail-main-panel-content")).toBeInTheDocument();
+      });
+
+      dispatchPopState({ navIndex: 0 });
+
+      await waitFor(() => {
+        expect(screen.queryByTestId("task-detail-main-panel-content")).toBeNull();
+        expect(screen.getByTestId("board-view")).toBeInTheDocument();
+      });
+    });
+
+    it("dismisses the list-mobile task detail on iOS edge-swipe-back (popstate)", async () => {
+      const task = makeTask("FN-1", "iOS Mobile List Detail");
+      mockUseTasks.mockImplementation(() => ({
+        tasks: [task],
+        createTask: mockCreateTask,
+        moveTask: vi.fn(),
+        deleteTask: vi.fn(),
+        mergeTask: vi.fn(),
+        retryTask: vi.fn(),
+        updateTask: vi.fn(),
+        duplicateTask: vi.fn(),
+        archiveTask: vi.fn(),
+        unarchiveTask: vi.fn(),
+        archiveAllDone: vi.fn(),
+        refreshTasks: vi.fn(),
+      }));
+      localStorage.setItem("kb-dashboard-view-mode", "project");
+      localStorage.setItem(scopedKey("kb-dashboard-task-view", DEFAULT_PROJECT_ID), "list");
+
+      await renderAppAndWait("list-view");
+      fireEvent.click(screen.getByTestId("list-open-FN-1"));
+
+      await waitFor(() => {
+        expect(screen.getByTestId("task-detail-modal")).toBeInTheDocument();
+      });
+
+      dispatchPopState({ navIndex: 0 });
+
+      await waitFor(() => {
+        expect(screen.queryByTestId("task-detail-modal")).toBeNull();
+        expect(screen.getByTestId("list-view")).toBeInTheDocument();
+      });
+    });
+
+    it("restores the previous modal detail when iOS edge-swipe-back (popstate) closes a nested task detail", async () => {
+      const task = makeTask("FN-1", "iOS Parent Task");
+      mockUseTasks.mockImplementation(() => ({
+        tasks: [task, makeTask("FN-2", "iOS Nested Task")],
+        createTask: mockCreateTask,
+        moveTask: vi.fn(),
+        deleteTask: vi.fn(),
+        mergeTask: vi.fn(),
+        retryTask: vi.fn(),
+        updateTask: vi.fn(),
+        duplicateTask: vi.fn(),
+        archiveTask: vi.fn(),
+        unarchiveTask: vi.fn(),
+        archiveAllDone: vi.fn(),
+        refreshTasks: vi.fn(),
+      }));
+      localStorage.setItem("kb-dashboard-view-mode", "project");
+      localStorage.setItem(scopedKey("kb-dashboard-task-view", DEFAULT_PROJECT_ID), "list");
+
+      await renderAppAndWait("list-view");
+      fireEvent.click(screen.getByTestId("list-open-FN-1"));
+      await waitFor(() => {
+        expect(screen.getByRole("dialog", { name: "iOS Parent Task" })).toBeInTheDocument();
+      });
+
+      fireEvent.click(screen.getByTestId("task-detail-open-nested"));
+      await waitFor(() => {
+        expect(screen.getByRole("dialog", { name: "iOS Nested Task" })).toBeInTheDocument();
+      });
+
+      dispatchPopState({ navIndex: 1 });
+
+      await waitFor(() => {
+        expect(screen.getByRole("dialog", { name: "iOS Parent Task" })).toBeInTheDocument();
+      });
+      expect(screen.queryByRole("dialog", { name: "iOS Nested Task" })).toBeNull();
+    });
+
+    it("safely no-ops on iOS edge-swipe-back (popstate) when Fusion owns no nav entry", async () => {
+      await renderAppAndWait("board-view");
+
+      expect(() => dispatchPopState(null)).not.toThrow();
+
+      await waitFor(() => {
+        expect(screen.getByTestId("board-view")).toBeInTheDocument();
+      });
+    });
+  });
 });
diff --git a/packages/mobile/README.md b/packages/mobile/README.md
index 47925cc929..acbc994cdc 100644
--- a/packages/mobile/README.md
+++ b/packages/mobile/README.md
@@ -53,6 +53,42 @@ pnpm --filter @fusion/mobile patch:android-manifest
 - bridge reads (`getState`, `listProfiles`) plus connection-manager event dispatch
 - malformed/empty QR payload handling and unavailable-scanner fallback behavior
 
+## Native Back Handling (Android Back + iOS Edge-Swipe-Back)
+
+Mobile task-detail dismissal converges on a SINGLE shared invariant regardless of how the
+user triggers "back": the dashboard's `useNavigationHistory` nav-history stack
+(`packages/dashboard/app/hooks/useNavigationHistory.ts`), which board main-panel,
+list-mobile, modal, and nested task-detail surfaces already consume for desktop/browser
+swipe-back via ordinary `popstate`.
+
+- **Android hardware Back button + gesture (FN-7583):** `AndroidBackButtonManager` in
+  `src/plugins/native-shell.ts` listens for `@capacitor/app`'s `backButton` event and
+  dispatches a cancelable `fusion:native-back` custom event; `useNavigationHistory` consumes
+  it to dismiss the top task-detail surface (falling back to native browser-history `back()`
+  or app exit when Fusion owns no nav entry). The Android 13+ predictive-back **gesture**
+  additionally requires the generated `AndroidManifest.xml` to opt into
+  `android:enableOnBackInvokedCallback="true"` for AndroidX's dispatcher to route the
+  gesture-completion callback to the same `backButton` listener — since `android/` is
+  generated by `cap sync` and git-ignored, this opt-in lives in a tracked post-`cap sync`
+  patch (`scripts/patch-android-manifest.ts`), wired into the `capacitor:sync:after` npm hook.
+- **iOS edge-swipe-back (FN-7586):** iOS has **no** Capacitor `backButton` event, so it does
+  NOT go through `fusion:native-back`. Instead, the WKWebView edge-swipe-back gesture (once
+  enabled) drives ordinary back-forward navigation, which the browser delivers as a
+  `popstate` — the exact same seam desktop/browser swipe-back already uses, and that
+  `useNavigationHistory.handlePopState` already consumes correctly. The gesture itself is OFF
+  by default: `WKWebView.allowsBackForwardNavigationGestures` defaults to `false`, Capacitor's
+  `CAPBridgeViewController` never sets it, and no `capacitor.config.ts` `ios` toggle exists
+  for it. Since `ios/` is also generated by `cap sync` and git-ignored, this is enabled via a
+  tracked post-`cap sync` patch (`scripts/patch-ios-webview.ts`) that idempotently patches the
+  generated `AppDelegate.swift` to set `webView?.allowsBackForwardNavigationGestures = true`
+  once the storyboard's root `CAPBridgeViewController` has loaded — also wired into the same
+  `capacitor:sync:after` npm hook. Empty-stack behavior (no Fusion nav entry) is unaffected:
+  the gesture just performs ordinary WKWebView history navigation with no forced trap/exit.
+
+Both patch scripts are safe no-ops when their respective native platform directory
+(`android/` / `ios/`) hasn't been added yet, and are idempotent across repeated `cap sync`
+runs (see `src/__tests__/native-shell.test.ts`).
+
 ## Push Notifications
 
 `PushNotificationManager` supports two complementary notification channels:
diff --git a/packages/mobile/package.json b/packages/mobile/package.json
index aecd168db0..fe473d5575 100644
--- a/packages/mobile/package.json
+++ b/packages/mobile/package.json
@@ -20,7 +20,8 @@
     "dev:android": "tsx scripts/live-reload.ts --platform android",
     "build:mobile": "pnpm --filter @fusion/dashboard build && npx cap sync",
     "patch:android-manifest": "npx tsx scripts/patch-android-manifest.ts",
-    "capacitor:sync:after": "npx tsx scripts/patch-android-manifest.ts",
+    "patch:ios-webview": "npx tsx scripts/patch-ios-webview.ts",
+    "capacitor:sync:after": "npx tsx scripts/patch-android-manifest.ts && npx tsx scripts/patch-ios-webview.ts",
     "test": "vitest run --silent=passed-only --reporter=dot",
     "typecheck": "tsc --noEmit"
   },
diff --git a/packages/mobile/scripts/patch-ios-webview.ts b/packages/mobile/scripts/patch-ios-webview.ts
new file mode 100644
index 0000000000..6f906b7394
--- /dev/null
+++ b/packages/mobile/scripts/patch-ios-webview.ts
@@ -0,0 +1,119 @@
+/**
+ * FNXC:TaskDetailIOSSwipeBack 2026-07-05-12:10:
+ * FN-7586: the iOS edge-swipe-back gesture (WKWebView interactive pop / back-forward
+ * navigation gesture) is a guaranteed no-op on a stock Capacitor 7 iOS build of this app.
+ * `WKWebView.allowsBackForwardNavigationGestures` defaults to `false`
+ * (https://developer.apple.com/documentation/webkit/wkwebview/1414995-allowsbackforwardnavigationgestu),
+ * `CAPBridgeViewController.prepareWebView` (in `@capacitor/ios`) sets several WKWebView
+ * properties from `capacitor.config.ts` (`allowsLinkPreview`, `scrollView.isScrollEnabled`,
+ * background color, content-inset behavior) but never touches this one, and the installed
+ * `@capacitor/cli`'s `ios` config block (see `declarations.d.ts`) exposes no first-class
+ * toggle for it either. Without the gesture enabled, iOS never even reaches
+ * `window.history.back()` / `popstate` — so the dashboard's shared nav-history dismissal
+ * stack (`useNavigationHistory.handlePopState`), which board/list/modal/nested task-detail
+ * surfaces already converge on for desktop/browser swipe-back, never gets a chance to run.
+ *
+ * The native `ios/` project is generated by `cap sync` (via `cap add ios`, which extracts
+ * `@capacitor/cli`'s bundled `ios-pods-template.tar.gz`) and is git-ignored (see AGENTS.md /
+ * `.gitignore`), so durable changes cannot live there directly — mirroring FN-7583's Android
+ * manifest-patch precedent (`patch-android-manifest.ts`), this script idempotently patches
+ * the generated `AppDelegate.swift` immediately after every sync, wired into Capacitor's own
+ * `capacitor:sync:after` npm-script hook (see `package.json`), which the Capacitor CLI runs
+ * automatically after `cap sync` (and therefore after `cap run ios` / `build:mobile` too).
+ *
+ * Patch target: the stock template has NO custom `CAPBridgeViewController` subclass — the
+ * generated `Main.storyboard` wires `customClass="CAPBridgeViewController"` directly onto the
+ * scene's view controller. `AppDelegate.didFinishLaunchingWithOptions` is therefore the
+ * stable, minimal patch point: by the time it runs, `UIApplicationMain` has already loaded
+ * the storyboard's root view controller into `window.rootViewController`. The patch casts it
+ * to `CAPBridgeViewController`, forces `loadViewIfNeeded()` so `webView` is non-nil (the
+ * bridge view controller creates its WKWebView lazily in `loadView()`), then sets
+ * `webView?.allowsBackForwardNavigationGestures = true`.
+ *
+ * This keeps a SINGLE dismissal invariant across platforms: once the gesture is delivered,
+ * iOS drives ordinary WKWebView back-forward navigation -> `popstate`, the exact same arm
+ * browser/desktop swipe-back already uses and that `useNavigationHistory.handlePopState`
+ * already consumes for board main-panel / list-mobile / modal / nested task-detail surfaces.
+ * iOS has no Capacitor `backButton` event (that's Android-only, see
+ * `src/plugins/native-shell.ts`'s `AndroidBackButtonManager`), so this does NOT add an iOS
+ * `fusion:native-back` emitter — it reuses the existing `popstate` arm of the shared
+ * invariant instead of introducing a second, divergent back-handling path.
+ */
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const MARKER = "allowsBackForwardNavigationGestures";
+
+const DID_FINISH_LAUNCHING_SIGNATURE =
+  /func application\(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: \[UIApplication\.LaunchOptionsKey: Any\]\?\) -> Bool \{/;
+
+function buildInjectedSnippet(): string {
+  return `
+        // FNXC:TaskDetailIOSSwipeBack 2026-07-05-12:10:
+        // FN-7586: enable the WKWebView edge-swipe-back gesture so it drives ordinary
+        // back-forward navigation (-> popstate), matching Android Back's fusion:native-back
+        // arm and desktop/browser swipe-back. See packages/mobile/scripts/patch-ios-webview.ts
+        // for the full rationale (idempotent — this line is the presence marker).
+        if let bridgeViewController = self.window?.rootViewController as? CAPBridgeViewController {
+            bridgeViewController.loadViewIfNeeded()
+            bridgeViewController.webView?.${MARKER} = true
+        }
+`;
+}
+
+export function patchAppDelegateSource(swift: string): { changed: boolean; swift: string } {
+  if (swift.includes(MARKER)) {
+    // Already opted in (idempotent — do not duplicate on repeat `cap sync` runs).
+    return { changed: false, swift };
+  }
+
+  const signatureMatch = swift.match(DID_FINISH_LAUNCHING_SIGNATURE);
+  if (!signatureMatch || signatureMatch.index === undefined) {
+    // Unrecognized AppDelegate shape (e.g. a hand-customized template) — do not guess.
+    return { changed: false, swift };
+  }
+
+  const insertAt = signatureMatch.index + signatureMatch[0].length;
+  const patched = swift.slice(0, insertAt) + buildInjectedSnippet() + swift.slice(insertAt);
+  return { changed: true, swift: patched };
+}
+
+export function resolveAppDelegatePath(mobilePackageDir: string): string {
+  return join(mobilePackageDir, "ios", "App", "App", "AppDelegate.swift");
+}
+
+export function patchIOSWebView(mobilePackageDir: string): { patched: boolean; skipped: boolean; path: string } {
+  const appDelegatePath = resolveAppDelegatePath(mobilePackageDir);
+
+  if (!existsSync(appDelegatePath)) {
+    // No iOS platform added yet (e.g. Android-only sync) — safe no-op, not an error.
+    return { patched: false, skipped: true, path: appDelegatePath };
+  }
+
+  const original = readFileSync(appDelegatePath, "utf8");
+  const { changed, swift } = patchAppDelegateSource(original);
+
+  if (changed) {
+    writeFileSync(appDelegatePath, swift, "utf8");
+  }
+
+  return { patched: changed, skipped: false, path: appDelegatePath };
+}
+
+function isMainModule(): boolean {
+  return process.argv[1] === fileURLToPath(import.meta.url);
+}
+
+if (isMainModule()) {
+  const mobilePackageDir = dirname(fileURLToPath(import.meta.url)).replace(/[/\\]scripts$/, "");
+  const result = patchIOSWebView(mobilePackageDir);
+
+  if (result.skipped) {
+    console.log(`[patch-ios-webview] no ios/ project at ${result.path}; skipping (nothing to patch yet)`);
+  } else if (result.patched) {
+    console.log(`[patch-ios-webview] enabled allowsBackForwardNavigationGestures in ${result.path}`);
+  } else {
+    console.log(`[patch-ios-webview] ${result.path} already enables allowsBackForwardNavigationGestures; no change`);
+  }
+}
diff --git a/packages/mobile/src/__tests__/native-shell.test.ts b/packages/mobile/src/__tests__/native-shell.test.ts
index 623fa4f115..b261b755d9 100644
--- a/packages/mobile/src/__tests__/native-shell.test.ts
+++ b/packages/mobile/src/__tests__/native-shell.test.ts
@@ -4,6 +4,7 @@ import { join } from "node:path";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { buildMobileShellHandoff } from "../plugins/shell-handoff.js";
 import { patchAndroidManifest, patchManifestSource } from "../../scripts/patch-android-manifest.js";
+import { patchAppDelegateSource, patchIOSWebView } from "../../scripts/patch-ios-webview.js";
 
 type BackButtonListener = (event: { canGoBack: boolean }) => void;
 
@@ -264,6 +265,7 @@ describe("MobileNativeShellBridge", () => {
     expect(capacitorState.exitApp).toHaveBeenCalledTimes(1);
   });
 
+  /*
   /*
   FNXC:TaskDetailAndroidBack 2026-07-05-11:45:
   FN-7583 — the Android back GESTURE (predictive back / edge swipe, Android 13+) reached
@@ -361,4 +363,124 @@ describe("MobileNativeShellBridge", () => {
       expect(xml).toContain('android:label="@string/app_name"');
     });
   });
+
+  /*
+  FNXC:TaskDetailIOSSwipeBack 2026-07-05-12:10:
+  FN-7586 — the iOS edge-swipe-back GESTURE (WKWebView interactive pop) is a no-op on a
+  stock Capacitor 7 iOS build: `WKWebView.allowsBackForwardNavigationGestures` defaults to
+  `false`, `CAPBridgeViewController.prepareWebView` never sets it, and no capacitor.config
+  toggle exists. The raw WKWebView gesture cannot be dispatched from a unit test, so these
+  tests drive the actual seam the fix introduces (`patch-ios-webview.ts`) and assert it
+  converges on the exact contract the popstate-based coverage in
+  `TaskDetail.swipe-back.test.tsx` already proves: once AppDelegate enables the gesture, iOS
+  drives ordinary WKWebView back-forward navigation -> `popstate` -> the shared nav-history
+  dismissal stack, with no iOS-specific `fusion:native-back` emitter introduced. This test
+  fails against the pre-fix tree (no `patch-ios-webview.ts` module, so the import above
+  throws) and passes after.
+  */
+  describe("iOS Back: edge-swipe-back gesture opt-in (patch-ios-webview)", () => {
+    let workDir: string;
+
+    beforeEach(() => {
+      workDir = mkdtempSync(join(tmpdir(), "fusion-fn7586-appdelegate-"));
+    });
+
+    afterEach(() => {
+      rmSync(workDir, { recursive: true, force: true });
+    });
+
+    function writeAppDelegate(swift: string): string {
+      const appDir = join(workDir, "ios", "App", "App");
+      mkdirSync(appDir, { recursive: true });
+      const appDelegatePath = join(appDir, "AppDelegate.swift");
+      writeFileSync(appDelegatePath, swift, "utf8");
+      return appDelegatePath;
+    }
+
+    const baseAppDelegate = `import UIKit
+import Capacitor
+
+@UIApplicationMain
+class AppDelegate: UIResponder, UIApplicationDelegate {
+
+    var window: UIWindow?
+
+    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
+        // Override point for customization after application launch.
+        return true
+    }
+
+    func applicationWillResignActive(_ application: UIApplication) {
+    }
+
+}
+`;
+
+    it("enables the WKWebView edge-swipe-back gesture in the generated AppDelegate (the seam the gesture needs)", () => {
+      const appDelegatePath = writeAppDelegate(baseAppDelegate);
+
+      const result = patchIOSWebView(workDir);
+
+      expect(result.patched).toBe(true);
+      expect(result.skipped).toBe(false);
+      const patchedSwift = readFileSync(appDelegatePath, "utf8");
+      expect(patchedSwift).toContain("as? CAPBridgeViewController");
+      expect(patchedSwift).toContain("webView?.allowsBackForwardNavigationGestures = true");
+      // Injected before the existing `return true` so the override still returns true.
+      expect(patchedSwift.indexOf("allowsBackForwardNavigationGestures")).toBeLessThan(
+        patchedSwift.indexOf("return true"),
+      );
+    });
+
+    it("is idempotent across repeated cap sync runs (does not duplicate the patch)", () => {
+      writeAppDelegate(baseAppDelegate);
+
+      const first = patchIOSWebView(workDir);
+      const second = patchIOSWebView(workDir);
+
+      expect(first.patched).toBe(true);
+      expect(second.patched).toBe(false);
+      const appDelegatePath = join(workDir, "ios", "App", "App", "AppDelegate.swift");
+      const swift = readFileSync(appDelegatePath, "utf8");
+      expect(swift.match(/allowsBackForwardNavigationGestures/g)).toHaveLength(1);
+    });
+
+    it("leaves an already-patched AppDelegate untouched", () => {
+      const alreadyPatched = baseAppDelegate.replace(
+        "// Override point for customization after application launch.",
+        "// Override point for customization after application launch.\n        self.window?.rootViewController.map { _ in }\n        // allowsBackForwardNavigationGestures already set elsewhere",
+      );
+      writeAppDelegate(alreadyPatched);
+
+      const result = patchIOSWebView(workDir);
+
+      expect(result.patched).toBe(false);
+      const swift = readFileSync(join(workDir, "ios", "App", "App", "AppDelegate.swift"), "utf8");
+      expect(swift.match(/allowsBackForwardNavigationGestures/g)).toHaveLength(1);
+    });
+
+    it("no-ops safely (does not throw) when no ios/ project has been added yet", () => {
+      const result = patchIOSWebView(workDir);
+
+      expect(result.skipped).toBe(true);
+      expect(result.patched).toBe(false);
+    });
+
+    it("patchAppDelegateSource preserves the rest of AppDelegate verbatim aside from the injected snippet", () => {
+      const { changed, swift } = patchAppDelegateSource(baseAppDelegate);
+
+      expect(changed).toBe(true);
+      expect(swift).toContain("func applicationWillResignActive(_ application: UIApplication) {");
+      expect(swift).toContain("class AppDelegate: UIResponder, UIApplicationDelegate {");
+    });
+
+    it("does not change patchAppDelegateSource when the didFinishLaunchingWithOptions signature is unrecognized", () => {
+      const unrecognized = "import UIKit\nclass AppDelegate {}\n";
+
+      const { changed, swift } = patchAppDelegateSource(unrecognized);
+
+      expect(changed).toBe(false);
+      expect(swift).toBe(unrecognized);
+    });
+  });
 });

From 8a7507ad36ac118f07224c2329a051a868bb2811 Mon Sep 17 00:00:00 2001
From: gsxdsm <gsxdsm@users.noreply.github.com>
Date: Sun, 5 Jul 2026 12:38:01 -0700
Subject: [PATCH 43/65] FN-7587: add predictive-back slide/fade animation for
 mobile task-detail dismissal

Adds a presentation-only enter animation for mobile task-detail surfaces (modal and board main-panel), layered on top of the existing FN-7583/FN-7586 dismissal routing, without altering close/back timing.

- Gate a new `.task-detail-modal--mobile-transition` class in TaskDetailModal.tsx via a local resize listener at the 768px breakpoint, mirroring the existing OVERSIGHT_MENU_MOBILE_BREAKPOINT pattern
- Add matching `.task-detail-main-panel--mobile-transition` modifier in MainContent.tsx gated by the existing isMobile prop
- Add slide/fade keyframe animations in TaskDetailModal.css and styles.css, both honoring prefers-reduced-motion
- Add regression tests covering the modal and board-panel mobile transition behavior
- Document the Capacitor WebView limitation preventing a true interactive predictive-back in packages/mobile/README.md

Files changed:
 .../dashboard/app/components/TaskDetailModal.css   |  33 ++
 .../dashboard/app/components/TaskDetailModal.tsx   |  31 +-
 ...skDetail.mobile-transition.board-panel.test.tsx | 333 +++++++++++++++++++++
 .../TaskDetail.mobile-transition.test.tsx          | 156 ++++++++++
 .../app/components/dashboard/MainContent.tsx       |  10 +-
 packages/dashboard/app/styles.css                  |  35 +++
 packages/mobile/README.md                          |  30 ++
 7 files changed, 626 insertions(+), 2 deletions(-)

Fusion-Task-Id: FN-7587

Fusion-Task-Lineage: cc5f08df-4aaf-447d-9c30-237b32191d3f

Co-authored-by: Fusion (runfusion.ai) <noreply@runfusion.ai>
---
 .../app/components/TaskDetailModal.css        |  33 ++
 .../app/components/TaskDetailModal.tsx        |  31 +-
 ...ail.mobile-transition.board-panel.test.tsx | 333 ++++++++++++++++++
 .../TaskDetail.mobile-transition.test.tsx     | 156 ++++++++
 .../app/components/dashboard/MainContent.tsx  |  10 +-
 packages/dashboard/app/styles.css             |  35 ++
 packages/mobile/README.md                     |  30 ++
 7 files changed, 626 insertions(+), 2 deletions(-)
 create mode 100644 packages/dashboard/app/components/__tests__/TaskDetail.mobile-transition.board-panel.test.tsx
 create mode 100644 packages/dashboard/app/components/__tests__/TaskDetail.mobile-transition.test.tsx

diff --git a/packages/dashboard/app/components/TaskDetailModal.css b/packages/dashboard/app/components/TaskDetailModal.css
index d3300f17c2..c4418e0345 100644
--- a/packages/dashboard/app/components/TaskDetailModal.css
+++ b/packages/dashboard/app/components/TaskDetailModal.css
@@ -1715,6 +1715,39 @@ FN-6500 fixes a tablet regression from FN-5599: the task-detail overlay offset a
 
 }
 
+/*
+FNXC:TaskDetailSwipeBack 2026-07-05-12:30:
+FN-7587 — non-interactive predictive-back polish: a short slide/fade enter animation for the
+mobile list/modal/nested task-detail surface, layered purely on top of the unchanged
+FN-7583/FN-7586 dismissal routing (popstate / fusion:native-back / useNavigationHistory stack).
+Gated to mobile via `.task-detail-modal--mobile-transition` (TaskDetailModal.tsx local resize
+listener); desktop never receives this class. A true finger-tracked interactive predictive-back
+is not feasible from a Capacitor single-page WebView today — see task FN-7587 notes.
+*/
+@media (max-width: 768px) {
+  .task-detail-modal--mobile-transition {
+    animation: task-detail-modal-mobile-slide-fade-in var(--duration-normal) ease-out;
+  }
+}
+
+@keyframes task-detail-modal-mobile-slide-fade-in {
+  from {
+    opacity: 0;
+    transform: translateX(var(--space-xl, 24px));
+  }
+
+  to {
+    opacity: 1;
+    transform: translateX(0);
+  }
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .task-detail-modal--mobile-transition {
+    animation: none;
+  }
+}
+
 .detail-actions-menu-item-danger {
   color: var(--color-error);
 }
diff --git a/packages/dashboard/app/components/TaskDetailModal.tsx b/packages/dashboard/app/components/TaskDetailModal.tsx
index 294362fe83..010c127e3b 100644
--- a/packages/dashboard/app/components/TaskDetailModal.tsx
+++ b/packages/dashboard/app/components/TaskDetailModal.tsx
@@ -88,6 +88,8 @@ const ACTIVITY_VIEW_MENU_MAX_HEIGHT = 320;
 const ACTIVITY_VIEW_MENU_OPEN_VIEWPORT_GUARD_MS = 350;
 // FNXC:PlannerOversight 2026-07-04-19:00: FN-7545 — mobile breakpoint for collapsing the oversight action cluster into an overflow menu; matches the `@media (max-width: 768px)` breakpoint used across TaskDetailModal.css.
 const OVERSIGHT_MENU_MOBILE_BREAKPOINT = 768;
+// FNXC:TaskDetailSwipeBack 2026-07-05-12:30: FN-7587 — mobile breakpoint gating the presentation-only predictive-back slide/fade transition on the modal/list/nested task-detail surface; matches OVERSIGHT_MENU_MOBILE_BREAKPOINT/the `@media (max-width: 768px)` convention already used in this file.
+const TASK_DETAIL_MOBILE_TRANSITION_BREAKPOINT = 768;
 
 type ActivityViewMenuPosition = {
   top: number;
@@ -5997,6 +5999,30 @@ export function TaskDetailModal({ onClose, ...props }: TaskDetailModalProps) {
   useModalResizePersist(modalRef, true, "task-detail-modal-size");
   useMobileScrollLock(true);
   const overlayDismissProps = useOverlayDismiss(onClose);
+  /*
+  FNXC:TaskDetailSwipeBack 2026-07-05-12:30:
+  FN-7587 — track the mobile breakpoint locally (mirrors the OVERSIGHT_MENU_MOBILE_BREAKPOINT
+  resize-listener pattern above) so the list/modal/nested task-detail surface gets the same
+  presentation-only predictive-back slide/fade enter transition as the board main-panel
+  (MainContent.tsx), without threading a new isMobile prop through App.tsx/AppModals.tsx. This
+  is presentation-only: it never touches onClose/onRequestClose timing or the underlying
+  useNavigationHistory dismissal routing, and honors prefers-reduced-motion (see
+  TaskDetailModal.css). Defaults false so JSDOM/unit tests keep exercising the desktop (no
+  animation) branch unless a test explicitly narrows the viewport.
+  */
+  const [isMobileTransition, setIsMobileTransition] = useState(false);
+  useEffect(() => {
+    const updateIsMobileTransition = () => {
+      setIsMobileTransition(window.innerWidth <= TASK_DETAIL_MOBILE_TRANSITION_BREAKPOINT);
+    };
+
+    updateIsMobileTransition();
+    window.addEventListener("resize", updateIsMobileTransition);
+
+    return () => {
+      window.removeEventListener("resize", updateIsMobileTransition);
+    };
+  }, []);
 
   return (
     <div
@@ -6005,7 +6031,10 @@ export function TaskDetailModal({ onClose, ...props }: TaskDetailModalProps) {
       role="dialog"
       aria-modal="true"
     >
-      <div className="modal modal-lg task-detail-modal" ref={modalRef}>
+      <div
+        className={`modal modal-lg task-detail-modal${isMobileTransition ? " task-detail-modal--mobile-transition" : ""}`}
+        ref={modalRef}
+      >
         <TaskDetailContent
           {...props}
           onRequestClose={onClose}
diff --git a/packages/dashboard/app/components/__tests__/TaskDetail.mobile-transition.board-panel.test.tsx b/packages/dashboard/app/components/__tests__/TaskDetail.mobile-transition.board-panel.test.tsx
new file mode 100644
index 0000000000..25b98b7892
--- /dev/null
+++ b/packages/dashboard/app/components/__tests__/TaskDetail.mobile-transition.board-panel.test.tsx
@@ -0,0 +1,333 @@
+/**
+ * FN-7587 companion suite: board main-panel (MainContent.tsx) mobile predictive-back
+ * transition class gating.
+ *
+ * FNXC:TaskDetailSwipeBack 2026-07-05-12:45:
+ * Split out from `TaskDetail.mobile-transition.test.tsx` because this surface needs the
+ * full App-level mock harness (mirrors `TaskDetail.swipe-back.test.tsx`'s harness: Board/
+ * ListView/TaskDetailModal module mocks, real lucide-react icons via Header) which conflicts
+ * with the TaskDetailModal-focused `test-helpers` harness's fixed lucide-react icon allowlist
+ * if both are combined in one test module (vi.mock hoisting collides).
+ *
+ * Asserts only the class-gating invariant: `.task-detail-main-panel--mobile-transition` is
+ * present on mobile and absent on desktop. Does not re-derive dismissal-routing coverage,
+ * which stays the responsibility of `TaskDetail.swipe-back.test.tsx` /
+ * `navigation-history.test.tsx` (run unmodified per PROMPT.md).
+ */
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { render, screen, fireEvent, waitFor } from "@testing-library/react";
+import type { Settings, Task } from "@fusion/core";
+import type { ProjectInfo } from "../../api";
+
+const defaultSettings: Settings = {
+  maxConcurrent: 2,
+  maxWorktrees: 4,
+  pollIntervalMs: 15000,
+  groupOverlappingFiles: false,
+  autoMerge: true,
+  recycleWorktrees: false,
+  worktreeInitCommand: "",
+  testCommand: "",
+  buildCommand: "",
+  experimentalFeatures: { insights: true, roadmap: true, skillsView: true, agentsView: true, evalsView: true, todoView: true, leftSidebarNav: false, rightDock: false },
+};
+
+const mockSubscribeSse = vi.fn((..._args: any[]) => vi.fn());
+vi.mock("../../sse-bus", () => ({
+  subscribeSse: (...args: any[]) => mockSubscribeSse(...args),
+}));
+
+vi.mock("../../api", async (importOriginal) => {
+  const { createDashboardApiMock } = await import("../../test/mockApi");
+  return createDashboardApiMock(() => importOriginal<typeof import("../../api")>(), {
+    fetchTasks: vi.fn(() => Promise.resolve([])),
+    fetchConfig: vi.fn(() => Promise.resolve({ maxConcurrent: 2, rootDir: "/workspace/project" })),
+    fetchSettings: vi.fn(() => Promise.resolve({ ...defaultSettings })),
+    updateSettings: vi.fn(() => Promise.resolve({ ...defaultSettings })),
+    fetchGlobalSettings: vi.fn(() => Promise.resolve({})),
+    fetchAuthStatus: vi.fn(() => Promise.resolve({ providers: [] })),
+    fetchModels: vi.fn(() => Promise.resolve({ models: [], favoriteProviders: [], favoriteModels: [] })),
+    fetchGitRemotes: vi.fn(() => Promise.resolve([])),
+    fetchAgents: vi.fn(() => Promise.resolve([])),
+    fetchTaskDetail: vi.fn((id: string) => Promise.resolve({ id, title: `Task ${id}` })),
+    fetchUnreadCount: vi.fn(() => Promise.resolve({ unreadCount: 0 })),
+    fetchPluginDashboardViews: vi.fn(() => Promise.resolve([])),
+    fetchExecutorStats: vi.fn(() => Promise.resolve({
+      globalPause: false,
+      enginePaused: false,
+      maxConcurrent: 2,
+      lastActivityAt: new Date().toISOString(),
+    })),
+    fetchScripts: vi.fn(() => Promise.resolve({})),
+    runScript: vi.fn(() => Promise.resolve({ sessionId: "sess-1", command: "echo" })),
+    killPtyTerminalSession: vi.fn(() => Promise.resolve({ killed: true })),
+  });
+});
+
+const mockCreateTask = vi.fn();
+const mockUseTasks = vi.fn(() => ({
+  tasks: [],
+  createTask: mockCreateTask,
+  moveTask: vi.fn(),
+  deleteTask: vi.fn(),
+  mergeTask: vi.fn(),
+  retryTask: vi.fn(),
+  updateTask: vi.fn(),
+  duplicateTask: vi.fn(),
+  archiveTask: vi.fn(),
+  unarchiveTask: vi.fn(),
+  archiveAllDone: vi.fn(),
+  refreshTasks: vi.fn(),
+}));
+vi.mock("../../hooks/useTasks", () => ({
+  useTasks: (_options?: any) => mockUseTasks(),
+}));
+
+vi.mock("../../hooks/useInsights", () => ({
+  useInsights: () => ({
+    sections: [], loading: false, error: null, latestRun: null,
+    isRunInFlight: false, runError: null, refresh: vi.fn(),
+    runInsights: vi.fn(), dismiss: vi.fn(), createTask: vi.fn(),
+    dismissStates: new Map(), createTaskStates: new Map(),
+    totalCount: 0, dismissedCount: 0,
+  }),
+}));
+
+vi.mock("../../hooks/useRemoteNodeData", () => ({
+  useRemoteNodeData: vi.fn(() => ({
+    projects: [], tasks: [], health: null, loading: false,
+    error: null, refresh: vi.fn(),
+  })),
+}));
+
+vi.mock("../../hooks/useRemoteNodeEvents", () => ({
+  useRemoteNodeEvents: vi.fn(() => ({ isConnected: false, lastEvent: null })),
+}));
+
+vi.mock("../../hooks/useBackgroundSessions", () => ({
+  useBackgroundSessions: vi.fn(() => ({
+    sessions: [], generating: false, needsInput: false,
+    planningSessions: [], dismissSession: vi.fn(),
+  })),
+}));
+
+const mockNodeContextValue = {
+  currentNode: null, currentNodeId: null, isRemote: false,
+  setCurrentNode: vi.fn(), clearCurrentNode: vi.fn(),
+};
+vi.mock("../../context/NodeContext", () => ({
+  NodeProvider: ({ children }: { children: React.ReactNode }) => children,
+  useNodeContext: vi.fn(() => mockNodeContextValue),
+}));
+
+vi.mock("../../components/model-onboarding-state", () => ({
+  isOnboardingResumable: () => false,
+  getOnboardingResumeStep: () => null,
+  getOnboardingState: () => null,
+  saveOnboardingState: vi.fn(),
+  clearOnboardingState: vi.fn(),
+  isOnboardingCompleted: () => false,
+  markOnboardingCompleted: vi.fn(),
+  markStepSkipped: vi.fn(),
+  getOnboardingCompletedAt: () => null,
+  getSkippedSteps: () => [],
+  getStepData: () => null,
+  ONBOARDING_FLOW_STEPS: ["ai-setup", "github", "project-setup", "agent", "first-task"],
+}));
+
+vi.mock("../../components/Board", () => ({
+  Board: ({ tasks, onOpenDetail }: { tasks: Task[]; onOpenDetail: (task: Task) => void }) => (
+    <div data-testid="board-view">
+      {tasks.map((task) => (
+        <button key={task.id} type="button" data-testid={`open-task-${task.id}`} onClick={() => onOpenDetail(task)}>
+          {task.title}
+        </button>
+      ))}
+    </div>
+  ),
+}));
+
+vi.mock("../../components/ListView", () => ({
+  ListView: () => <div data-testid="list-view" />,
+}));
+
+vi.mock("../../components/TaskDetailModal", () => ({
+  TaskDetailModal: () => null,
+  TaskDetailContent: ({ task }: { task: { id: string; title?: string } }) => (
+    <div data-testid="task-detail-main-panel-content">
+      <h2>{task.title ?? task.id}</h2>
+    </div>
+  ),
+}));
+
+vi.mock("../../components/SettingsModal", () => ({
+  SettingsModal: () => null,
+  SettingsView: () => <div data-testid="settings-view">Settings</div>,
+}));
+
+vi.mock("../../components/GitHubImportModal", () => ({ GitHubImportModal: () => null }));
+vi.mock("../../components/PlanningModeModal", () => ({ PlanningModeModal: () => null }));
+vi.mock("../../components/AgentsView", () => ({ AgentsView: () => <div data-testid="agents-view">Agents</div> }));
+vi.mock("../../components/ResearchView", () => ({ ResearchView: () => <div data-testid="research-view">Research</div> }));
+vi.mock("../../components/EvalsView", () => ({ EvalsView: () => <div data-testid="evals-view">Evals</div> }));
+vi.mock("../../components/TodoView", () => ({ TodoView: () => <div data-testid="todo-view">Todo</div> }));
+vi.mock("../../components/QuickChatFAB", () => ({ QuickChatFAB: () => null }));
+vi.mock("../../components/ScriptsModal", () => ({ ScriptsModal: () => null }));
+vi.mock("../../components/TerminalModal", () => ({ TerminalModal: () => null }));
+vi.mock("../../components/FileBrowser", () => ({ FileBrowserModal: () => null }));
+vi.mock("../../components/ActivityLogModal", () => ({ ActivityLogModal: () => null }));
+vi.mock("../../components/GitManagerModal", () => ({ GitManagerModal: () => null }));
+vi.mock("../../components/SchedulesModal", () => ({ SchedulesModal: () => null }));
+vi.mock("../../components/WorkflowEditorModal", () => ({ WorkflowEditorModal: () => null }));
+vi.mock("../../components/AgentsModal", () => ({ AgentsModal: () => null }));
+vi.mock("../../components/SubtaskBreakdownModal", () => ({ SubtaskBreakdownModal: () => null }));
+vi.mock("../../components/UsageModal", () => ({ UsageModal: () => null }));
+vi.mock("../../components/ModelOnboardingModal", () => ({ ModelOnboardingModal: () => null }));
+vi.mock("../../components/SetupWizardModal", () => ({ SetupWizardModal: () => null }));
+vi.mock("../../components/GroupTaskModal", () => ({ GroupTaskModal: () => null }));
+vi.mock("../../components/ProjectSelector", () => ({ ProjectSelector: () => <div /> }));
+vi.mock("../../components/ProjectCard", () => ({ ProjectCard: () => <div /> }));
+vi.mock("../../components/Sidebar", () => ({ Sidebar: () => <div /> }));
+vi.mock("../../components/Header", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("../../components/Header")>();
+  return {
+    ...actual,
+    Header: () => <div><button title="Settings" type="button">Settings</button></div>,
+  };
+});
+vi.mock("../../components/MobileNavBar", () => ({ MobileNavBar: () => null }));
+vi.mock("../../components/RightDock", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("../../components/RightDock")>();
+  return {
+    ...actual,
+    RightDock: () => null,
+    RightDockExpandModal: () => null,
+  };
+});
+
+const mockUseProjects = vi.fn(() => ({ projects: [], loading: false, error: null }));
+const mockCurrentProjectState = {
+  currentProject: {
+    id: "proj-1",
+    name: "Test Project",
+    path: "/test",
+    status: "active",
+    isolationMode: "in-process",
+    createdAt: "",
+    updatedAt: "",
+  } as ProjectInfo,
+  loading: false,
+  setCurrentProject: vi.fn(),
+  clearCurrentProject: vi.fn(),
+};
+vi.mock("../../hooks/useProjects", () => ({ useProjects: () => mockUseProjects() }));
+vi.mock("../../hooks/useCurrentProject", () => ({
+  useCurrentProject: () => mockCurrentProjectState,
+}));
+vi.mock("../../hooks/useNodes", () => ({
+  useNodes: vi.fn(() => ({
+    nodes: [], loading: false, error: null,
+    refresh: vi.fn(), register: vi.fn(), update: vi.fn(), unregister: vi.fn(), healthCheck: vi.fn(),
+  })),
+}));
+
+const mockUseViewportMode = vi.fn(() => "desktop");
+vi.mock("../../hooks/useViewportMode", () => ({
+  MOBILE_MEDIA_QUERY: "(max-width: 768px), (max-height: 480px)",
+  getViewportMode: () => mockUseViewportMode(),
+  isMobileViewport: () => mockUseViewportMode() === "mobile",
+  useViewportMode: (..._args: unknown[]) => mockUseViewportMode(..._args),
+}));
+
+const mockUseMobileKeyboard = vi.fn(() => ({
+  keyboardOverlap: 0, viewportHeight: null, viewportOffsetTop: 0, keyboardOpen: false,
+}));
+vi.mock("../../hooks/useMobileKeyboard", () => ({
+  useMobileKeyboard: (..._args: unknown[]) => mockUseMobileKeyboard(..._args),
+}));
+
+import { App } from "../../App";
+
+function makeBoardTask(id: string, title: string): Task {
+  return {
+    id,
+    title,
+    description: "Test task description",
+    column: "todo",
+    status: "todo",
+    createdAt: new Date(0).toISOString(),
+    updatedAt: new Date(0).toISOString(),
+  } as Task;
+}
+
+async function renderAppAndWait(expectedTestId: string = "board-view") {
+  const result = render(<App />);
+  await waitFor(() => {
+    expect(screen.getByTestId(expectedTestId)).toBeTruthy();
+  });
+  return result;
+}
+
+describe("Board main-panel task-detail — mobile transition class gating (MainContent.tsx)", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockSubscribeSse.mockReset();
+    mockSubscribeSse.mockReturnValue(vi.fn());
+    mockUseTasks.mockReset();
+  });
+
+  it("applies the mobile transition class to the board main-panel surface when the viewport is mobile", async () => {
+    mockUseViewportMode.mockReturnValue("mobile");
+    const task = makeBoardTask("FN-1", "Board Detail");
+    mockUseTasks.mockImplementation(() => ({
+      tasks: [task],
+      createTask: mockCreateTask,
+      moveTask: vi.fn(),
+      deleteTask: vi.fn(),
+      mergeTask: vi.fn(),
+      retryTask: vi.fn(),
+      updateTask: vi.fn(),
+      duplicateTask: vi.fn(),
+      archiveTask: vi.fn(),
+      unarchiveTask: vi.fn(),
+      archiveAllDone: vi.fn(),
+      refreshTasks: vi.fn(),
+    }));
+
+    await renderAppAndWait("board-view");
+    fireEvent.click(screen.getByTestId("open-task-FN-1"));
+
+    await waitFor(() => {
+      expect(screen.getByTestId("task-detail-main-panel-content")).toBeInTheDocument();
+    });
+    expect(document.querySelector(".task-detail-main-panel--mobile-transition")).toBeInTheDocument();
+  });
+
+  it("does NOT apply the mobile transition class to the board main-panel surface on desktop", async () => {
+    mockUseViewportMode.mockReturnValue("desktop");
+    const task = makeBoardTask("FN-1", "Board Detail");
+    mockUseTasks.mockImplementation(() => ({
+      tasks: [task],
+      createTask: mockCreateTask,
+      moveTask: vi.fn(),
+      deleteTask: vi.fn(),
+      mergeTask: vi.fn(),
+      retryTask: vi.fn(),
+      updateTask: vi.fn(),
+      duplicateTask: vi.fn(),
+      archiveTask: vi.fn(),
+      unarchiveTask: vi.fn(),
+      archiveAllDone: vi.fn(),
+      refreshTasks: vi.fn(),
+    }));
+
+    await renderAppAndWait("board-view");
+    fireEvent.click(screen.getByTestId("open-task-FN-1"));
+
+    await waitFor(() => {
+      expect(screen.getByTestId("task-detail-main-panel-content")).toBeInTheDocument();
+    });
+    expect(document.querySelector(".task-detail-main-panel")).toBeInTheDocument();
+    expect(document.querySelector(".task-detail-main-panel--mobile-transition")).not.toBeInTheDocument();
+  });
+});
diff --git a/packages/dashboard/app/components/__tests__/TaskDetail.mobile-transition.test.tsx b/packages/dashboard/app/components/__tests__/TaskDetail.mobile-transition.test.tsx
new file mode 100644
index 0000000000..f79052fdf1
--- /dev/null
+++ b/packages/dashboard/app/components/__tests__/TaskDetail.mobile-transition.test.tsx
@@ -0,0 +1,156 @@
+/**
+ * Focused regression coverage for the FN-7587 mobile task-detail predictive-back
+ * slide/fade transition polish.
+ *
+ * FNXC:TaskDetailSwipeBack 2026-07-05-12:45:
+ * This suite asserts ONLY the presentation-layer invariant this task adds:
+ *  - the mobile transition class is applied to the modal/list/nested surface when the
+ *    viewport is mobile;
+ *  - the class is absent on desktop, and does not linger after re-rendering desktop-width;
+ *  - the CSS neutralizes the animation under `prefers-reduced-motion: reduce`
+ *    (jsdom cannot execute CSS keyframe animations, so this is asserted statically
+ *    against the stylesheet source, mirroring the project's existing
+ *    `TaskDetailModal.css.test.ts` / `TaskDetailModal.github-tracking-enable.css.test.ts`
+ *    pattern of asserting CSS text rather than computed animation state).
+ *
+ * Board main-panel gating (MainContent.tsx) is covered separately in
+ * `TaskDetail.mobile-transition.board-panel.test.tsx` because that surface requires the
+ * full App-level mock harness (Board/ListView/TaskDetailModal module mocks + real
+ * lucide-react icons via Header), which conflicts with this file's TaskDetailModal-focused
+ * `test-helpers` harness (fixed lucide-react icon allowlist) if combined in one module.
+ *
+ * This suite deliberately does NOT re-derive dismissal-routing coverage — that remains the
+ * sole responsibility of `TaskDetail.swipe-back.test.tsx` and `navigation-history.test.tsx`,
+ * which this task runs unmodified (see PROMPT.md Step 0/3) to prove the animation layer does
+ * not perturb the `useNavigationHistory` / `popstate` / `fusion:native-back` invariant.
+ */
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { render, screen, waitFor } from "@testing-library/react";
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import {
+  makeTask,
+  noop,
+  noopMove,
+  noopDelete,
+  noopMerge,
+  noopOpenDetail,
+  setupTaskDetailModalHooks,
+} from "./TaskDetailModal.test-helpers";
+import { TaskDetailModal } from "../TaskDetailModal";
+
+const MOBILE_WIDTH = 375;
+const DESKTOP_WIDTH = 1024;
+
+function setViewportWidth(width: number): void {
+  Object.defineProperty(window, "innerWidth", { writable: true, configurable: true, value: width });
+  window.dispatchEvent(new Event("resize"));
+}
+
+describe("Task-detail mobile predictive-back transition — CSS invariants", () => {
+  it("styles.css neutralizes the board main-panel transition under prefers-reduced-motion", () => {
+    const css = readFileSync(resolve(__dirname, "../../styles.css"), "utf8");
+    expect(css).toContain(".task-detail-main-panel--mobile-transition");
+    expect(css).toContain("@keyframes task-detail-mobile-slide-fade-in");
+    const reducedMotionBlock = css.slice(css.indexOf("@media (prefers-reduced-motion: reduce) {\n  .task-detail-main-panel--mobile-transition"));
+    expect(reducedMotionBlock.slice(0, 200)).toContain("animation: none;");
+  });
+
+  it("TaskDetailModal.css neutralizes the modal/list/nested transition under prefers-reduced-motion", () => {
+    const css = readFileSync(resolve(__dirname, "../TaskDetailModal.css"), "utf8");
+    expect(css).toContain(".task-detail-modal--mobile-transition");
+    expect(css).toContain("@keyframes task-detail-modal-mobile-slide-fade-in");
+    const reducedMotionBlock = css.slice(css.indexOf("@media (prefers-reduced-motion: reduce) {\n  .task-detail-modal--mobile-transition"));
+    expect(reducedMotionBlock.slice(0, 200)).toContain("animation: none;");
+  });
+});
+
+describe("TaskDetailModal wrapper — mobile transition class gating (modal/list/nested surface)", () => {
+  setupTaskDetailModalHooks();
+
+  beforeEach(() => {
+    setViewportWidth(MOBILE_WIDTH);
+  });
+
+  afterEach(() => {
+    setViewportWidth(DESKTOP_WIDTH);
+  });
+
+  it("applies the mobile transition class to the modal surface when the viewport is mobile", async () => {
+    setViewportWidth(MOBILE_WIDTH);
+
+    render(
+      <TaskDetailModal
+        task={makeTask({ id: "FN-300" })}
+        onClose={noop}
+        onMoveTask={noopMove}
+        onDeleteTask={noopDelete}
+        onMergeTask={noopMerge}
+        onOpenDetail={noopOpenDetail}
+        addToast={noop}
+      />,
+    );
+
+    await waitFor(() => {
+      expect(document.querySelector(".task-detail-modal--mobile-transition")).toBeInTheDocument();
+    });
+  });
+
+  it("does NOT apply the mobile transition class on desktop", async () => {
+    setViewportWidth(DESKTOP_WIDTH);
+
+    render(
+      <TaskDetailModal
+        task={makeTask({ id: "FN-301" })}
+        onClose={noop}
+        onMoveTask={noopMove}
+        onDeleteTask={noopDelete}
+        onMergeTask={noopMerge}
+        onOpenDetail={noopOpenDetail}
+        addToast={noop}
+      />,
+    );
+
+    await waitFor(() => {
+      expect(document.querySelector(".task-detail-modal")).toBeInTheDocument();
+    });
+    expect(document.querySelector(".task-detail-modal--mobile-transition")).not.toBeInTheDocument();
+  });
+
+  it("does not leave a lingering transition class after re-rendering at desktop width", async () => {
+    setViewportWidth(MOBILE_WIDTH);
+
+    const { rerender } = render(
+      <TaskDetailModal
+        task={makeTask({ id: "FN-302" })}
+        onClose={noop}
+        onMoveTask={noopMove}
+        onDeleteTask={noopDelete}
+        onMergeTask={noopMerge}
+        onOpenDetail={noopOpenDetail}
+        addToast={noop}
+      />,
+    );
+
+    await waitFor(() => {
+      expect(document.querySelector(".task-detail-modal--mobile-transition")).toBeInTheDocument();
+    });
+
+    setViewportWidth(DESKTOP_WIDTH);
+    rerender(
+      <TaskDetailModal
+        task={makeTask({ id: "FN-302" })}
+        onClose={noop}
+        onMoveTask={noopMove}
+        onDeleteTask={noopDelete}
+        onMergeTask={noopMerge}
+        onOpenDetail={noopOpenDetail}
+        addToast={noop}
+      />,
+    );
+
+    await waitFor(() => {
+      expect(document.querySelector(".task-detail-modal--mobile-transition")).not.toBeInTheDocument();
+    });
+  });
+});
diff --git a/packages/dashboard/app/components/dashboard/MainContent.tsx b/packages/dashboard/app/components/dashboard/MainContent.tsx
index 403408d45f..428ba00ac4 100644
--- a/packages/dashboard/app/components/dashboard/MainContent.tsx
+++ b/packages/dashboard/app/components/dashboard/MainContent.tsx
@@ -751,7 +751,15 @@ export function MainContent({
     }
     return (
       <PageErrorBoundary>
-        <div className="task-detail-main-panel">
+        {/*
+        FNXC:TaskDetailSwipeBack 2026-07-05-12:30:
+        FN-7587 — presentation-only predictive-back polish layered on top of the unchanged
+        FN-7583/FN-7586 dismissal routing (popstate / fusion:native-back / useNavigationHistory
+        stack). The `--mobile-transition` modifier only adds a CSS enter animation gated to the
+        existing `isMobile` prop; it never defers or reorders when onRequestClose/onBackToBoard
+        fire, and honors prefers-reduced-motion (see styles.css).
+        */}
+        <div className={`task-detail-main-panel${isMobile ? " task-detail-main-panel--mobile-transition" : ""}`}>
           <div className="task-detail-main-panel-body">
             <TaskDetailContent
               task={liveDetailTask}
diff --git a/packages/dashboard/app/styles.css b/packages/dashboard/app/styles.css
index e012f690ce..4436a1f9bb 100644
--- a/packages/dashboard/app/styles.css
+++ b/packages/dashboard/app/styles.css
@@ -3958,3 +3958,38 @@ The panel and its body must be width-bounded (width:100%; min-width:0; max-width
   overflow-x: hidden;
   overflow-y: auto;
 }
+
+/*
+FNXC:TaskDetailSwipeBack 2026-07-05-12:30:
+FN-7587 — non-interactive predictive-back polish: a short slide/fade enter animation for the
+mobile full-panel task detail, layered purely on top of the unchanged FN-7583/FN-7586 dismissal
+routing (popstate / fusion:native-back / useNavigationHistory stack). Mobile-only (gated by the
+existing `isMobile` prop in MainContent.tsx); desktop never receives this class. A true
+finger-tracked interactive predictive-back is not feasible from a Capacitor single-page WebView
+on either platform today (WKWebView exposes no interactive-progress callback to JS; Android's
+system predictive-back preview is not driveable from the in-page DOM) — see task FN-7587 notes
+and the filed interactive-predictive-back follow-up task.
+*/
+@media (max-width: 768px) {
+  .task-detail-main-panel--mobile-transition {
+    animation: task-detail-mobile-slide-fade-in var(--duration-normal) ease-out;
+  }
+}
+
+@keyframes task-detail-mobile-slide-fade-in {
+  from {
+    opacity: 0;
+    transform: translateX(var(--space-xl, 24px));
+  }
+
+  to {
+    opacity: 1;
+    transform: translateX(0);
+  }
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .task-detail-main-panel--mobile-transition {
+    animation: none;
+  }
+}
diff --git a/packages/mobile/README.md b/packages/mobile/README.md
index acbc994cdc..122bd21dd6 100644
--- a/packages/mobile/README.md
+++ b/packages/mobile/README.md
@@ -45,6 +45,36 @@ Manual invocation (e.g. after a bare `npx cap sync` outside `build:mobile`):
 pnpm --filter @fusion/mobile patch:android-manifest
 ```
 
+### Mobile task-detail predictive-back transition (FN-7587)
+
+FN-7583 (Android back-gesture parity) and FN-7586 (iOS edge-swipe-back parity) made native
+"back" gestures **functionally** dismiss Fusion's mobile task-detail surfaces (board
+main-panel, list-mobile, modal, and nested detail) through the dashboard's shared
+nav-history invariant (`useNavigationHistory` / `popstate` / `fusion:native-back`). FN-7587
+layers a **presentation-only** slide/fade transition on top of that unchanged routing:
+
+- Mobile/native-only — the transition is gated to the mobile viewport (`<= 768px`, matching
+  the existing `isMobile`/`OVERSIGHT_MENU_MOBILE_BREAKPOINT` convention in the dashboard);
+  desktop task-detail never receives the animation class.
+- Non-interactive — the transition is a short CSS `@keyframes` slide/fade (~200ms) triggered
+  by mount/prop-state change, not by gesture progress. It does **not** intercept, delay, or
+  reorder when the `useNavigationHistory` pop / `fusion:native-back` / empty-stack fallback
+  fires; the animation is purely a CSS class applied to the already-real DOM node.
+- Honors `prefers-reduced-motion: reduce` (neutralizes to an instant, transform-free show),
+  mirroring the dashboard's existing reduced-motion convention (`WorkflowSwitcher.css`,
+  `TopProgressBar.css`).
+- **Interactive predictive-back is not implemented** and is not feasible today from a
+  Capacitor single-page WebView on either platform: iOS's `allowsBackForwardNavigationGestures`
+  gesture (used by FN-7586) exposes only a discrete `popstate` on commit, with no
+  interactive-progress callback reachable from JS; Android's OS-owned predictive-back preview
+  animates outside the single-Activity WebView and is not driveable from in-page DOM. A
+  follow-up task is filed to revisit this if/when platform APIs expose gesture-progress
+  callbacks to JS.
+
+Implementation lives entirely in the dashboard package (`packages/dashboard/app/styles.css`,
+`packages/dashboard/app/components/TaskDetailModal.css`, `MainContent.tsx`,
+`TaskDetailModal.tsx`) — no mobile-shell-native code changes were required for this task.
+
 ### Regression coverage locked by tests
 
 `packages/mobile/src/__tests__/connection-profiles.test.ts`, `native-shell.test.ts`, and `qr-scanner.test.ts` now lock these contracts:

From 09a10bc5e70991d40272e2eee64389caa6dfeeb1 Mon Sep 17 00:00:00 2001
From: gsxdsm <gsxdsm@users.noreply.github.com>
Date: Sun, 5 Jul 2026 13:11:15 -0700
Subject: [PATCH 44/65] FN-7592: replace overseer badge text label with a
 colored Eye icon

Swaps the planner-overseer status badge from an uppercase text pill to a compact icon glyph, keeping accessibility text on aria-label/title.

- Render a small lucide-react Eye icon instead of the state-label text inside the overseer badge
- Keep the readable state name on aria-label and the composed tooltip on title for accessibility
- Add per-state coloring (watching/steering/recovering/awaiting-confirmation) keyed off the data-planner-overseer-state attribute in TaskCard.css, sized tightly around the icon
- Update TaskCard tests to assert the icon renders and the accessible name moved to aria-label instead of textContent

Files changed:
 packages/dashboard/app/components/TaskCard.css     | 40 ++++++++++++++++++++++
 packages/dashboard/app/components/TaskCard.tsx     | 14 ++++++--
 .../app/components/__tests__/TaskCard.test.tsx     | 25 +++++++++++---
 3 files changed, 72 insertions(+), 7 deletions(-)

Fusion-Task-Id: FN-7592

Fusion-Task-Lineage: d7ca93a6-9236-4fa0-a829-80f5b99dbd5f

Co-authored-by: Fusion (runfusion.ai) <noreply@runfusion.ai>
---
 .../dashboard/app/components/TaskCard.css     | 40 +++++++++++++++++++
 .../dashboard/app/components/TaskCard.tsx     | 14 ++++++-
 .../components/__tests__/TaskCard.test.tsx    | 25 +++++++++---
 3 files changed, 72 insertions(+), 7 deletions(-)

diff --git a/packages/dashboard/app/components/TaskCard.css b/packages/dashboard/app/components/TaskCard.css
index 1443982d39..e2d664f432 100644
--- a/packages/dashboard/app/components/TaskCard.css
+++ b/packages/dashboard/app/components/TaskCard.css
@@ -397,6 +397,46 @@ not a restyle of the ordinary manual-approval badge.
   border-color: color-mix(in srgb, var(--color-warning) 45%, transparent);
 }
 
+/*
+FNXC:PlannerOversight 2026-07-05-00:00:
+FN-7592 replaces the overseer badge's uppercase text label with a small `Eye` icon so it
+reads as a compact glyph rather than a wide pill. Size the badge to the icon (no min-width,
+tight padding) and color it per `PlannerOverseerState` via the `data-planner-overseer-state`
+attribute so operators can distinguish watching/steering/recovering/awaiting-confirmation at
+a glance without reading text. Colors reuse existing semantic tokens: neutral/info for the
+passive "watching" state, warning for the more active "steering"/"recovering" states, and the
+triage token for "awaiting-confirmation" (a human-decision hold), matching the hue conventions
+used elsewhere in this file (e.g. .card-oversight-badge--*, .card-status-badge--triage).
+*/
+.card-planner-overseer-state {
+  padding: calc(var(--space-xs) / 2);
+  line-height: 0;
+}
+
+.card-planner-overseer-state svg {
+  width: 12px;
+  height: 12px;
+}
+
+.card-planner-overseer-state[data-planner-overseer-state="watching"] {
+  background: color-mix(in srgb, var(--color-info) 15%, transparent);
+  color: var(--color-info);
+  border-color: color-mix(in srgb, var(--color-info) 40%, transparent);
+}
+
+.card-planner-overseer-state[data-planner-overseer-state="steering"],
+.card-planner-overseer-state[data-planner-overseer-state="recovering"] {
+  background: color-mix(in srgb, var(--color-warning) 18%, transparent);
+  color: var(--color-warning);
+  border-color: color-mix(in srgb, var(--color-warning) 45%, transparent);
+}
+
+.card-planner-overseer-state[data-planner-overseer-state="awaiting-confirmation"] {
+  background: color-mix(in srgb, var(--triage) 18%, transparent);
+  color: var(--triage);
+  border-color: color-mix(in srgb, var(--triage) 45%, transparent);
+}
+
 .card.awaiting-input {
   border-left: 3px solid var(--color-warning);
   background: color-mix(in srgb, var(--color-warning) 6%, transparent);
diff --git a/packages/dashboard/app/components/TaskCard.tsx b/packages/dashboard/app/components/TaskCard.tsx
index 2bcb016f3d..e312111e4e 100644
--- a/packages/dashboard/app/components/TaskCard.tsx
+++ b/packages/dashboard/app/components/TaskCard.tsx
@@ -3,7 +3,7 @@ import { useTranslation } from "react-i18next";
 import type { TFunction } from "i18next";
 import { memo, useCallback, useState, useRef, useEffect, useLayoutEffect, useMemo, type CSSProperties, type ReactElement } from "react";
 import { createPortal } from "react-dom";
-import { Link, Clock, Layers, Pencil, ChevronDown, Folder, Target, Bot, Trash2, RotateCw, Zap, GitBranch, GitPullRequest, AlertTriangle, ArrowUpRight } from "lucide-react";
+import { Link, Clock, Layers, Pencil, ChevronDown, Folder, Target, Bot, Trash2, RotateCw, Zap, GitBranch, GitPullRequest, AlertTriangle, ArrowUpRight, Eye } from "lucide-react";
 import type { Task, TaskDetail, Column, ColumnId, PrInfo, IssueInfo, TaskPriority, GithubIssueAction, MergeResult, PlannerOversightLevel } from "@fusion/core";
 import {
   DEFAULT_PLANNER_OVERSIGHT_LEVEL,
@@ -2889,15 +2889,25 @@ function TaskCardComponent({
           board payload) plus a repaint-correct memo comparator; FN-7516 owns the styled
           badge/design and surface-by-surface rendering. This is a minimal, type-safe,
           guarded read only — nothing renders for an absent field or the "idle" state.
+
+          FNXC:PlannerOversight 2026-07-05-00:00:
+          FN-7592 replaces the uppercase text label with a small state-colored `Eye` icon so
+          the badge reads as a compact glyph. The readable label and composed tooltip stay
+          available for accessibility: `aria-label` carries the state name (screen readers)
+          and `title` keeps the existing tooltip (hover). Per-state color comes from the
+          `data-planner-overseer-state` attribute in TaskCard.css — do not fork the label
+          logic here; `plannerOverseerStateLabel`/`plannerOverseerBadgeTooltip` remain the
+          single source of truth.
         */}
         {task.plannerOverseerState && task.plannerOverseerState.state !== "idle" && (
           <span
             className="card-status-badge card-planner-overseer-state"
             title={plannerOverseerBadgeTooltip(task.plannerOverseerState, t)}
+            aria-label={plannerOverseerStateLabel(task.plannerOverseerState.state, t)}
             data-testid="planner-overseer-state-badge"
             data-planner-overseer-state={task.plannerOverseerState.state}
           >
-            {plannerOverseerStateLabel(task.plannerOverseerState.state, t)}
+            <Eye aria-hidden="true" />
           </span>
         )}
         {showStalledReview && stalledReview && (
diff --git a/packages/dashboard/app/components/__tests__/TaskCard.test.tsx b/packages/dashboard/app/components/__tests__/TaskCard.test.tsx
index 0f48411f2d..9cd637d2ab 100644
--- a/packages/dashboard/app/components/__tests__/TaskCard.test.tsx
+++ b/packages/dashboard/app/components/__tests__/TaskCard.test.tsx
@@ -26,7 +26,9 @@ vi.mock("lucide-react", () => ({
   Zap: () => <svg data-testid="icon-zap" />,
   AlertTriangle: () => null,
   ArrowUpRight: () => null,
-  Eye: () => null,
+  // FN-7592: the overseer badge now renders an icon child instead of a text label,
+  // so tests must see a real SVG (like Zap) rather than a no-op render.
+  Eye: () => <svg data-testid="icon-eye" />,
 }));
 
 vi.mock("../ProviderIcon", () => ({
@@ -317,9 +319,13 @@ describe("TaskCard", () => {
 
     render(<TaskCard task={task} onOpenDetail={noop} addToast={noop} />);
 
+    // FN-7592: the badge is now an icon-only glyph. The readable label moved from
+    // textContent to aria-label; the composed tooltip is unchanged on title.
     const badge = screen.getByTestId("planner-overseer-state-badge");
-    expect(badge.textContent).not.toBe("awaiting-confirmation");
-    expect(badge.textContent).toBe("Awaiting confirmation");
+    expect(badge.querySelector("svg")).toBeInTheDocument();
+    expect(badge.getAttribute("aria-label")).not.toBe("awaiting-confirmation");
+    expect(badge.getAttribute("aria-label")).toBe("Awaiting confirmation");
+    expect(badge.getAttribute("data-planner-overseer-state")).toBe("awaiting-confirmation");
 
     const title = badge.getAttribute("title") ?? "";
     expect(title).not.toBe("Planner overseer: awaiting-confirmation");
@@ -343,8 +349,12 @@ describe("TaskCard", () => {
       },
     });
     const { unmount } = render(<TaskCard task={watchingTask} onOpenDetail={noop} addToast={noop} />);
+    // FN-7592: icon-only badge — assert the accessible name via aria-label and the
+    // per-state color hook via data-planner-overseer-state, not raw text content.
     let badge = screen.getByTestId("planner-overseer-state-badge");
-    expect(badge.textContent).toBe("Overseer watching");
+    expect(badge.querySelector("svg")).toBeInTheDocument();
+    expect(badge.getAttribute("aria-label")).toBe("Overseer watching");
+    expect(badge.getAttribute("data-planner-overseer-state")).toBe("watching");
     expect(badge.getAttribute("title")).not.toMatch(/undefined/);
     unmount();
 
@@ -361,7 +371,12 @@ describe("TaskCard", () => {
     });
     render(<TaskCard task={recoveringTask} onOpenDetail={noop} addToast={noop} />);
     badge = screen.getByTestId("planner-overseer-state-badge");
-    expect(badge.textContent).toBe("Overseer recovering");
+    expect(badge.querySelector("svg")).toBeInTheDocument();
+    expect(badge.getAttribute("aria-label")).toBe("Overseer recovering");
+    // Distinct states expose distinct data-planner-overseer-state values, which is the
+    // hook TaskCard.css keys per-state color off of (jsdom cannot compute color-mix()).
+    expect(badge.getAttribute("data-planner-overseer-state")).toBe("recovering");
+    expect(badge.getAttribute("data-planner-overseer-state")).not.toBe("watching");
     const title = badge.getAttribute("title") ?? "";
     expect(title).not.toMatch(/undefined/);
     expect(title.length).toBeGreaterThan(0);

From cf3fe8b485f964bea9cf014d04c5a521386e5c5a Mon Sep 17 00:00:00 2001
From: gsxdsm <gsxdsm@users.noreply.github.com>
Date: Sun, 5 Jul 2026 13:15:56 -0700
Subject: [PATCH 45/65] FN-7591: make dashboard create surfaces resolve intake
 column from workflow instead of hard-coding triage

Fixes dashboard task creation so new cards land in the selected/default workflow's intake column instead of always forcing legacy triage, letting workflows like Coding (Ideas) park new cards in 'ideas' until an operator promotes them.

- InlineCreateCard, QuickEntryBox, and NewTaskModal no longer hard-code column:"triage"; InlineCreateCard now forwards workflowId at create time instead of applying it post-create.
- Fixed a glue-layer regression in useTaskHandlers.ts (handleBoardQuickCreate/handleModalCreate) that re-forced column:"triage" even after UI surfaces stopped sending it.
- Added/updated tests covering the store's intake-column resolution and the dashboard create surfaces/hooks.
- Documented the new manual-intake-column parking behavior in dashboard-guide.md and workflow-steps.md.
- Added a patch changeset for @runfusion/fusion.

Files changed:
 .changeset/fn-7591-coding-ideas-intake.md          |  7 +++
 docs/dashboard-guide.md                            |  4 ++
 docs/workflow-steps.md                             |  1 +
 packages/core/src/__tests__/store-create-intake-column.test.ts   | 20 ++++++++
 packages/dashboard/app/App.tsx                     |  5 +-
 packages/dashboard/app/components/InlineCreateCard.tsx  | 28 ++++------
 packages/dashboard/app/components/NewTaskModal.tsx |  5 +-
 packages/dashboard/app/components/QuickEntryBox.tsx     |  5 +-
 packages/dashboard/app/components/TodoView.tsx     |  7 ++-
 packages/dashboard/app/components/__tests__/InlineCreateCard.test.tsx | 59 +++++++++++++++++++++-
 packages/dashboard/app/components/__tests__/QuickEntryBox.test.tsx    | 14 +++--
 packages/dashboard/app/components/__tests__/TodoView.test.tsx | 10 ++--
 packages/dashboard/app/components/__tests__/board-quickcreate-workflow-lane-visibility.test.tsx | 45 ++++++++++++++++-
 packages/dashboard/app/hooks/__tests__/useTaskHandlers.test.ts    | 27 ++++++++--
 packages/dashboard/app/hooks/useTaskHandlers.ts    |  8 ++-
 15 files changed, 207 insertions(+), 38 deletions(-)

Fusion-Task-Id: FN-7591

Fusion-Task-Lineage: 510f0e6a-89e7-468f-a6df-ad6aebd5c33a

Co-authored-by: Fusion (runfusion.ai) <noreply@runfusion.ai>
---
 .changeset/fn-7591-coding-ideas-intake.md     |  7 +++
 docs/dashboard-guide.md                       |  4 ++
 docs/workflow-steps.md                        |  1 +
 .../store-create-intake-column.test.ts        | 20 +++++++
 packages/dashboard/app/App.tsx                |  5 +-
 .../app/components/InlineCreateCard.tsx       | 28 ++++-----
 .../dashboard/app/components/NewTaskModal.tsx |  5 +-
 .../app/components/QuickEntryBox.tsx          |  5 +-
 .../dashboard/app/components/TodoView.tsx     |  7 ++-
 .../__tests__/InlineCreateCard.test.tsx       | 59 ++++++++++++++++++-
 .../__tests__/QuickEntryBox.test.tsx          | 14 +++--
 .../components/__tests__/TodoView.test.tsx    | 10 ++--
 ...ckcreate-workflow-lane-visibility.test.tsx | 45 +++++++++++++-
 .../hooks/__tests__/useTaskHandlers.test.ts   | 27 +++++++--
 .../dashboard/app/hooks/useTaskHandlers.ts    |  8 ++-
 15 files changed, 207 insertions(+), 38 deletions(-)
 create mode 100644 .changeset/fn-7591-coding-ideas-intake.md

diff --git a/.changeset/fn-7591-coding-ideas-intake.md b/.changeset/fn-7591-coding-ideas-intake.md
new file mode 100644
index 0000000000..6db08f8a77
--- /dev/null
+++ b/.changeset/fn-7591-coding-ideas-intake.md
@@ -0,0 +1,7 @@
+---
+"@runfusion/fusion": patch
+---
+
+summary: New tasks created under the Coding (Ideas) workflow now land in the Ideas column and wait for you to promote them.
+category: fix
+dev: Dashboard create surfaces (InlineCreateCard, QuickEntryBox, NewTaskModal, insight/todo → task) no longer hard-code column:"triage"; the store now resolves the selected/default workflow's intake column. InlineCreateCard forwards workflowId at create time instead of applying it post-create. Also fixed a glue-layer regression in `useTaskHandlers.ts` (`handleBoardQuickCreate`/`handleModalCreate`) that re-forced column:"triage" even after the UI surfaces stopped sending it.
diff --git a/docs/dashboard-guide.md b/docs/dashboard-guide.md
index 8992295765..40cc1440e8 100644
--- a/docs/dashboard-guide.md
+++ b/docs/dashboard-guide.md
@@ -432,6 +432,10 @@ When quick-create task creation, Planning Mode, or Subtask Breakdown runs from a
 
 The **New Task** dialog's workflow selector also defaults to the current or last selected Board/List workflow lane for the current project. If no valid lane has been selected, or the remembered lane was deleted, the selector falls back to the project default workflow and task creation omits an explicit `workflowId`.
 
+<!-- FNXC:CodingIdeasWorkflow 2026-07-05-00:00: Every dashboard create surface (inline quick-create, quick-add box, New Task dialog, insight → task, todo → task) must omit an explicit `column` from the create request so the store resolves the landing column from the (selected or project-default) workflow's intake column instead of always forcing legacy `triage`. -->
+
+Create requests never send an explicit `column`. The task store resolves the landing column from the (selected or project-default) workflow's intake column, so most tasks still land in `triage` under the default Coding workflow, byte-identical to before. A workflow with a **manual intake column** — for example the built-in **Coding (Ideas)** workflow's `ideas` column (`autoTriage: false`) — parks new cards there instead: they wait for you to promote them into `todo` and are not auto-planned by the triage service until you do.
+
 Optional workflow steps declared by the active workflow are available from the quick-add action row and the **New Task** dialog's inline quick buttons. For example, the coding workflow's browser verification option appears as a quick drop-down when that workflow is active; each option is seeded from the workflow step's `defaultOn` setting and is sent with the task's `enabledWorkflowSteps` payload at creation time.
 
 <!-- FNXC:QuickAddAttachments 2026-06-30-00:00: Quick Add attachments use a compact icon-only paperclip while keeping the Attach action and pending image count in accessible labels. The same pending preview/upload path accepts image selection, paste, and direct drag/drop onto the Quick Add box. -->
diff --git a/docs/workflow-steps.md b/docs/workflow-steps.md
index 9e453b6d98..48db90a417 100644
--- a/docs/workflow-steps.md
+++ b/docs/workflow-steps.md
@@ -82,6 +82,7 @@ Use this inventory as the documentation map for current workflow behavior:
 | Routing boundary | Agents may select/change a workflow only for explicit user requests or tasks they created; no-commit markers do not imply Quick fix or any other workflow. | This page, [Selecting workflows](#selecting-workflows); [Agents](./agents.md#interactive-cli-chat). |
 | Dashboard board/list/graph selection | Board/List/Header/Graph share durable per-project workflow selection; stale saved ids fall back to a valid workflow. Board adds a dashboard-only **All workflows** aggregate and task workflow-name badges; Graph uses **All workflows** for the full active graph. | [Dashboard Guide → Board View](./dashboard-guide.md#board-view), [Graph View](./dashboard-guide.md#graph-view), and [Workflow Selection and Editor](./dashboard-guide.md#workflow-selection-and-editor). |
 | Create/planning forwarding | Quick-create task creation, Planning Mode, Subtask Breakdown, and the New Task dialog forward the active real workflow id when creating tasks; **All workflows** quick-create chooses a real workflow intake/default column instead of saving a synthetic aggregate id. | [Dashboard Guide → Planning Mode](./dashboard-guide.md#planning-mode). |
+| Manual-intake column parking | Dashboard create surfaces never send an explicit `column`; the store resolves the landing column from the (selected or project-default) workflow's intake column. A workflow whose intake column sets `autoTriage: false` (e.g. built-in Coding (Ideas)'s `ideas` column) parks new cards there instead of auto-planning them, until an operator promotes the card. | [Dashboard Guide → Create/Planning Forwarding](./dashboard-guide.md#planning-mode). |
 
 ### Skill-backed workflow steps
 
diff --git a/packages/core/src/__tests__/store-create-intake-column.test.ts b/packages/core/src/__tests__/store-create-intake-column.test.ts
index 02b9a14452..f2c94ea21a 100644
--- a/packages/core/src/__tests__/store-create-intake-column.test.ts
+++ b/packages/core/src/__tests__/store-create-intake-column.test.ts
@@ -36,6 +36,26 @@ describe("createTask intake-column wiring (Coding (Ideas))", () => {
     expect(task.column).toBe("ideas");
   });
 
+  it("lands a task explicitly selecting builtin:coding in triage even when the project default is coding-ideas", async () => {
+    const store = harness.store();
+    await store.setDefaultWorkflowId("builtin:coding-ideas");
+    const task = await store.createTask({
+      description: "explicit default coding workflow task",
+      workflowId: "builtin:coding",
+    });
+    expect(task.column).toBe("triage");
+  });
+
+  it("does not throw and falls back to triage when workflowId is explicitly null (\"No workflow\")", async () => {
+    const store = harness.store();
+    await store.setDefaultWorkflowId("builtin:coding-ideas");
+    const task = await store.createTask({
+      description: "explicit no-workflow task",
+      workflowId: null,
+    });
+    expect(task.column).toBe("triage");
+  });
+
   it("writes a bootstrap PROMPT.md for an ideas-column task (unplanned)", async () => {
     const store = harness.store();
     const task: Task = await store.createTask({
diff --git a/packages/dashboard/app/App.tsx b/packages/dashboard/app/App.tsx
index 03532054fe..8264e175c1 100644
--- a/packages/dashboard/app/App.tsx
+++ b/packages/dashboard/app/App.tsx
@@ -792,10 +792,13 @@ function AppInner() {
 
   const handleInsightTaskCreate = useCallback(
     async ({ insightId, title, description }: { insightId: string; title: string; description: string }) => {
+      /*
+      FNXC:CodingIdeasWorkflow 2026-07-05-00:00:
+      Do not hard-code `column: "triage"` — this surface has no workflow picker, so it inherits the project-default workflow, and the store resolves the landing column from that workflow's intake column (e.g. Coding (Ideas) → "ideas") instead of forcing triage.
+      */
       await createTask({
         title,
         description,
-        column: "triage",
         source: {
           sourceType: "dashboard_ui",
           sourceMetadata: {
diff --git a/packages/dashboard/app/components/InlineCreateCard.tsx b/packages/dashboard/app/components/InlineCreateCard.tsx
index ebf302edba..134559d580 100644
--- a/packages/dashboard/app/components/InlineCreateCard.tsx
+++ b/packages/dashboard/app/components/InlineCreateCard.tsx
@@ -6,7 +6,7 @@ import { Brain, Link, ListTree, Zap, ChevronDown, ChevronUp, Bot, Maximize2, Min
 import { DEFAULT_TASK_PRIORITY, TASK_PRIORITIES, type Task, type TaskPriority, type Settings, type ResolvedWorkflowOptionalStep } from "@fusion/core";
 import { getErrorMessage } from "@fusion/core";
 import type { ToastType } from "../hooks/useToast";
-import { checkDuplicateTasks, fetchModels, uploadAttachment, fetchSettings, updateGlobalSettings, fetchAgents, selectTaskWorkflow, fetchWorkflowOptionalSteps, DuplicateCandidatesError } from "../api";
+import { checkDuplicateTasks, fetchModels, uploadAttachment, fetchSettings, updateGlobalSettings, fetchAgents, fetchWorkflowOptionalSteps, DuplicateCandidatesError } from "../api";
 import type { CreateTaskInput, ModelInfo, Agent, NodeInfo, DuplicateMatch } from "../api";
 import { useNodes } from "../hooks/useNodes";
 import { ModelSelectionModal } from "./ModelSelectionModal";
@@ -394,24 +394,15 @@ export function InlineCreateCard({
     });
   }, []);
 
+  /*
+  FNXC:CodingIdeasWorkflow 2026-07-05-00:00:
+  submitTask no longer applies the selected workflow post-create via selectTaskWorkflow — handleSubmit now forwards workflowId inside the CreateTaskInput so the store materializes the workflow and resolves the intake column (e.g. Coding (Ideas) → "ideas") atomically at create time. A post-create selectTaskWorkflow call would race the store's intake-column resolution and re-introduce the auto-triage bug this task fixes.
+  */
   const submitTask = useCallback(async (input: CreateTaskInput) => {
     setSubmitting(true);
     try {
       const task = await onSubmit(input);
 
-      // Apply custom workflow if selected (non-blocking — task already exists)
-      if (selectedWorkflowId) {
-        try {
-          await selectTaskWorkflow(task.id, selectedWorkflowId, projectId);
-        } catch (err) {
-          if (addToast) {
-            addToast(getErrorMessage(err) || "Failed to apply workflow", "error");
-          } else {
-            console.warn("Failed to apply workflow:", getErrorMessage(err));
-          }
-        }
-      }
-
       // Upload pending images as attachments
       if (pendingImages.length > 0) {
         const failures: string[] = [];
@@ -478,15 +469,18 @@ export function InlineCreateCard({
     onSubmit,
     addToast,
     projectId,
-    selectedWorkflowId,
   ]);
 
   const handleSubmit = useCallback(async () => {
     if (!description.trim() || submitting) return;
 
+    /*
+    FNXC:CodingIdeasWorkflow 2026-07-05-00:00:
+    Do not hard-code `column: "triage"` here — the store resolves the landing column from the forwarded (or project-default) workflow's intake column, e.g. Coding (Ideas) → "ideas". Forwarding `workflowId` at create time (instead of applying it post-create via selectTaskWorkflow) lets the store materialize the workflow and land the card in its resolved intake column atomically, so a manual-intake workflow parks the card for the operator instead of being auto-triaged.
+    */
     const input: CreateTaskInput = {
       description: description.trim(),
-      column: "triage",
+      ...(selectedWorkflowId ? { workflowId: selectedWorkflowId } : {}),
       dependencies: dependencies.length ? dependencies : undefined,
       ...(selectedAgentId ? { assignedAgentId: selectedAgentId } : {}),
       modelPresetId: selectedPresetId,
@@ -517,7 +511,7 @@ export function InlineCreateCard({
     }
 
     await submitTask(input);
-  }, [description, submitting, dependencies, selectedAgentId, selectedPresetId, hasExecutorOverride, executorProvider, executorModelId, hasValidatorOverride, validatorProvider, validatorModelId, hasPlanningOverride, planningProvider, planningModelId, optionalSteps.length, enabledOptionalStepIds, priority, effectiveNodeId, projectId, addToast, submitTask]);
+  }, [description, submitting, selectedWorkflowId, dependencies, selectedAgentId, selectedPresetId, hasExecutorOverride, executorProvider, executorModelId, hasValidatorOverride, validatorProvider, validatorModelId, hasPlanningOverride, planningProvider, planningModelId, optionalSteps.length, enabledOptionalStepIds, priority, effectiveNodeId, projectId, addToast, submitTask]);
 
   const handleDuplicateProceed = useCallback(async () => {
     const matches = duplicateMatches;
diff --git a/packages/dashboard/app/components/NewTaskModal.tsx b/packages/dashboard/app/components/NewTaskModal.tsx
index ab0251100f..2cca65baf3 100644
--- a/packages/dashboard/app/components/NewTaskModal.tsx
+++ b/packages/dashboard/app/components/NewTaskModal.tsx
@@ -791,10 +791,13 @@ export function NewTaskModal({ isOpen, onClose, projectId, tasks, onCreateTask,
     const validatorSlashIdx = validatorModel.indexOf("/");
     const planningSlashIdx = planningModel.indexOf("/");
 
+    /*
+    FNXC:CodingIdeasWorkflow 2026-07-05-00:00:
+    Do not hard-code `column: "triage"` — the store resolves the landing column from the (materialized) workflowId below, so a manual-intake workflow (e.g. Coding (Ideas) → "ideas") parks the card for the operator instead of being auto-triaged.
+    */
     const createInput: NewTaskCreateInput = {
       title: undefined,
       description: trimmedDesc,
-      column: "triage",
       dependencies: dependencies.length ? dependencies : undefined,
       // U6/R3: forward the workflow selection only when the user changed it.
       //  - undefined → omit (store inherits the project default, today's behavior)
diff --git a/packages/dashboard/app/components/QuickEntryBox.tsx b/packages/dashboard/app/components/QuickEntryBox.tsx
index ad8745a4e5..87ca77fb7d 100644
--- a/packages/dashboard/app/components/QuickEntryBox.tsx
+++ b/packages/dashboard/app/components/QuickEntryBox.tsx
@@ -715,9 +715,12 @@ export function QuickEntryBox({ onCreate, addToast, tasks = [], availableModels,
     const originalDescription = description;
     setDescription("");
     try {
+      /*
+      FNXC:CodingIdeasWorkflow 2026-07-05-00:00:
+      Do not hard-code `column: "triage"` — the store resolves the landing column from the forwarded (or project-default) workflow's intake column, so a manual-intake workflow (e.g. Coding (Ideas) → "ideas") parks the card for the operator instead of being auto-triaged.
+      */
       const createdTask = await onCreate({
         description: trimmed,
-        column: "triage",
         ...(selectedWorkflowForCreate !== undefined ? { workflowId: selectedWorkflowForCreate } : {}),
         dependencies: dependencies.length ? dependencies : undefined,
         ...(selectedAgentId ? { assignedAgentId: selectedAgentId } : {}),
diff --git a/packages/dashboard/app/components/TodoView.tsx b/packages/dashboard/app/components/TodoView.tsx
index 916962ee7c..c76e777438 100644
--- a/packages/dashboard/app/components/TodoView.tsx
+++ b/packages/dashboard/app/components/TodoView.tsx
@@ -299,9 +299,12 @@ export function TodoView({
 
   const handleCreateTaskFromItem = useCallback(async (item: TodoItem) => {
     try {
+      /*
+      FNXC:CodingIdeasWorkflow 2026-07-05-00:00:
+      Do not hard-code `column: "triage"` — this surface has no workflow picker, so it inherits the project-default workflow, and the store resolves the landing column from that workflow's intake column (e.g. Coding (Ideas) → "ideas") instead of forcing triage.
+      */
       const input: TaskCreateInput = {
         description: item.text,
-        column: "triage",
         source: { sourceType: "dashboard_ui" },
       };
       const task: Task = await createTask(input, projectId);
@@ -314,9 +317,9 @@ export function TodoView({
 
   const handleCreateTaskAndAssign = useCallback(async (item: TodoItem, agentId: string) => {
     try {
+      // FNXC:CodingIdeasWorkflow 2026-07-05-00:00: same rationale as handleCreateTaskFromItem above — omit column so the project-default workflow's intake column resolves it.
       const input: TaskCreateInput = {
         description: item.text,
-        column: "triage",
         assignedAgentId: agentId,
         source: { sourceType: "dashboard_ui" },
       };
diff --git a/packages/dashboard/app/components/__tests__/InlineCreateCard.test.tsx b/packages/dashboard/app/components/__tests__/InlineCreateCard.test.tsx
index f08f49d86a..c4c5d35c34 100644
--- a/packages/dashboard/app/components/__tests__/InlineCreateCard.test.tsx
+++ b/packages/dashboard/app/components/__tests__/InlineCreateCard.test.tsx
@@ -3,7 +3,7 @@ import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
 import { render, screen, fireEvent, waitFor, act } from "@testing-library/react";
 import { InlineCreateCard } from "../InlineCreateCard";
 import type { Task, Column } from "@fusion/core";
-import { fetchModels, fetchSettings, fetchAgents, checkDuplicateTasks, fetchWorkflows, fetchWorkflowOptionalSteps } from "../../api";
+import { fetchModels, fetchSettings, fetchAgents, checkDuplicateTasks, fetchWorkflows, fetchWorkflowOptionalSteps, selectTaskWorkflow } from "../../api";
 import { useNodes } from "../../hooks/useNodes";
 import type { ModelInfo } from "../../api";
 import { scopedKey } from "../../utils/projectStorage";
@@ -1773,4 +1773,61 @@ describe("InlineCreateCard node override", () => {
   });
 });
 
+/*
+FN-7591: InlineCreateCard must forward a selected workflow inside the create-time CreateTaskInput
+(so the store materializes it and resolves the workflow's intake column atomically) instead of hard-coding
+column:"triage" and applying the workflow post-create via selectTaskWorkflow.
+*/
+describe("InlineCreateCard workflow selection at create time (FN-7591)", () => {
+  beforeEach(() => {
+    vi.mocked(fetchWorkflows).mockResolvedValue([
+      { id: "wf-a", name: "Workflow A" },
+      { id: "builtin:coding-ideas", name: "Coding (Ideas)" },
+    ]);
+  });
+
+  it("submits workflowId in the create input and omits column:triage when a workflow is selected", async () => {
+    const { props } = renderCard();
+    expandCard();
+
+    fireEvent.change(screen.getByPlaceholderText("What needs to be done?"), { target: { value: "Idea for later" } });
+    const select = await screen.findByLabelText("Workflow") as HTMLSelectElement;
+    fireEvent.change(select, { target: { value: "builtin:coding-ideas" } });
+
+    fireEvent.click(screen.getByTestId("save-button"));
+
+    await waitFor(() => expect(props.onSubmit).toHaveBeenCalled());
+    const submitted = vi.mocked(props.onSubmit).mock.calls[0][0];
+    expect(submitted.workflowId).toBe("builtin:coding-ideas");
+    expect(submitted.column).toBeUndefined();
+  });
+
+  it("omits workflowId when no workflow is explicitly selected (inherits project default)", async () => {
+    const { props } = renderCard();
+    expandCard();
+
+    fireEvent.change(screen.getByPlaceholderText("What needs to be done?"), { target: { value: "Plain task" } });
+    fireEvent.click(screen.getByTestId("save-button"));
+
+    await waitFor(() => expect(props.onSubmit).toHaveBeenCalled());
+    const submitted = vi.mocked(props.onSubmit).mock.calls[0][0];
+    expect(submitted.workflowId).toBeUndefined();
+    expect(submitted.column).toBeUndefined();
+  });
+
+  it("does not call the redundant post-create selectTaskWorkflow for the create path", async () => {
+    const { props } = renderCard();
+    expandCard();
+
+    fireEvent.change(screen.getByPlaceholderText("What needs to be done?"), { target: { value: "Idea for later" } });
+    const select = await screen.findByLabelText("Workflow") as HTMLSelectElement;
+    fireEvent.change(select, { target: { value: "builtin:coding-ideas" } });
+
+    fireEvent.click(screen.getByTestId("save-button"));
+
+    await waitFor(() => expect(props.onSubmit).toHaveBeenCalled());
+    expect(selectTaskWorkflow).not.toHaveBeenCalled();
+  });
+});
+
 });
diff --git a/packages/dashboard/app/components/__tests__/QuickEntryBox.test.tsx b/packages/dashboard/app/components/__tests__/QuickEntryBox.test.tsx
index cd5b40d954..d7f30b1f1a 100644
--- a/packages/dashboard/app/components/__tests__/QuickEntryBox.test.tsx
+++ b/packages/dashboard/app/components/__tests__/QuickEntryBox.test.tsx
@@ -1373,7 +1373,9 @@ describe("QuickEntryBox", () => {
     });
   });
 
-  it("creates task on Enter key with TaskCreateInput", async () => {
+  // FN-7591: QuickEntryBox must not force column:"triage" — the store resolves the landing column from
+  // the (selected or default) workflow's intake column, so a manual-intake workflow parks the card instead.
+  it("creates task on Enter key with TaskCreateInput and without forcing column:triage", async () => {
     const { props } = renderQuickEntryBox({});
     const textarea = screen.getByTestId("quick-entry-input");
 
@@ -1384,9 +1386,10 @@ describe("QuickEntryBox", () => {
       expect(props.onCreate).toHaveBeenCalledWith(
         expect.objectContaining({
           description: "New task description",
-          column: "triage",
         }),
       );
+      const submitted = vi.mocked(props.onCreate).mock.calls[0][0];
+      expect(submitted.column).toBeUndefined();
     });
   });
 
@@ -1639,6 +1642,8 @@ describe("QuickEntryBox", () => {
       fireEvent.change(screen.getByTestId("quick-entry-input"), { target: { value: "Create in selected workflow" } });
       clickSave();
       await waitFor(() => expect(onCreate).toHaveBeenCalledWith(expect.objectContaining({ workflowId: "wf-default" })));
+      // FN-7591: forwarding workflowId at create time must not carry a hard-coded column:"triage".
+      expect(vi.mocked(onCreate).mock.calls[0][0].column).toBeUndefined();
 
       expect(screen.queryByTestId("plan-button")).not.toBeInTheDocument();
       expect(onPlanningMode).not.toHaveBeenCalled();
@@ -3722,7 +3727,7 @@ describe("QuickEntryBox", () => {
       expect(localStorage.getItem(QUICK_ENTRY_STORAGE_KEY)).toBeNull();
     });
 
-    it("clicking save action creates the task", async () => {
+    it("clicking save action creates the task without forcing column:triage", async () => {
       const { props } = renderQuickEntryBox({});
       expandQuickEntry();
       const textarea = screen.getByTestId("quick-entry-input");
@@ -3734,9 +3739,10 @@ describe("QuickEntryBox", () => {
         expect(props.onCreate).toHaveBeenCalledWith(
           expect.objectContaining({
             description: "Task to save",
-            column: "triage",
           }),
         );
+        const submitted = vi.mocked(props.onCreate).mock.calls[0][0];
+        expect(submitted.column).toBeUndefined();
       });
     });
 
diff --git a/packages/dashboard/app/components/__tests__/TodoView.test.tsx b/packages/dashboard/app/components/__tests__/TodoView.test.tsx
index 2c1f06f4bc..0574ea136f 100644
--- a/packages/dashboard/app/components/__tests__/TodoView.test.tsx
+++ b/packages/dashboard/app/components/__tests__/TodoView.test.tsx
@@ -446,7 +446,9 @@ describe("TodoView", () => {
     expect(mockCreateTask).not.toHaveBeenCalled();
   });
 
-  it("clicking Create Task button calls createTask with item text", async () => {
+  // FN-7591: TodoView create handlers must not force column:"triage" — the store resolves the landing
+  // column from the project-default workflow's intake column instead.
+  it("clicking Create Task button calls createTask with item text and without forcing column:triage", async () => {
     const onTaskCreated = vi.fn();
     mockCreateTask.mockResolvedValueOnce({ id: "FN-123" });
     render(<TodoView addToast={addToast} projectId="project-1" onTaskCreated={onTaskCreated} />);
@@ -455,7 +457,7 @@ describe("TodoView", () => {
 
     await waitFor(() => {
       expect(mockCreateTask).toHaveBeenCalledWith(
-        { description: "Buy groceries", column: "triage", source: { sourceType: "dashboard_ui" } },
+        { description: "Buy groceries", source: { sourceType: "dashboard_ui" } },
         "project-1",
       );
     });
@@ -474,7 +476,7 @@ describe("TodoView", () => {
     expect(screen.getByText("Builder")).toBeInTheDocument();
   });
 
-  it("selecting an agent creates task assigned to that agent", async () => {
+  it("selecting an agent creates task assigned to that agent without forcing column:triage", async () => {
     const onTaskCreated = vi.fn();
     mockCreateTask.mockResolvedValueOnce({ id: "FN-234" });
     render(<TodoView addToast={addToast} projectId="project-1" onTaskCreated={onTaskCreated} />);
@@ -486,7 +488,7 @@ describe("TodoView", () => {
 
     await waitFor(() => {
       expect(mockCreateTask).toHaveBeenCalledWith(
-        { description: "Buy groceries", column: "triage", assignedAgentId: "agent-1", source: { sourceType: "dashboard_ui" } },
+        { description: "Buy groceries", assignedAgentId: "agent-1", source: { sourceType: "dashboard_ui" } },
         "project-1",
       );
     });
diff --git a/packages/dashboard/app/components/__tests__/board-quickcreate-workflow-lane-visibility.test.tsx b/packages/dashboard/app/components/__tests__/board-quickcreate-workflow-lane-visibility.test.tsx
index 1f76f1c3f1..28964c172a 100644
--- a/packages/dashboard/app/components/__tests__/board-quickcreate-workflow-lane-visibility.test.tsx
+++ b/packages/dashboard/app/components/__tests__/board-quickcreate-workflow-lane-visibility.test.tsx
@@ -94,6 +94,22 @@ const CUSTOM_WORKFLOW = {
   ],
 };
 
+/*
+FNXC:CodingIdeasWorkflow 2026-07-05-00:00:
+A task created under the Coding (Ideas) workflow (manual "ideas" intake, autoTriage:false) must render in the board's
+"ideas" lane, not "triage" — mirrors the real builtin:coding-ideas workflow's intake column id/flag shape.
+*/
+const CODING_IDEAS_WORKFLOW = {
+  id: "builtin:coding-ideas",
+  name: "Coding (Ideas)",
+  columns: [
+    { id: "ideas", name: "Ideas", flags: { intake: true } },
+    { id: "todo", name: "Todo", flags: { hold: true } },
+    { id: "done", name: "Done", flags: { complete: true } },
+    { id: "archived", name: "Archived", flags: { archived: true } },
+  ],
+};
+
 function mkTask(overrides: Partial<Task> & { id: string }): Task {
   return {
     title: overrides.id,
@@ -113,7 +129,7 @@ function workflowPayload(taskWorkflowIds: Record<string, string>, flagEnabled =
   return {
     flagEnabled,
     defaultWorkflowId: DEFAULT_WORKFLOW.id,
-    workflows: flagEnabled ? [DEFAULT_WORKFLOW, CUSTOM_WORKFLOW] : [],
+    workflows: flagEnabled ? [DEFAULT_WORKFLOW, CUSTOM_WORKFLOW, CODING_IDEAS_WORKFLOW] : [],
     taskWorkflowIds,
   };
 }
@@ -269,6 +285,33 @@ describe("workflow lane quick-create visibility", () => {
     expect(screen.getByText(title)).toBeTruthy();
   });
 
+  it("Board renders a task created under the Coding (Ideas) workflow in the ideas lane", async () => {
+    const refetch = deferred<BoardWorkflowsPayload>();
+    fetchBoardWorkflowsMock
+      .mockResolvedValueOnce(workflowPayload({}))
+      .mockResolvedValueOnce(workflowPayload({}))
+      .mockReturnValueOnce(refetch.promise);
+
+    render(<BoardHarness />);
+    await screen.findByTestId("workflow-switcher");
+    selectWorkflow(CODING_IDEAS_WORKFLOW.id);
+
+    await act(async () => {
+      fireEvent.click(screen.getByTestId("quick-create-ideas"));
+    });
+
+    const ideasColumn = screen.getByTestId("column-ideas");
+    expect(within(ideasColumn).getByText("Created builtin:coding-ideas")).toBeTruthy();
+    expect(JSON.parse(ideasColumn.getAttribute("data-task-ids") ?? "[]")).toContain("FN-new");
+
+    await act(async () => {
+      refetch.resolve(workflowPayload({ "FN-new": CODING_IDEAS_WORKFLOW.id }));
+      await refetch.promise;
+    });
+
+    expect(within(screen.getByTestId("column-ideas")).getByText("Created builtin:coding-ideas")).toBeTruthy();
+  });
+
   it("leaves the legacy flag-off Board quick-create path unchanged", async () => {
     const inputs: TaskCreateInput[] = [];
     fetchBoardWorkflowsMock.mockResolvedValue(workflowPayload({}, false));
diff --git a/packages/dashboard/app/hooks/__tests__/useTaskHandlers.test.ts b/packages/dashboard/app/hooks/__tests__/useTaskHandlers.test.ts
index d5cb65a18e..d1c59a3a9a 100644
--- a/packages/dashboard/app/hooks/__tests__/useTaskHandlers.test.ts
+++ b/packages/dashboard/app/hooks/__tests__/useTaskHandlers.test.ts
@@ -37,7 +37,10 @@ describe("useTaskHandlers", () => {
     vi.clearAllMocks();
   });
 
-  it("handleBoardQuickCreate calls createTask with triage column and returns task", async () => {
+  // FN-7591: handleBoardQuickCreate/handleModalCreate must NOT force column:"triage" — the store resolves the
+  // landing column from the (selected or default) workflow's intake column, so a manual-intake workflow
+  // (e.g. Coding (Ideas) → "ideas") parks the card instead of being auto-triaged.
+  it("handleBoardQuickCreate forwards createTask without forcing a column", async () => {
     const options = createOptions();
     const { result } = renderHook(() => useTaskHandlers(options));
     const input: TaskCreateInput = { description: "Do work" };
@@ -47,11 +50,27 @@ describe("useTaskHandlers", () => {
       created = await result.current.handleBoardQuickCreate(input);
     });
 
-    expect(options.createTask).toHaveBeenCalledWith({ description: "Do work", column: "triage", source: { sourceType: "dashboard_ui" } });
+    expect(options.createTask).toHaveBeenCalledWith({ description: "Do work", source: { sourceType: "dashboard_ui" } });
     expect(created).toEqual(CREATED_TASK);
   });
 
-  it("handleModalCreate calls createTask with triage column and returns task", async () => {
+  it("handleBoardQuickCreate forwards an explicit workflowId without forcing a column", async () => {
+    const options = createOptions();
+    const { result } = renderHook(() => useTaskHandlers(options));
+    const input: TaskCreateInput = { description: "Do work", workflowId: "builtin:coding-ideas" };
+
+    await act(async () => {
+      await result.current.handleBoardQuickCreate(input);
+    });
+
+    expect(options.createTask).toHaveBeenCalledWith({
+      description: "Do work",
+      workflowId: "builtin:coding-ideas",
+      source: { sourceType: "dashboard_ui" },
+    });
+  });
+
+  it("handleModalCreate forwards createTask without forcing a column", async () => {
     const options = createOptions();
     const { result } = renderHook(() => useTaskHandlers(options));
 
@@ -60,7 +79,7 @@ describe("useTaskHandlers", () => {
       created = await result.current.handleModalCreate({ description: "From modal" });
     });
 
-    expect(options.createTask).toHaveBeenCalledWith({ description: "From modal", column: "triage", source: { sourceType: "dashboard_ui" } });
+    expect(options.createTask).toHaveBeenCalledWith({ description: "From modal", source: { sourceType: "dashboard_ui" } });
     expect(created).toEqual(CREATED_TASK);
   });
 
diff --git a/packages/dashboard/app/hooks/useTaskHandlers.ts b/packages/dashboard/app/hooks/useTaskHandlers.ts
index 5593e0f717..51fddf72df 100644
--- a/packages/dashboard/app/hooks/useTaskHandlers.ts
+++ b/packages/dashboard/app/hooks/useTaskHandlers.ts
@@ -32,16 +32,20 @@ export function useTaskHandlers(options: UseTaskHandlersOptions): UseTaskHandler
     addToast,
   } = options;
 
+  /*
+  FNXC:CodingIdeasWorkflow 2026-07-05-00:00:
+  These wrappers previously forced `column: "triage"` (handleBoardQuickCreate defaulted to it when the caller omitted column; handleModalCreate hard-coded it unconditionally), which overrode InlineCreateCard/NewTaskModal even after those callers stopped sending an explicit column. Both must now forward the caller's `column` untouched (usually omitted) so the store resolves the landing column from the (selected or default) workflow's intake column — e.g. Coding (Ideas) → "ideas" — instead of always forcing legacy triage.
+  */
   const handleBoardQuickCreate = useCallback(
     async (input: TaskCreateInput): Promise<Task> => {
-      return createTask({ ...input, column: input.column ?? "triage", source: { sourceType: "dashboard_ui" } });
+      return createTask({ ...input, source: { sourceType: "dashboard_ui" } });
     },
     [createTask],
   );
 
   const handleModalCreate = useCallback(
     async (input: TaskCreateInput): Promise<Task> => {
-      const task = await createTask({ ...input, column: "triage", source: { sourceType: "dashboard_ui" } });
+      const task = await createTask({ ...input, source: { sourceType: "dashboard_ui" } });
       return task;
     },
     [createTask],

From f30d55fae785f88ea0b4e4ca91ad6652721400ba Mon Sep 17 00:00:00 2001
From: gsxdsm <gsxdsm@users.noreply.github.com>
Date: Sun, 5 Jul 2026 13:44:50 -0700
Subject: [PATCH 46/65] FN-7593: move Before/After Transformation section to
 top of task definitions

Reorders task-definition prompt templates so the Before -> After Transformation section appears before other sections, making the expected change visible first.

- Move the Before -> After Transformation section ahead of other sections in agent-prompts.ts task-definition templates
- Update docs/task-management.md to reflect the new section order
- Add/extend tests in agent-prompts.test.ts and triage.test.ts covering the new ordering
- Add changeset fn-7593-before-after-top.md documenting the change

Files changed:
 .changeset/fn-7593-before-after-top.md            |  7 +++++++
 docs/task-management.md                           |  2 +-
 packages/core/src/__tests__/agent-prompts.test.ts | 20 ++++++++++++++++++++
 packages/core/src/agent-prompts.ts                | 20 +++++++++++++-------
 packages/engine/src/__tests__/triage.test.ts      | 17 +++++++++++++++++
 5 files changed, 58 insertions(+), 8 deletions(-)

Fusion-Task-Id: FN-7593

Fusion-Task-Lineage: d0d5eb4d-2fe0-456c-b061-5c078b78911b

Co-authored-by: Fusion (runfusion.ai) <noreply@runfusion.ai>
---
 .changeset/fn-7593-before-after-top.md        |  7 +++++++
 docs/task-management.md                       |  2 +-
 .../core/src/__tests__/agent-prompts.test.ts  | 20 +++++++++++++++++++
 packages/core/src/agent-prompts.ts            | 20 ++++++++++++-------
 packages/engine/src/__tests__/triage.test.ts  | 17 ++++++++++++++++
 5 files changed, 58 insertions(+), 8 deletions(-)
 create mode 100644 .changeset/fn-7593-before-after-top.md

diff --git a/.changeset/fn-7593-before-after-top.md b/.changeset/fn-7593-before-after-top.md
new file mode 100644
index 0000000000..43186a0490
--- /dev/null
+++ b/.changeset/fn-7593-before-after-top.md
@@ -0,0 +1,7 @@
+---
+"@runfusion/fusion": patch
+---
+
+summary: Move the Before → After transformation summary to the top of generated task definitions.
+category: fix
+dev: Reorders the standard and fast triage `PROMPT.md` templates in packages/core/src/agent-prompts.ts so `## Before → After Transformation` is the first content section, ahead of `## Review Level` and `## Mission`, matching FN-7499's glance-verification intent.
diff --git a/docs/task-management.md b/docs/task-management.md
index f592e41fe2..11ea9b8497 100644
--- a/docs/task-management.md
+++ b/docs/task-management.md
@@ -552,8 +552,8 @@ The task detail modal exposes multiple tabs:
 
 After planning, each task gets a structured `PROMPT.md` with sections like:
 
-- Mission
 - Before → after transformation summary
+- Mission
 - Dependencies
 - Context to read first
 - File scope
diff --git a/packages/core/src/__tests__/agent-prompts.test.ts b/packages/core/src/__tests__/agent-prompts.test.ts
index 1f625b0f64..a34837b925 100644
--- a/packages/core/src/__tests__/agent-prompts.test.ts
+++ b/packages/core/src/__tests__/agent-prompts.test.ts
@@ -312,6 +312,26 @@ describe("resolveAgentPrompt", () => {
     }
   });
 
+  it("places the Before → After Transformation section at the top of the definition, ahead of Mission and Review Level (FN-7593)", () => {
+    const standardPrompt = resolveAgentPrompt("triage");
+    const fastPrompt = builtinSeamPrompt("planning-fast");
+
+    const standardTransformationIdx = standardPrompt.indexOf("## Before → After Transformation");
+    const standardReviewLevelIdx = standardPrompt.indexOf("## Review Level");
+    const standardMissionIdx = standardPrompt.indexOf("## Mission");
+    expect(standardTransformationIdx).toBeGreaterThan(-1);
+    expect(standardReviewLevelIdx).toBeGreaterThan(-1);
+    expect(standardMissionIdx).toBeGreaterThan(-1);
+    expect(standardTransformationIdx).toBeLessThan(standardReviewLevelIdx);
+    expect(standardTransformationIdx).toBeLessThan(standardMissionIdx);
+
+    const fastTransformationIdx = fastPrompt.indexOf("## Before → After Transformation");
+    const fastMissionIdx = fastPrompt.indexOf("## Mission");
+    expect(fastTransformationIdx).toBeGreaterThan(-1);
+    expect(fastMissionIdx).toBeGreaterThan(-1);
+    expect(fastTransformationIdx).toBeLessThan(fastMissionIdx);
+  });
+
   it("triage planning prompt is sourced from workflow IR without an engine duplicate", () => {
     const corePrompt = resolveAgentPrompt("triage");
     const planningPrompt = resolvePlanningPromptFromIr(BUILTIN_CODING_WORKFLOW_IR);
diff --git a/packages/core/src/agent-prompts.ts b/packages/core/src/agent-prompts.ts
index 39d75641a9..14014c0046 100644
--- a/packages/core/src/agent-prompts.ts
+++ b/packages/core/src/agent-prompts.ts
@@ -221,6 +221,9 @@ Keep the prompt lean, but preserve mandatory planning contracts: duplicate searc
 
 FNXC:FastPlanning 2026-07-04-16:25:
 Fast mode skips heavyweight planning ceremony, but every generated task still needs the same glanceable Before → After Transformation section as standard planning so operators can validate intent quickly.
+
+FNXC:FastPlanning 2026-07-05-12:00:
+Per FN-7593, the transformation summary must sit at the top of the PROMPT.md (before Mission), matching the standard-mode placement, so operators get the same glance-first ordering in fast mode.
 */
 const FAST_TRIAGE_PROMPT_TEXT = `You are a task specification agent for "fn". This task is running in **fast mode**.
 
@@ -235,7 +238,7 @@ Write a lean, executable PROMPT.md quickly. Preserve safety gates, but skip heav
 Before writing a spec, call \`fn_task_list\` for active work, then call \`fn_task_search\` with 2-4 targeted keyword phrases from the title/description, such as file paths, symptoms, and symbols. For any likely match in \`done\` or \`archived\`, call \`fn_task_show\` and inspect it before deciding. If an existing task covers the same work, do not write PROMPT.md; write exactly \`DUPLICATE: {existing-task-id}\`.
 
 ## Required PROMPT.md shape
-Write PROMPT.md with Mission, Before → After Transformation, Dependencies, Context to Read First, File Scope, Steps, Documentation Requirements, Completion Criteria, Git Commit Convention, and Do NOT. Include \`## Before → After Transformation\` after Mission with concise Before and After bullets stating current state, target state, and why it satisfies the user's request at a glance. In \`## Steps\`, every executable heading MUST use \`### Step N: <name>\` (for example, \`### Step 1: Preflight\`); Do not write bare \`### Preflight\` / \`### Implementation\` headings. Do not add review-level, triage subtask, or proactive subtask headings.
+Write PROMPT.md with Before → After Transformation, Mission, Dependencies, Context to Read First, File Scope, Steps, Documentation Requirements, Completion Criteria, Git Commit Convention, and Do NOT. Put \`## Before → After Transformation\` at the top, before \`## Mission\`, with concise Before/After bullets: current state, target state, why it satisfies the user's request at a glance. In \`## Steps\`, every executable heading MUST use \`### Step N: <name>\` (e.g. \`### Step 1: Preflight\`). Do not write bare \`### Preflight\` / \`### Implementation\` headings, and do not add review-level, triage subtask, or proactive subtask headings.
 
 ## Surface Enumeration
 For bug fixes and UI-affordance add/remove tasks, the spec MUST include a \`## Surface Enumeration\` section. The workflow Plan Review gate validates this before execution when plan review is enabled.
@@ -297,6 +300,11 @@ Follow this structure exactly:
 **Created:** {YYYY-MM-DD}
 **Size:** {S | M | L}
 
+## Before → After Transformation
+
+- **Before:** {Briefly describe the current state, missing capability, broken behavior, or operator pain point}
+- **After:** {Briefly describe the target state and how it satisfies the user's request at a glance}
+
 ## Review Level: {0-3} ({None | Plan Only | Plan and Code | Full})
 
 **Assessment:** {1-2 sentences explaining the score}
@@ -306,11 +314,6 @@ Follow this structure exactly:
 
 {One paragraph: what you're building and why it matters}
 
-## Before → After Transformation
-
-- **Before:** {Briefly describe the current state, missing capability, broken behavior, or operator pain point}
-- **After:** {Briefly describe the target state and how it satisfies the user's request at a glance}
-
 ## Surface Enumeration
 
 {Required for bug-fix tasks and UI-affordance add/remove tasks (adding, removing, or restructuring icons, buttons, chevrons/arrows, toggles, badges, menu entries, click targets): a checklist enumerating every surface the fixed invariant must hold across. Include every provider/bridge for streaming and agent paths; desktop AND mobile breakpoints; empty/undefined/duplicate/populated data states; and every hook/component/module that shares the affected logic. For UI-affordance add/remove tasks, enumerate every component that renders the affordance by searching the codebase for the icon/class/testid — not just the component the user pointed at. Explicitly check for leftover shells after removal (empty buttons, orphaned click targets, now-unused wrappers, dangling aria-labels) across both desktop and mobile breakpoints. Use the canonical checklist in docs/testing.md as the starting point.}
@@ -437,11 +440,14 @@ If this task REMOVES existing functionality (deleting modules, settings, API end
 
 ## Transformation summary requirement
 
-Every normal implementation, documentation, or decision task definition MUST include \`## Before → After Transformation\` after \`## Mission\`. Keep it concise: use brief Before and After bullets (or equivalent short prose) that name the current state, the target state, and why that target satisfies the user's request at a glance.
+Every normal implementation, documentation, or decision task definition MUST include \`## Before → After Transformation\` at the top of the definition, immediately after the \`# Task\` title and \`Created\`/\`Size\` metadata, before \`## Review Level\` and \`## Mission\`. Keep it concise: use brief Before and After bullets (or equivalent short prose) that name the current state, the target state, and why that target satisfies the user's request at a glance.
 
 <!--
 FNXC:TriagePromptStructure 2026-07-04-16:20:
 Task definitions now carry a glanceable before-to-after transformation summary near the top so operators and reviewers can confirm the intended outcome before reading the full specification.
+
+FNXC:TriagePromptStructure 2026-07-05-12:00:
+Per FN-7593, the transformation summary now sits at the very top of the definition — before Review Level and Mission — so operators can validate intent at a glance without scrolling past triage bookkeeping and Mission prose first.
 -->
 
 ## Testing requirements
diff --git a/packages/engine/src/__tests__/triage.test.ts b/packages/engine/src/__tests__/triage.test.ts
index e497d912b1..506bab4734 100644
--- a/packages/engine/src/__tests__/triage.test.ts
+++ b/packages/engine/src/__tests__/triage.test.ts
@@ -753,6 +753,23 @@ describe("FN-5893 invariant regression wording", () => {
     expect(FAST_PLANNING_PROMPT).not.toContain("## Proactive Subtask Breakdown");
   });
 
+  it("places Before → After Transformation at the top of the definition, ahead of Mission and Review Level (FN-7593)", () => {
+    const standardTransformationIdx = STANDARD_PLANNING_PROMPT.indexOf("## Before → After Transformation");
+    const standardReviewLevelIdx = STANDARD_PLANNING_PROMPT.indexOf("## Review Level");
+    const standardMissionIdx = STANDARD_PLANNING_PROMPT.indexOf("## Mission");
+    expect(standardTransformationIdx).toBeGreaterThan(-1);
+    expect(standardReviewLevelIdx).toBeGreaterThan(-1);
+    expect(standardMissionIdx).toBeGreaterThan(-1);
+    expect(standardTransformationIdx).toBeLessThan(standardReviewLevelIdx);
+    expect(standardTransformationIdx).toBeLessThan(standardMissionIdx);
+
+    const fastTransformationIdx = FAST_PLANNING_PROMPT.indexOf("## Before → After Transformation");
+    const fastMissionIdx = FAST_PLANNING_PROMPT.indexOf("## Mission");
+    expect(fastTransformationIdx).toBeGreaterThan(-1);
+    expect(fastMissionIdx).toBeGreaterThan(-1);
+    expect(fastTransformationIdx).toBeLessThan(fastMissionIdx);
+  });
+
   it("requires invariant-level regression coverage in standard, fast, and core triage prompts", () => {
     for (const prompt of [
       TRIAGE_POLICY_PROMPT,

From 8b4e5224eacd379f5e10f0bd99e584c7009c8f1d Mon Sep 17 00:00:00 2001
From: gsxdsm <gsxdsm@users.noreply.github.com>
Date: Sun, 5 Jul 2026 16:10:36 -0700
Subject: [PATCH 47/65] fix(FN-7591): stop intake-column cards vanishing from
 the workflow board

Tasks added to a workflow whose intake column differs from the default
(e.g. Coding (Ideas) -> "ideas") disappeared from the board until a manual
reload. The board resolves a card's lane from the board-workflows
taskWorkflowIds map, which only refetches on mount/focus/workflow-CRUD SSE
-- never on task creation. A freshly created card was absent from that map,
fell back to the default workflow (no "ideas" column), and was dropped from
every lane.

- Board.tsx: force one board-workflows refetch (deferred a tick,
  signature-guarded) whenever a rendered task is missing from taskWorkflowIds,
  so its real workflow + intake column resolve for any create surface.
- Board.tsx: re-home a selected-workflow task whose column the workflow no
  longer declares into the intake lane instead of a phantom bucket.
- useBoardWorkflows.ts: widen refreshBoardWorkflows type to accept forceFresh.
- Add regression tests for tasks arriving via the tasks prop (SSE / non-board
  create surfaces) and the orphan-column safety net.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 .changeset/fn-7591-intake-card-disappears.md  |   7 ++
 packages/dashboard/app/components/Board.tsx   |  51 +++++++-
 ...ckcreate-workflow-lane-visibility.test.tsx | 112 ++++++++++++++++++
 .../dashboard/app/hooks/useBoardWorkflows.ts  |   5 +-
 4 files changed, 171 insertions(+), 4 deletions(-)
 create mode 100644 .changeset/fn-7591-intake-card-disappears.md

diff --git a/.changeset/fn-7591-intake-card-disappears.md b/.changeset/fn-7591-intake-card-disappears.md
new file mode 100644
index 0000000000..819f32512c
--- /dev/null
+++ b/.changeset/fn-7591-intake-card-disappears.md
@@ -0,0 +1,7 @@
+---
+"@runfusion/fusion": patch
+---
+
+summary: Fix tasks vanishing from the board after being added to a workflow like Coding (Ideas).
+category: fix
+dev: Board.tsx forces a board-workflows refetch (deferred one tick, signature-guarded) whenever a rendered task is missing from the taskWorkflowIds map, so its real workflow and intake column resolve regardless of which create surface added it; the single-workflow grouping also re-homes a task whose column its workflow no longer declares into the intake lane instead of dropping it. Fixes the FN-7591 regression where intake-column cards (column "ideas") fell back to the default workflow, which has no such column, and were filtered out until a manual reload.
diff --git a/packages/dashboard/app/components/Board.tsx b/packages/dashboard/app/components/Board.tsx
index f343fa8cfb..04d6b5934b 100644
--- a/packages/dashboard/app/components/Board.tsx
+++ b/packages/dashboard/app/components/Board.tsx
@@ -454,6 +454,46 @@ export function Board({ tasks, projectId, maxConcurrent, showWorktreeGrouping, o
       : boardWorkflows.defaultWorkflowId;
   }, [boardWorkflows, knownWorkflowIds]);
 
+  /*
+  FNXC:WorkflowBoard 2026-07-05-14:20:
+  Invariant: every rendered task must resolve to its REAL workflow, or the board silently drops it.
+  A task created into a workflow whose intake column differs from the default (e.g. Coding (Ideas) → "ideas", per FN-7591) disappears until the next mount/focus/workflow-CRUD refetch. Cause: the task list (SSE) updates before the board-workflows `taskWorkflowIds` map, so getEffectiveTaskWorkflowId falls back to `defaultWorkflowId` (plain Coding), whose columns do not declare the intake column; the aggregate grouping then `continue`-skips the card and the single-workflow grouping files it into a never-rendered phantom bucket. The board's own quick-create handlers dodge this via applyOptimisticTaskWorkflow, but the shared create surfaces (QuickEntryBox / NewTaskModal / InlineCreateCard→TodoView / insight→task) route through useTaskHandlers and never seed the map. Fix at the invariant, not the create surface: whenever a rendered task is absent from taskWorkflowIds, force ONE board-workflows refetch so its persisted workflow selection (and intake column) resolves. Signature-guarded on the sorted unmapped-id set so we never spin an infinite refetch loop, and only run in workflow mode once the payload has loaded.
+
+  The refetch is deferred by one macrotask and re-checked against the latest state at fire time: the board's own quick-create commits the new task one microtask before applyOptimisticTaskWorkflow seeds it, so a synchronous refetch here would double-fire alongside the optimistic path. Deferring lets the seed land first — an already-mapped task is then skipped — so this only fetches for tasks that truly arrived without a workflow mapping.
+  */
+  const boardWorkflowsRef = useRef(boardWorkflows);
+  boardWorkflowsRef.current = boardWorkflows;
+  const tasksRef = useRef(tasks);
+  tasksRef.current = tasks;
+  const lastUnmappedTaskSignatureRef = useRef<string | null>(null);
+  const unmappedRefetchTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
+  useEffect(() => {
+    if (!boardWorkflows || !workflowMode) return;
+    const unmapped = tasks
+      .filter((task) => boardWorkflows.taskWorkflowIds[task.id] === undefined)
+      .map((task) => task.id)
+      .sort();
+    if (unmapped.length === 0) {
+      lastUnmappedTaskSignatureRef.current = null;
+      return;
+    }
+    const signature = unmapped.join(",");
+    if (signature === lastUnmappedTaskSignatureRef.current) return;
+    lastUnmappedTaskSignatureRef.current = signature;
+    if (unmappedRefetchTimerRef.current) clearTimeout(unmappedRefetchTimerRef.current);
+    unmappedRefetchTimerRef.current = setTimeout(() => {
+      unmappedRefetchTimerRef.current = null;
+      const latestWorkflows = boardWorkflowsRef.current;
+      if (!latestWorkflows) return;
+      const stillUnmapped = tasksRef.current.some((task) => latestWorkflows.taskWorkflowIds[task.id] === undefined);
+      if (stillUnmapped) refreshBoardWorkflows({ forceFresh: true });
+    }, 0);
+  }, [boardWorkflows, refreshBoardWorkflows, tasks, workflowMode]);
+
+  useEffect(() => () => {
+    if (unmappedRefetchTimerRef.current) clearTimeout(unmappedRefetchTimerRef.current);
+  }, []);
+
   const resolveWorkflowQuickCreateTarget = useCallback((targetWorkflowId: string, preferredColumnId?: string | null): ColumnId | undefined => {
     if (targetWorkflowId === ALL_WORKFLOWS_BOARD_VIEW_ID) return undefined;
     const workflow = boardWorkflows?.workflows.find((candidate) => candidate.id === targetWorkflowId);
@@ -578,8 +618,15 @@ export function Board({ tasks, projectId, maxConcurrent, showWorktreeGrouping, o
     const grouped: Record<string, Task[]> = {};
     if (!selectedWorkflow) return grouped;
     for (const column of selectedWorkflow.columns) grouped[column.id] = [];
+    /*
+    FNXC:WorkflowBoard 2026-07-05-14:20:
+    Safety net (defense in depth for the taskWorkflowIds refetch above): a card that passed the selected-workflow membership filter genuinely belongs on THIS board, so it must always land in a rendered lane. If its stored `column` is not one this workflow declares (a workflow edited to drop a column, or a create/refetch race that lands an intake-column card before its lane is known), re-home it for DISPLAY into the workflow's intake/first visible column instead of a `??=`-created bucket that is never rendered. Display-only — the task's stored column is untouched.
+    */
     for (const task of selectedWorkflowTasks) {
-      (grouped[task.column] ??= []).push(task);
+      const columnId = grouped[task.column] !== undefined
+        ? task.column
+        : (selectedWorkflowCreateColumnId ?? task.column);
+      (grouped[columnId] ??= []).push(task);
     }
     for (const column of selectedWorkflow.columns) {
       /*
@@ -592,7 +639,7 @@ export function Board({ tasks, projectId, maxConcurrent, showWorktreeGrouping, o
         : sortTasksForDisplayColumn(grouped[column.id] ?? [], column.id as ColumnType);
     }
     return grouped;
-  }, [doneSortMode, selectedWorkflow, selectedWorkflowTasks]);
+  }, [doneSortMode, selectedWorkflow, selectedWorkflowCreateColumnId, selectedWorkflowTasks]);
 
   // Card-placed field defs grouped by workflow id (U13/KTD-14). Only recomputes
   // when the board-workflows payload changes, not on every SSE task tick.
diff --git a/packages/dashboard/app/components/__tests__/board-quickcreate-workflow-lane-visibility.test.tsx b/packages/dashboard/app/components/__tests__/board-quickcreate-workflow-lane-visibility.test.tsx
index 28964c172a..b6c8167549 100644
--- a/packages/dashboard/app/components/__tests__/board-quickcreate-workflow-lane-visibility.test.tsx
+++ b/packages/dashboard/app/components/__tests__/board-quickcreate-workflow-lane-visibility.test.tsx
@@ -183,6 +183,9 @@ function BoardHarness({ createdTaskId = "FN-new", createReturnsTask = true, onCr
       onNewTask={vi.fn()}
       autoMerge
       onToggleAutoMerge={vi.fn()}
+      showWorktreeGrouping={false}
+      planAutoApproveEnabled={false}
+      onTogglePlanAutoApprove={vi.fn()}
       workflowColumnsEnabled
       settingsLoaded
     />
@@ -360,3 +363,112 @@ describe("workflow lane quick-create visibility", () => {
     expect(readWorkflowCache()?.taskWorkflowIds["FN-new"]).toBe(DEFAULT_WORKFLOW.id);
   });
 });
+
+/*
+FNXC:WorkflowBoard 2026-07-05-14:20:
+Regression coverage for the disappearing intake-column card (Coding (Ideas) → "ideas", FN-7591 fallout).
+Surface enumeration:
+ - Create-path independence: tasks that arrive via the `tasks` prop (SSE / QuickEntryBox / NewTaskModal / InlineCreateCard→TodoView / insight→task) — i.e. NOT the board's own optimistic-seeding quick-create — must still resolve their real workflow. Invariant: an unmapped rendered task forces one board-workflows refetch (Part A), and once mapped renders in its intake lane instead of being dropped.
+ - No infinite loop: if the refetch never maps the task, the signature guard fires the refetch at most once per distinct unmapped-id set.
+ - Orphan column safety net (Part B): a task that belongs to the selected workflow but whose stored column the workflow no longer declares renders in the intake lane, never vanishing.
+*/
+function boardProps(tasks: Task[]) {
+  return {
+    tasks,
+    projectId: PROJECT_ID,
+    maxConcurrent: 2,
+    onMoveTask: vi.fn(),
+    onOpenDetail: vi.fn(),
+    addToast: vi.fn(),
+    onQuickCreate: vi.fn(),
+    onNewTask: vi.fn(),
+    autoMerge: true,
+    onToggleAutoMerge: vi.fn(),
+    showWorktreeGrouping: false,
+    planAutoApproveEnabled: false,
+    onTogglePlanAutoApprove: vi.fn(),
+    workflowColumnsEnabled: true as const,
+    settingsLoaded: true as const,
+  };
+}
+
+describe("workflow lane visibility for externally-arriving tasks (FN-7591 disappearing-card fix)", () => {
+  it("force-refetches board-workflows and renders an intake-column task that arrives via the tasks prop (non-board create surface)", async () => {
+    // Model the server: board-workflows derives taskWorkflowIds from the current store tasks,
+    // so once the ideas task exists it maps to Coding (Ideas) on the next fetch.
+    const serverMappedIds = new Set<string>();
+    fetchBoardWorkflowsMock.mockImplementation(() => {
+      const map: Record<string, string> = {};
+      for (const id of serverMappedIds) map[id] = CODING_IDEAS_WORKFLOW.id;
+      return Promise.resolve(workflowPayload(map));
+    });
+
+    const { rerender } = render(<Board {...boardProps([])} />);
+    await screen.findByTestId("workflow-switcher");
+    selectWorkflow(CODING_IDEAS_WORKFLOW.id);
+
+    const callsBeforeArrival = fetchBoardWorkflowsMock.mock.calls.length;
+
+    // A card lands in the "ideas" intake column via a surface that does NOT optimistically
+    // seed taskWorkflowIds (the store already persisted its workflow selection).
+    serverMappedIds.add("FN-ext");
+    const ideasTask = mkTask({ id: "FN-ext", title: "Ext ideas card", column: "ideas" });
+    await act(async () => {
+      rerender(<Board {...boardProps([ideasTask])} />);
+    });
+
+    // Part A: an unmapped rendered task forces a fresh board-workflows fetch.
+    await waitFor(() => expect(fetchBoardWorkflowsMock.mock.calls.length).toBeGreaterThan(callsBeforeArrival));
+
+    // Once mapped, the card renders in the ideas lane instead of being dropped.
+    await waitFor(() => {
+      const ideasColumn = screen.getByTestId("column-ideas");
+      expect(within(ideasColumn).getByText("Ext ideas card")).toBeTruthy();
+    });
+  });
+
+  it("fires a bounded number of refetches for a persistently-unmapped task (no infinite loop)", async () => {
+    // The server never maps FN-ext, so it stays unmapped after every refetch.
+    fetchBoardWorkflowsMock.mockResolvedValue(workflowPayload({}));
+
+    const { rerender } = render(<Board {...boardProps([])} />);
+    await screen.findByTestId("workflow-switcher");
+    selectWorkflow(CODING_IDEAS_WORKFLOW.id);
+
+    const ideasTask = mkTask({ id: "FN-ext", title: "Ext ideas card", column: "ideas" });
+    await act(async () => {
+      rerender(<Board {...boardProps([ideasTask])} />);
+    });
+
+    // Let the single deferred refetch fire; the signature guard blocks reschedules for the same set.
+    await waitFor(() => expect(fetchBoardWorkflowsMock.mock.calls.length).toBeGreaterThanOrEqual(2));
+    const settled = fetchBoardWorkflowsMock.mock.calls.length;
+
+    // Extra renders with the SAME unmapped-id set must not schedule further refetches.
+    for (let i = 0; i < 3; i++) {
+      await act(async () => {
+        rerender(<Board {...boardProps([ideasTask])} />);
+      });
+    }
+    await act(async () => {
+      await new Promise((resolve) => setTimeout(resolve, 5));
+    });
+    expect(fetchBoardWorkflowsMock.mock.calls.length).toBe(settled);
+  });
+
+  it("renders a selected-workflow task whose column the workflow no longer declares in the intake lane (never dropped)", async () => {
+    // FN-orphan is correctly mapped to Coding (Ideas) but sits in a column the workflow does not declare.
+    fetchBoardWorkflowsMock.mockResolvedValue(workflowPayload({ "FN-orphan": CODING_IDEAS_WORKFLOW.id }));
+    const orphan = mkTask({ id: "FN-orphan", title: "Orphan column card", column: "removed-column" });
+
+    render(<Board {...boardProps([orphan])} />);
+    await screen.findByTestId("workflow-switcher");
+    selectWorkflow(CODING_IDEAS_WORKFLOW.id);
+
+    // Part B safety net: re-homed for display into the intake ("ideas") lane, not dropped.
+    await waitFor(() => {
+      const ideasColumn = screen.getByTestId("column-ideas");
+      expect(within(ideasColumn).getByText("Orphan column card")).toBeTruthy();
+    });
+  });
+});
diff --git a/packages/dashboard/app/hooks/useBoardWorkflows.ts b/packages/dashboard/app/hooks/useBoardWorkflows.ts
index 8d2a44e469..e1abdbe765 100644
--- a/packages/dashboard/app/hooks/useBoardWorkflows.ts
+++ b/packages/dashboard/app/hooks/useBoardWorkflows.ts
@@ -54,8 +54,9 @@ export interface UseBoardWorkflowsResult {
   /** True when the dashboard-only aggregate workflow view is selected. */
   isAllWorkflowsSelected: boolean;
   setSelectedWorkflowId: Dispatch<SetStateAction<string | null>>;
-  /** Force a fresh fetch (used on switcher open, since task assignment changes emit no workflow SSE). */
-  refreshBoardWorkflows: () => void;
+  /** Force a fresh fetch (used on switcher open, and when the board detects a rendered
+   *  task missing from `taskWorkflowIds`, since task→workflow assignment emits no workflow SSE). */
+  refreshBoardWorkflows: (options?: { forceFresh?: boolean }) => void;
   /**
    * Raw state setter, exposed so Board can apply optimistic task→workflow assignment.
    * Planning does not use this.

From 09a1c9d843e39e0718346da3076508cb36f44c3e Mon Sep 17 00:00:00 2001
From: gsxdsm <gsxdsm@users.noreply.github.com>
Date: Sun, 5 Jul 2026 16:33:21 -0700
Subject: [PATCH 48/65] FN-7596: regression-test the Coding (Ideas)
 manual-intake lifecycle end-to-end

Adds cross-layer regression coverage for the manual-intake parking lifecycle (create -> parked -> operator Start promotion -> poll-time todo-discovery), and clarifies the workflow-steps doc to describe the tested lifecycle.

- packages/core: covers store create -> moveTask promotion out of the parked intake column
- packages/engine: covers triage poll ordering/discovery of the still-unplanned bootstrap-stub card
- packages/dashboard: covers TaskCard's Start affordance for parked cards
- docs: documents the full regression-tested lifecycle for manual-intake column parking (FN-7596)

Files changed:
 docs/workflow-steps.md                             |   2 +-
 .../__tests__/store-create-intake-column.test.ts   |  26 ++++
 .../app/components/__tests__/TaskCard.test.tsx     | 153 +++++++++++++++++++++
 packages/engine/src/__tests__/triage.test.ts       | 119 +++++++++++++++-
 4 files changed, 298 insertions(+), 2 deletions(-)

Fusion-Task-Id: FN-7596

Fusion-Task-Lineage: 267c3d9a-6181-4ca5-b871-7009c0204372

Co-authored-by: Fusion (runfusion.ai) <noreply@runfusion.ai>
---
 docs/workflow-steps.md                        |   2 +-
 .../store-create-intake-column.test.ts        |  26 +++
 .../components/__tests__/TaskCard.test.tsx    | 153 ++++++++++++++++++
 packages/engine/src/__tests__/triage.test.ts  | 119 +++++++++++++-
 4 files changed, 298 insertions(+), 2 deletions(-)

diff --git a/docs/workflow-steps.md b/docs/workflow-steps.md
index 48db90a417..746a4a1c05 100644
--- a/docs/workflow-steps.md
+++ b/docs/workflow-steps.md
@@ -82,7 +82,7 @@ Use this inventory as the documentation map for current workflow behavior:
 | Routing boundary | Agents may select/change a workflow only for explicit user requests or tasks they created; no-commit markers do not imply Quick fix or any other workflow. | This page, [Selecting workflows](#selecting-workflows); [Agents](./agents.md#interactive-cli-chat). |
 | Dashboard board/list/graph selection | Board/List/Header/Graph share durable per-project workflow selection; stale saved ids fall back to a valid workflow. Board adds a dashboard-only **All workflows** aggregate and task workflow-name badges; Graph uses **All workflows** for the full active graph. | [Dashboard Guide → Board View](./dashboard-guide.md#board-view), [Graph View](./dashboard-guide.md#graph-view), and [Workflow Selection and Editor](./dashboard-guide.md#workflow-selection-and-editor). |
 | Create/planning forwarding | Quick-create task creation, Planning Mode, Subtask Breakdown, and the New Task dialog forward the active real workflow id when creating tasks; **All workflows** quick-create chooses a real workflow intake/default column instead of saving a synthetic aggregate id. | [Dashboard Guide → Planning Mode](./dashboard-guide.md#planning-mode). |
-| Manual-intake column parking | Dashboard create surfaces never send an explicit `column`; the store resolves the landing column from the (selected or project-default) workflow's intake column. A workflow whose intake column sets `autoTriage: false` (e.g. built-in Coding (Ideas)'s `ideas` column) parks new cards there instead of auto-planning them, until an operator promotes the card. | [Dashboard Guide → Create/Planning Forwarding](./dashboard-guide.md#planning-mode). |
+| Manual-intake column parking | Dashboard create surfaces never send an explicit `column`; the store resolves the landing column from the (selected or project-default) workflow's intake column. A workflow whose intake column sets `autoTriage: false` (e.g. built-in Coding (Ideas)'s `ideas` column) parks new cards there instead of auto-planning them, until an operator promotes the card. The full lifecycle — create → parked → operator "Start" promotion → poll-time todo-discovery of the still-unplanned (bootstrap-stub) card — is regression-tested at the engine (triage poll ordering/discovery), UI (`TaskCard` Start affordance), and store (create → `moveTask` promotion) layers (FN-7596). | [Dashboard Guide → Create/Planning Forwarding](./dashboard-guide.md#planning-mode). |
 
 ### Skill-backed workflow steps
 
diff --git a/packages/core/src/__tests__/store-create-intake-column.test.ts b/packages/core/src/__tests__/store-create-intake-column.test.ts
index f2c94ea21a..382400c501 100644
--- a/packages/core/src/__tests__/store-create-intake-column.test.ts
+++ b/packages/core/src/__tests__/store-create-intake-column.test.ts
@@ -3,6 +3,7 @@ import { readFile } from "node:fs/promises";
 import { join } from "node:path";
 import type { Task } from "../types.js";
 import { createTaskStoreTestHarness } from "./store-test-helpers.js";
+import { buildBootstrapPrompt } from "../mesh-task-replication.js";
 
 /*
 FNXC:CodingIdeasWorkflow 2026-07-04-11:30:
@@ -80,4 +81,29 @@ describe("createTask intake-column wiring (Coding (Ideas))", () => {
     // A direct todo create is NOT an intake column, so it must NOT get the bootstrap stub.
     expect(prompt).not.toBe(`# ${task.id}\n\n${task.description}\n`);
   });
+
+  /*
+  FNXC:CodingIdeasWorkflow 2026-07-05-00:00:
+  FN-7596 pins the store-level contract the engine's todo-discovery poll (packages/engine/src/triage.ts eligibleTodoTasks) depends on: promoting a parked Ideas card via moveTask alone must NOT plan it. Only the triage service's bootstrap-prompt discovery loop plans a promoted-but-unplanned todo card; moveTask is a pure column transition.
+  */
+  it("promotes an Ideas-parked task to todo without planning it (still bootstrap-stub PROMPT.md)", async () => {
+    const store = harness.store();
+    // Custom (non-legacy) column transitions are validated against the workflow IR
+    // only when the workflowColumns compatibility flag is enabled (KTD-1).
+    await store.updateGlobalSettings({ experimentalFeatures: { workflowColumns: true } });
+    const task = await store.createTask({
+      description: "ideas lifecycle promotion task",
+      workflowId: "builtin:coding-ideas",
+    });
+    expect(task.column).toBe("ideas");
+
+    const moved = await store.moveTask(task.id, "todo", { moveSource: "user" });
+    expect(moved.column).toBe("todo");
+
+    const prompt = await readFile(
+      join(harness.rootDir(), ".fusion", "tasks", task.id, "PROMPT.md"),
+      "utf-8",
+    );
+    expect(prompt).toBe(buildBootstrapPrompt(task.id, task.title, task.description));
+  });
 });
diff --git a/packages/dashboard/app/components/__tests__/TaskCard.test.tsx b/packages/dashboard/app/components/__tests__/TaskCard.test.tsx
index 9cd637d2ab..83c87f28a4 100644
--- a/packages/dashboard/app/components/__tests__/TaskCard.test.tsx
+++ b/packages/dashboard/app/components/__tests__/TaskCard.test.tsx
@@ -6411,3 +6411,156 @@ describe("TaskCard custom field badges (U13/KTD-14)", () => {
     expect(screen.queryByTestId("card-field-badges")).toBeNull();
   });
 });
+
+/*
+FNXC:CodingIdeasWorkflow 2026-07-05-00:00:
+FN-7596 regression-tests the TaskCard "Start" affordance that promotes a Coding (Ideas) manual-intake card. `showStartAction` requires taskColumnFlags.intake and a non-"triage" column; `startTargetColumn` derives the destination from `taskMoveColumns` (first non-intake/non-archived/non-hiddenFromBoard column) rather than a hard-coded "todo" string, per the FNXC comment at its call site.
+*/
+describe("TaskCard Start affordance (FN-7596)", () => {
+  it("renders the Start button for a manual-intake column with onMoveTask provided", () => {
+    render(
+      <TaskCard
+        task={makeTask({ column: "ideas" as any })}
+        taskColumnFlags={{ intake: true }}
+        onOpenDetail={noop}
+        addToast={noop}
+        onMoveTask={vi.fn()}
+      />,
+    );
+
+    expect(screen.getByTestId("card-start-FN-001")).toBeInTheDocument();
+  });
+
+  it("omits the Start button when the column is not flagged as an intake", () => {
+    render(
+      <TaskCard
+        task={makeTask({ column: "ideas" as any })}
+        taskColumnFlags={{ intake: false }}
+        onOpenDetail={noop}
+        addToast={noop}
+        onMoveTask={vi.fn()}
+      />,
+    );
+
+    expect(screen.queryByTestId("card-start-FN-001")).toBeNull();
+  });
+
+  it("omits the Start button for the triage column even when intake is flagged", () => {
+    render(
+      <TaskCard
+        task={makeTask({ column: "triage" })}
+        taskColumnFlags={{ intake: true }}
+        onOpenDetail={noop}
+        addToast={noop}
+        onMoveTask={vi.fn()}
+      />,
+    );
+
+    expect(screen.queryByTestId("card-start-FN-001")).toBeNull();
+  });
+
+  it("omits the Start button when no onMoveTask handler is provided", () => {
+    render(
+      <TaskCard
+        task={makeTask({ column: "ideas" as any })}
+        taskColumnFlags={{ intake: true }}
+        onOpenDetail={noop}
+        addToast={noop}
+      />,
+    );
+
+    expect(screen.queryByTestId("card-start-FN-001")).toBeNull();
+  });
+
+  it("derives the Start target from taskMoveColumns instead of a hard-coded 'todo' string", async () => {
+    const onMoveTask = vi.fn().mockResolvedValue(makeTask({ column: "custom-working-stage" as any }));
+    const addToast = vi.fn();
+    // The intake column itself, plus a non-intake working column that is NOT literally
+    // named "todo", must win over any coincidental fallback — proving derivation, not a hard-coded string.
+    const taskMoveColumns = [
+      { id: "ideas" as any, label: "Ideas", flags: { intake: true } },
+      { id: "custom-working-stage" as any, label: "Custom Working Stage", flags: {} },
+      { id: "todo" as any, label: "Todo", flags: {} },
+    ];
+
+    render(
+      <TaskCard
+        task={makeTask({ column: "ideas" as any })}
+        taskColumnFlags={{ intake: true }}
+        taskMoveColumns={taskMoveColumns}
+        onOpenDetail={noop}
+        addToast={addToast}
+        onMoveTask={onMoveTask}
+      />,
+    );
+
+    fireEvent.click(screen.getByTestId("card-start-FN-001"));
+
+    await waitFor(() => expect(onMoveTask).toHaveBeenCalledWith("FN-001", "custom-working-stage"));
+  });
+
+  it("falls back to 'todo' when taskMoveColumns metadata is unavailable", async () => {
+    const onMoveTask = vi.fn().mockResolvedValue(makeTask({ column: "todo" }));
+    render(
+      <TaskCard
+        task={makeTask({ column: "ideas" as any })}
+        taskColumnFlags={{ intake: true }}
+        onOpenDetail={noop}
+        addToast={noop}
+        onMoveTask={onMoveTask}
+      />,
+    );
+
+    fireEvent.click(screen.getByTestId("card-start-FN-001"));
+
+    await waitFor(() => expect(onMoveTask).toHaveBeenCalledWith("FN-001", "todo"));
+  });
+
+  it("disables the button and shows the Starting label while the move is in flight, then shows a success toast", async () => {
+    let resolveMove: (task: ReturnType<typeof makeTask>) => void = () => {};
+    const onMoveTask = vi.fn().mockImplementation(
+      () => new Promise((resolve) => { resolveMove = resolve; }),
+    );
+    const addToast = vi.fn();
+
+    render(
+      <TaskCard
+        task={makeTask({ column: "ideas" as any })}
+        taskColumnFlags={{ intake: true }}
+        onOpenDetail={noop}
+        addToast={addToast}
+        onMoveTask={onMoveTask}
+      />,
+    );
+
+    const startButton = screen.getByTestId("card-start-FN-001");
+    fireEvent.click(startButton);
+
+    await waitFor(() => expect(startButton).toBeDisabled());
+    expect(startButton.textContent).toContain("Starting");
+
+    resolveMove(makeTask({ column: "todo" }));
+
+    await waitFor(() => expect(addToast).toHaveBeenCalledWith(expect.stringContaining("FN-001"), "success"));
+    await waitFor(() => expect(startButton).not.toBeDisabled());
+  });
+
+  it("shows an error toast when the Start move fails", async () => {
+    const onMoveTask = vi.fn().mockRejectedValue(new Error("move blocked"));
+    const addToast = vi.fn();
+
+    render(
+      <TaskCard
+        task={makeTask({ column: "ideas" as any })}
+        taskColumnFlags={{ intake: true }}
+        onOpenDetail={noop}
+        addToast={addToast}
+        onMoveTask={onMoveTask}
+      />,
+    );
+
+    fireEvent.click(screen.getByTestId("card-start-FN-001"));
+
+    await waitFor(() => expect(addToast).toHaveBeenCalledWith("move blocked", "error"));
+  });
+});
diff --git a/packages/engine/src/__tests__/triage.test.ts b/packages/engine/src/__tests__/triage.test.ts
index 506bab4734..37e0cb310d 100644
--- a/packages/engine/src/__tests__/triage.test.ts
+++ b/packages/engine/src/__tests__/triage.test.ts
@@ -1,6 +1,6 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
 import type { TaskStore, Task, TaskDetail, Settings } from "@fusion/core";
-import { builtinSeamPrompt, computePlanApprovalFingerprint, MAX_TASK_LIST_TEXT_CHARS, renderTriagePolicyPlaceholders, resolveAgentPrompt } from "@fusion/core";
+import { builtinSeamPrompt, buildBootstrapPrompt, computePlanApprovalFingerprint, MAX_TASK_LIST_TEXT_CHARS, renderTriagePolicyPlaceholders, resolveAgentPrompt } from "@fusion/core";
 import {
   TriageProcessor,
   buildSpecificationPrompt,
@@ -2392,6 +2392,123 @@ describe("TriageProcessor", () => {
     });
   });
 
+  /*
+  FNXC:CodingIdeasWorkflow 2026-07-05-00:00:
+  FN-7596 pins the Coding (Ideas) manual-intake lifecycle at the poll-dispatch boundary: an `ideas`-column card must stay parked (never auto-dispatched via `eligibleTriageTasks`, which only matches `column === "triage"`), while a promoted `todo`-column card whose PROMPT.md is still the bootstrap stub must be discovered and specified via `eligibleTodoTasks`'s bootstrap-prompt file check. A `todo` card with a real (non-bootstrap) spec must NOT be re-dispatched, guarding against double-specifying an already-planned card.
+  */
+  describe("Coding (Ideas) manual-intake discovery (FN-7596)", () => {
+    it("excludes a parked ideas-column task from the poll's specify-dispatch set", async () => {
+      const tasks: Task[] = [
+        createTriageTask({ id: "FN-IDEAS-PARKED", column: "ideas" as any, priority: "urgent" }),
+      ];
+
+      const triageStore = createMockStore({
+        listTasks: vi.fn().mockResolvedValue(tasks),
+        getSettings: vi.fn().mockResolvedValue({
+          maxConcurrent: 10,
+          maxTriageConcurrent: 10,
+          pollIntervalMs: 10_000,
+          groupOverlappingFiles: false,
+          autoMerge: true,
+        }),
+      });
+      const triageProcessor = new TriageProcessor(triageStore, rootDir);
+      const specifySpy = vi
+        .spyOn(triageProcessor, "specifyTask")
+        .mockResolvedValue(undefined);
+
+      (triageProcessor as any).running = true;
+      await (triageProcessor as any).poll();
+
+      expect(specifySpy).not.toHaveBeenCalled();
+    });
+
+    it("discovers a promoted todo-column task whose PROMPT.md is still the bootstrap stub", async () => {
+      const tempRoot = await createTriageFixtureRoot("fusion-triage-ideas-discovery-");
+      const promotedId = "FN-IDEAS-PROMOTED";
+      try {
+        const promotedTask = createTriageTask({
+          id: promotedId,
+          title: "Promoted from Ideas intake",
+          description: "Promoted intake task",
+          column: "todo",
+          priority: "urgent",
+        });
+        await mkdir(join(tempRoot, ".fusion", "tasks", promotedId), { recursive: true });
+        await writeFile(
+          join(tempRoot, ".fusion", "tasks", promotedId, "PROMPT.md"),
+          buildBootstrapPrompt(promotedId, promotedTask.title, promotedTask.description),
+          "utf-8",
+        );
+
+        const triageStore = createMockStore({
+          listTasks: vi.fn().mockResolvedValue([promotedTask]),
+          getSettings: vi.fn().mockResolvedValue({
+            maxConcurrent: 10,
+            maxTriageConcurrent: 10,
+            pollIntervalMs: 10_000,
+            groupOverlappingFiles: false,
+            autoMerge: true,
+          }),
+        });
+        const triageProcessor = new TriageProcessor(triageStore, tempRoot);
+        const specifySpy = vi
+          .spyOn(triageProcessor, "specifyTask")
+          .mockResolvedValue(undefined);
+
+        (triageProcessor as any).running = true;
+        await (triageProcessor as any).poll();
+
+        expect(specifySpy).toHaveBeenCalledTimes(1);
+        expect(specifySpy).toHaveBeenCalledWith(expect.objectContaining({ id: promotedId }));
+      } finally {
+        await cleanupTriageFixtureRoot(tempRoot);
+      }
+    });
+
+    it("does not re-dispatch a todo-column task whose PROMPT.md already carries a real (non-bootstrap) spec", async () => {
+      const tempRoot = await createTriageFixtureRoot("fusion-triage-ideas-planned-");
+      const plannedId = "FN-IDEAS-PLANNED";
+      try {
+        const plannedTask = createTriageTask({
+          id: plannedId,
+          title: "Already planned todo task",
+          description: "Already planned intake task",
+          column: "todo",
+          priority: "urgent",
+        });
+        await mkdir(join(tempRoot, ".fusion", "tasks", plannedId), { recursive: true });
+        await writeFile(
+          join(tempRoot, ".fusion", "tasks", plannedId, "PROMPT.md"),
+          `# Task: ${plannedId} - Already planned todo task\n\n## Mission\n\nThis task carries a real spec, not the bootstrap stub.\n`,
+          "utf-8",
+        );
+
+        const triageStore = createMockStore({
+          listTasks: vi.fn().mockResolvedValue([plannedTask]),
+          getSettings: vi.fn().mockResolvedValue({
+            maxConcurrent: 10,
+            maxTriageConcurrent: 10,
+            pollIntervalMs: 10_000,
+            groupOverlappingFiles: false,
+            autoMerge: true,
+          }),
+        });
+        const triageProcessor = new TriageProcessor(triageStore, tempRoot);
+        const specifySpy = vi
+          .spyOn(triageProcessor, "specifyTask")
+          .mockResolvedValue(undefined);
+
+        (triageProcessor as any).running = true;
+        await (triageProcessor as any).poll();
+
+        expect(specifySpy).not.toHaveBeenCalled();
+      } finally {
+        await cleanupTriageFixtureRoot(tempRoot);
+      }
+    });
+  });
+
   it("runs deterministic validation without calling the spec reviewer", async () => {
     const taskId = "FN-001";
     const testRootDir = await createTriageFixtureRoot("fusion-triage-plan-validation-");

From c0abca90d8e7a5e6cf504dc07fe32bcdef0f26be Mon Sep 17 00:00:00 2001
From: gsxdsm <gsxdsm@users.noreply.github.com>
Date: Sun, 5 Jul 2026 16:51:05 -0700
Subject: [PATCH 49/65] FN-7598: add planner-oversight discovery pointers to
 README and docs hub
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Docs-only change adding front-door discovery for the already-shipped planner-oversight feature (FN-7508 → FN-7583), which previously had no entry point outside internal reference docs.

- Add a README.md feature table row and a new "Planner oversight" section describing oversight levels (off/observe/steer/autonomous) and the always-on human-confirmation gate for merge/PR and destructive actions, linking to Settings Reference and Dashboard Guide
- Add a README.md capabilities bullet cross-linking the new section
- Add a docs/README.md hub row pointing to Settings Reference, Dashboard Guide, and Architecture for planner oversight, and extend the 'power user' reading path
- Add a one-line pointer in docs/getting-started.md workflow section noting per-task/workflow oversight controls

Files changed:
 README.md               | 11 +++++++++++
 docs/README.md          |  9 ++++++---
 docs/getting-started.md |  3 +++
 3 files changed, 20 insertions(+), 3 deletions(-)

Fusion-Task-Id: FN-7598

Fusion-Task-Lineage: 8141b44c-f007-45c0-a057-f4eeb34ae8d4

Co-authored-by: Fusion (runfusion.ai) <noreply@runfusion.ai>
---
 README.md               | 11 +++++++++++
 docs/README.md          |  9 ++++++---
 docs/getting-started.md |  3 +++
 3 files changed, 20 insertions(+), 3 deletions(-)

diff --git a/README.md b/README.md
index 7092cce277..b75e16bd9c 100644
--- a/README.md
+++ b/README.md
@@ -136,6 +136,7 @@ Every task shows its plan, its reviews, its diffs, and its file changes in real
 |---|---|
 | 🧠 **AI planning** | Describe a task in plain language. Planning agents turn it into a `PROMPT.md` plan with steps, file scope, and acceptance criteria. |
 | 🔁 **Selectable workflows** | Built-ins cover coding, quick fixes, review-heavy work, stepwise execution, plugin-gated Compound Engineering, and PR lifecycle fragments. Pick a workflow per task or author custom ones in the [Workflow Editor](./docs/workflow-editor.md). |
+| 🛡️ **Planner oversight** | Per-task or per-workflow oversight level (`off` / `observe` / `steer` / `autonomous`) governs how closely a planner overseer watches and intervenes — merge/PR and destructive actions always require explicit human confirmation. See [Settings Reference](./docs/settings-reference.md#workflow-settings) and [Dashboard Guide](./docs/dashboard-guide.md). |
 | 🌳 **Worktree isolation** | Each task runs in its own branch and worktree (`fusion/{task-id}`). Parallel tasks. Zero conflicts. Optional [worktrunk](https://github.com/max-sixty/worktrunk) delegation via [`worktrunk.enabled`](./docs/settings-reference.md#worktree-backend-settings) (see [WorktreeBackend abstraction](./docs/architecture.md#worktreebackend-abstraction)). |
 | ⚡ **Smart merge controls** | Passing every gate? Fusion squash-merges and moves on. Opt into manual approval anywhere, inherit the live global auto-merge default, or set explicit per-task auto/manual overrides. |
 | 🛰️ **Multi-node mesh** | Laptop, Mac mini, Linux server, cloud VM, phone — all synced. Desktop, mobile, web. |
@@ -385,6 +386,15 @@ Fusion workflows define how a task moves from idea to delivery. The default codi
 
 Read [Workflow Steps](./docs/workflow-steps.md) for runtime semantics, built-in workflow behavior, and workflow-step templates; read [Workflow Editor](./docs/workflow-editor.md) for the dashboard authoring guide.
 
+<!--
+FNXC:PlannerOversight 2026-07-05-00:00:
+The planner-oversight feature (FN-7508 → FN-7583) shipped fully documented in internal/reference docs (architecture.md, settings-reference.md, dashboard-guide.md, workflow-steps.md) but had no front-door entry point in README.md, so a new operator could not discover it. Add a short overview here that links out to the canonical docs instead of duplicating engine internals (FN-7598).
+-->
+
+### Planner oversight
+
+Each workflow (and optionally each task) can set a **planner oversight** level — `off`, `observe`, `steer`, or `autonomous` (default) — controlling how closely a planner overseer watches and intervenes in that task's execution. Even at `autonomous`, merge/PR progression and any destructive or external-service side effect always require an explicit, recorded human confirmation before they run. Notification verbosity is controlled separately. Set the default in the **Workflow Editor → Values** tab, or override per task from the New Task dialog / Task Detail edit form. Read [Settings Reference](./docs/settings-reference.md#workflow-settings) for the full setting semantics and [Dashboard Guide](./docs/dashboard-guide.md) for the UI controls.
+
 ---
 
 ## Multi-node. One board. Every platform.
@@ -504,6 +514,7 @@ npx companies.sh add paperclipai/companies/gstack
 - **Visual Workflow Editor** — Inspect read-only built-ins, duplicate/customize workflows, and edit graph nodes, columns, task fields, typed settings, and per-project values ([Workflow Editor](./docs/workflow-editor.md))
 - **Workflow Steps** — Configurable quality gates (pre-merge: blocks merge; post-merge: informational), plus workflow-declared optional steps such as opt-in [Browser Verification](./docs/workflow-steps.md#workflow-declared-optional-steps)
 - **Workflow-native policy** — Fast-mode planning (`leanPlanning` / `autoApproveSpec`), typed triage thresholds, review/approval, step execution, and model/fallback lanes are workflow settings, not hard-coded engine constants ([Settings Reference](./docs/settings-reference.md#workflow-native-triage-policy-settings); [workflow settings](./docs/settings-reference.md#workflow-settings))
+- **Planner oversight** — Workflow-native `plannerOversightLevel` (`off`/`observe`/`steer`/`autonomous`), with an optional per-task override and a separate notification-verbosity setting; merge/PR progression and destructive actions always require explicit human confirmation, even at `autonomous` ([overview](#planner-oversight); [Settings Reference](./docs/settings-reference.md#workflow-settings))
 - **GitHub + PR lifecycle** — Import issues, create PRs, display real-time PR/issue badges, and use workflow-mode PR lifecycle graph fragments where enabled
 - **Dashboard** — Real-time kanban/list/graph views, agent management, terminal, git manager, mission planner, chat, workflow editor, custom provider setup, and one-click update action
 - **Missions** — Hierarchical planning (Mission → Milestone → Slice → Feature → Task) with autopilot, validation contracts, fix-feature retries, mission-goal linking, and blocked-handoff semantics
diff --git a/docs/README.md b/docs/README.md
index 9b0c003a59..28d5bfba19 100644
--- a/docs/README.md
+++ b/docs/README.md
@@ -43,11 +43,14 @@ For a full walkthrough (installation, onboarding, first task, and daily workflow
 | [Multi-Project](./multi-project.md) | Central registry architecture, project management, isolation modes, and migration paths |
 
 ### Configuration & Agents
-| Guide | Description |
-|---|---|
+<!--
+FNXC:DocsIndex 2026-07-05-00:00:
+Planner oversight (FN-7508 → FN-7583) is fully documented in Settings Reference, Dashboard Guide, and Architecture but had no index entry, so it was undiscoverable from the docs hub. Add a labeled pointer row rather than a new doc, since the existing reference docs already cover the feature end to end (FN-7598).
+-->
 | [Settings Reference](./settings-reference.md) | Global/project settings, workflow setting values, model/fallback lane hierarchy, defaults, and API endpoints |
 | [MCP](./mcp.md) | Model Context Protocol server configuration, secret references, validation, CLI, dashboard, and import/export workflows |
 | [Agents](./agents.md) | Agent management, presets, prompts, heartbeat behavior, spawning, and mailbox workflows |
+| Planner Oversight (see [Settings Reference](./settings-reference.md#workflow-settings), [Dashboard Guide](./dashboard-guide.md), [Architecture](./architecture.md)) | Workflow-native oversight levels (`off`/`observe`/`steer`/`autonomous`), per-task overrides, notification verbosity, the human-confirmation gate on merge/PR and destructive actions, and the Task Detail overseer controls/Intervention Timeline |
 
 ### Architecture & Development
 | Guide | Description |
@@ -151,5 +154,5 @@ FN-7088 links previously-unlinked first-class testing and baseline docs here so
 
 - **New user:** Getting Started → Dashboard Guide → Task Management
 - **Workflow author:** Dashboard Guide → Workflow Editor → Workflow Steps → Settings Reference
-- **Power user / automation owner:** Settings Reference → Workflow Steps → Agents
+- **Power user / automation owner:** Settings Reference → Workflow Steps → Agents → Planner Oversight (Settings Reference § Workflow Settings)
 - **Maintainer / contributor:** Architecture → Multi-Project → Contributing
diff --git a/docs/getting-started.md b/docs/getting-started.md
index 0436bb6002..74bd81d7ba 100644
--- a/docs/getting-started.md
+++ b/docs/getting-started.md
@@ -137,6 +137,9 @@ Most tasks can use the default **Coding** workflow. When the workflow selector i
 
 Built-ins include task-selectable Coding, Legacy coding, Quick fix, Review-heavy, plugin-gated Compound engineering, Coding (per-step review), and Design workflows, plus PR lifecycle fragments for workflow authors. For the full catalog and runtime behavior, see [Workflow Steps](./workflow-steps.md#workflow-overview). To inspect built-ins or author custom workflows, open the dashboard [Workflow Editor](./workflow-editor.md).
 
+<!-- FNXC:PlannerOversight 2026-07-05-00:00: shipped planner-oversight feature (FN-7508 → FN-7583) had no getting-started pointer, so new operators could not discover per-task/workflow oversight controls; add a one-line pointer to the reference docs (FN-7598). -->
+Workflows (and individual tasks) also have a **Planner oversight** level (`off`/`observe`/`steer`/`autonomous`) that controls how closely a planner overseer watches and can intervene; see [Settings Reference](./settings-reference.md#workflow-settings) for the setting semantics and [Dashboard Guide](./dashboard-guide.md) for the UI controls.
+
 ## Understand the Task Lifecycle
 
 Fusion uses six default lifecycle columns:

From 20379e81c5a6b40a9eb40b365ae7a145c9c7207a Mon Sep 17 00:00:00 2001
From: gsxdsm <gsxdsm@users.noreply.github.com>
Date: Sun, 5 Jul 2026 16:56:22 -0700
Subject: [PATCH 50/65] FN-7597: style task-detail Priority dropdown to match
 Oversight dropdown

Aligns the task-detail Priority dropdown's size, border, and typography with the Oversight dropdown so both controls read as one consistent style.

- Give the untinted `normal` priority level a neutral, token-based chip background (scoped to `.detail-priority-chip.card-priority-badge--normal`) instead of an empty bordered shell, matching the Oversight `--off` chip treatment.
- Remove the Priority-only forced uppercase text-transform on the select/option so it relies on the ancestor label's uppercase transform like the Oversight select does.
- Add regression coverage asserting shared box-size/border tokens across the Priority chip, Oversight chip, and mobile Oversight overflow trigger, no duplicated text-transform overrides, preserved low/high/urgent semantic tints, and unaffected --saving state.
- Add a patch changeset documenting the fix.

Files changed:
 .changeset/fn-7597-priority-dropdown-matches-oversight.md          |  7 +++
 packages/dashboard/app/components/TaskDetailModal.css              | 27 ++++++++++--
 packages/dashboard/app/components/__tests__/TaskDetailModal.responsive-and-dependencies.test.tsx | 51 ++++++++++++++++++++++
 3 files changed, 82 insertions(+), 3 deletions(-)

Fusion-Task-Id: FN-7597

Fusion-Task-Lineage: d703e59a-35d8-4788-9ad2-1462d6f3c588

Co-authored-by: Fusion (runfusion.ai) <noreply@runfusion.ai>
---
 ...597-priority-dropdown-matches-oversight.md |  7 +++
 .../app/components/TaskDetailModal.css        | 27 ++++++++--
 ...Modal.responsive-and-dependencies.test.tsx | 51 +++++++++++++++++++
 3 files changed, 82 insertions(+), 3 deletions(-)
 create mode 100644 .changeset/fn-7597-priority-dropdown-matches-oversight.md

diff --git a/.changeset/fn-7597-priority-dropdown-matches-oversight.md b/.changeset/fn-7597-priority-dropdown-matches-oversight.md
new file mode 100644
index 0000000000..4d89e6363c
--- /dev/null
+++ b/.changeset/fn-7597-priority-dropdown-matches-oversight.md
@@ -0,0 +1,7 @@
+---
+"@runfusion/fusion": patch
+---
+
+summary: Task-detail Priority dropdown now matches the Oversight dropdown's size, border, and typography.
+category: fix
+dev: Removed the Priority-only forced select/option uppercase, added a neutral chip background scoped to `.detail-priority-chip.card-priority-badge--normal` for the untinted `normal` level, and reused the FN-7585 shared `--btn-border-width`/`--border`/`--detail-control-border-radius`/`--detail-priority-control-min-height` tokens so both dropdowns render as one control style across desktop and the mobile oversight-overflow surface.
diff --git a/packages/dashboard/app/components/TaskDetailModal.css b/packages/dashboard/app/components/TaskDetailModal.css
index c4418e0345..93f0b22277 100644
--- a/packages/dashboard/app/components/TaskDetailModal.css
+++ b/packages/dashboard/app/components/TaskDetailModal.css
@@ -415,13 +415,27 @@ The task-detail modal metadata must keep priority, execution mode, provenance, P
   opacity: 0.75;
 }
 
+/*
+FNXC:TaskDetail 2026-07-05-12:00:
+FN-7597 — the untinted `normal` priority level has no `--low/--high/--urgent`
+tint, so without this rule it renders as a bordered-but-empty shell while the
+Oversight chip's `--off` level always gets a neutral, token-based background
+(`.card-oversight-badge--off` in TaskCard.css). Give `.detail-priority-chip`'s
+`normal` state the SAME neutral `color-mix(... var(--text-muted) ...)`
+treatment so the two dropdowns read as one consistent control style. Scoped
+to the detail chip (not a global `.card-priority-badge--normal` rule) so the
+read-only TaskCard priority badge (out of scope) is untouched.
+*/
+.detail-priority-chip.card-priority-badge--normal {
+  background: color-mix(in srgb, var(--text-muted) 12%, transparent);
+  color: var(--text-muted);
+}
+
 .detail-priority-select {
   border: 0;
   background: transparent;
   color: inherit;
   font: inherit;
-  text-transform: uppercase;
-  letter-spacing: inherit;
   cursor: pointer;
   padding: 0;
   min-height: inherit;
@@ -437,10 +451,17 @@ The task-detail modal metadata must keep priority, execution mode, provenance, P
   cursor: wait;
 }
 
+/*
+FNXC:TaskDetail 2026-07-05-12:00:
+FN-7597 — drop the Priority-only forced uppercase on the select/option so its
+typography matches `.detail-oversight-select` exactly (which relies on the
+ancestor `.card-*-badge` label's own `text-transform: uppercase` instead of
+redeclaring it here). Visual case is unchanged since the label already
+uppercases its content; this only removes a duplicated, drift-prone override.
+*/
 .detail-priority-select option {
   color: var(--text);
   background: var(--surface);
-  text-transform: uppercase;
 }
 
 .detail-execution-mode-toggle {
diff --git a/packages/dashboard/app/components/__tests__/TaskDetailModal.responsive-and-dependencies.test.tsx b/packages/dashboard/app/components/__tests__/TaskDetailModal.responsive-and-dependencies.test.tsx
index 9e348aadaa..f988e2b5ce 100644
--- a/packages/dashboard/app/components/__tests__/TaskDetailModal.responsive-and-dependencies.test.tsx
+++ b/packages/dashboard/app/components/__tests__/TaskDetailModal.responsive-and-dependencies.test.tsx
@@ -253,6 +253,57 @@ describe("TaskDetailModal", () => {
       expect(oversightChipBlock).not.toMatch(/border-radius:\s*var\(--radius-pill\)/);
     });
 
+    it("renders the Priority dropdown chip like the Oversight dropdown chip, on every surface (FN-7597)", () => {
+      const css = readDashboardStylesSource();
+
+      const priorityChipBlock = getExactCssRuleBlock(css, ".detail-priority-chip");
+      const oversightChipBlock = getExactCssRuleBlock(css, ".detail-oversight-chip");
+      const oversightTriggerBlock = getExactCssRuleBlock(css, ".detail-oversight-menu-trigger");
+      const prioritySelectBlock = getExactCssRuleBlock(css, ".detail-priority-select");
+      const oversightSelectBlock = getExactCssRuleBlock(css, ".detail-oversight-select");
+      const prioritySelectOptionBlock = getExactCssRuleBlock(css, ".detail-priority-select option");
+      const oversightSelectOptionBlock = getExactCssRuleBlock(css, ".detail-oversight-select option");
+
+      // Same box size AND same border source for the desktop Priority chip vs.
+      // BOTH oversight surfaces (desktop chip and the mobile overflow trigger).
+      for (const block of [priorityChipBlock, oversightChipBlock, oversightTriggerBlock]) {
+        expect(block).toContain("min-height: var(--detail-priority-control-min-height);");
+        expect(block).toContain("border-width: var(--btn-border-width);");
+        expect(block).toContain("border-color: var(--border);");
+        expect(block).toContain("border-radius: var(--detail-control-border-radius);");
+        expect(block).toContain("box-sizing: border-box;");
+      }
+
+      // Same select typography: neither select force-uppercases its own text
+      // or options; both rely on the ancestor chip label's uppercase transform,
+      // so a regression re-adding a Priority-only override fails this.
+      expect(prioritySelectBlock).not.toMatch(/text-transform\s*:/);
+      expect(oversightSelectBlock).not.toMatch(/text-transform\s*:/);
+      expect(prioritySelectOptionBlock).not.toMatch(/text-transform\s*:/);
+      expect(oversightSelectOptionBlock).not.toMatch(/text-transform\s*:/);
+      expect(prioritySelectBlock).toContain("font: inherit;");
+      expect(oversightSelectBlock).toContain("font: inherit;");
+
+      // The untinted `normal` priority level must resolve a real, non-transparent
+      // neutral chip background (not a borderless/background-less shell), just
+      // like the Oversight chip's neutral `--off` background.
+      const priorityNormalBlock = getExactCssRuleBlock(css, ".detail-priority-chip.card-priority-badge--normal");
+      const oversightOffBlock = getExactCssRuleBlock(css, ".card-oversight-badge--off");
+      expect(priorityNormalBlock).toMatch(/background:\s*color-mix\(in srgb, var\(--text-muted\)/);
+      expect(oversightOffBlock).toMatch(/background:\s*color-mix\(in srgb, var\(--text-muted\)/);
+
+      // The semantic priority tints (info/warning/error family) must survive —
+      // this task must not flatten low/high/urgent to the same neutral tone.
+      expect(css).toMatch(/\.card-priority-badge--low\s*\{[^}]*background:\s*color-mix\(in srgb, var\(--color-info\)/);
+      expect(css).toMatch(/\.card-priority-badge--high\s*\{[^}]*background:\s*color-mix\(in srgb, var\(--color-warning\)/);
+      expect(css).toMatch(/\.card-priority-badge--urgent\s*\{[^}]*background:\s*color-mix\(in srgb, var\(--color-error\)/);
+
+      // `--saving` only dims opacity; it must never change box size/border.
+      const prioritySavingBlock = getExactCssRuleBlock(css, ".detail-priority-chip--saving");
+      expect(prioritySavingBlock.replace(/\s+/g, "")).toBe("opacity:0.75;");
+      expect(prioritySavingBlock).not.toMatch(/border|min-height|padding/);
+    });
+
     it("keeps grouped timestamp metadata inline on desktop and mobile", () => {
       const css = readDashboardStylesSource();
 

From e0f3d3d14c6529615cd7e92402c5c586b2787239 Mon Sep 17 00:00:00 2001
From: gsxdsm <gsxdsm@users.noreply.github.com>
Date: Sun, 5 Jul 2026 16:58:42 -0700
Subject: [PATCH 51/65] FN-7599: rename triage column label to Planning in
 default workflows

Renames the default-workflow intake column's display label from "Triage" to "Planning" across the built-in coding, stepwise-coding, and PR workflows, while keeping the column id as `triage` for lifecycle/DB/type stability.

- builtin-coding-workflow-ir.ts: intake column name "Triage" -> "Planning"
- builtin-pr-workflow-ir.ts: intake column name "Triage" -> "Planning"
- builtin-stepwise-coding-workflow-ir.ts: intake column name "Triage" -> "Planning"
- Added regression tests asserting the intake column is labeled "Planning" with id "triage" in builtin-coding and hand-authored default workflows (stepwise-coding, pr-workflow)
- Added changeset (patch) documenting the label change for @runfusion/fusion

Files changed:
 .changeset/fn-7599-planning-column-rename.md                 |  7 +++++++
 .../core/src/__tests__/builtin-coding-workflow-ir.test.ts    |  7 +++++++
 packages/core/src/__tests__/builtin-workflows.test.ts        | 12 ++++++++++++
 packages/core/src/builtin-coding-workflow-ir.ts              |  3 ++-
 packages/core/src/builtin-pr-workflow-ir.ts                  |  2 +-
 packages/core/src/builtin-stepwise-coding-workflow-ir.ts     |  2 +-
 6 files changed, 30 insertions(+), 3 deletions(-)

Fusion-Task-Id: FN-7599

Fusion-Task-Lineage: 5de8abc4-2407-4f9a-b97c-bd5b900d8fd9

Co-authored-by: Fusion (runfusion.ai) <noreply@runfusion.ai>
---
 .changeset/fn-7599-planning-column-rename.md         |  7 +++++++
 .../src/__tests__/builtin-coding-workflow-ir.test.ts |  7 +++++++
 .../core/src/__tests__/builtin-workflows.test.ts     | 12 ++++++++++++
 packages/core/src/builtin-coding-workflow-ir.ts      |  3 ++-
 packages/core/src/builtin-pr-workflow-ir.ts          |  2 +-
 .../core/src/builtin-stepwise-coding-workflow-ir.ts  |  2 +-
 6 files changed, 30 insertions(+), 3 deletions(-)
 create mode 100644 .changeset/fn-7599-planning-column-rename.md

diff --git a/.changeset/fn-7599-planning-column-rename.md b/.changeset/fn-7599-planning-column-rename.md
new file mode 100644
index 0000000000..59cac03411
--- /dev/null
+++ b/.changeset/fn-7599-planning-column-rename.md
@@ -0,0 +1,7 @@
+---
+"@runfusion/fusion": patch
+---
+
+summary: Default workflow boards now label the intake column "Planning" instead of "Triage".
+category: fix
+dev: Renamed the `name` of the `id: "triage"` intake column to "Planning" in builtin-coding, builtin-stepwise-coding, and builtin-pr workflow IRs (column id unchanged; linear built-ins inherit via canonicalBuiltinWorkflowColumns). COLUMN_LABELS.triage was already "Planning".
diff --git a/packages/core/src/__tests__/builtin-coding-workflow-ir.test.ts b/packages/core/src/__tests__/builtin-coding-workflow-ir.test.ts
index 5aacff6035..cfd6b91ecb 100644
--- a/packages/core/src/__tests__/builtin-coding-workflow-ir.test.ts
+++ b/packages/core/src/__tests__/builtin-coding-workflow-ir.test.ts
@@ -107,6 +107,13 @@ describe("builtin coding workflow ir", () => {
     expect(ids).toEqual(["triage", "todo", "in-progress", "in-review", "done", "archived"]);
   });
 
+  // FNXC:Workflows 2026-07-05-00:00: FN-7599 — the intake column displays as "Planning" while its id stays "triage" for lifecycle/DB/type stability.
+  it("labels the intake column 'Planning' while keeping the 'triage' id (FN-7599)", () => {
+    if (BUILTIN_CODING_WORKFLOW_IR.version !== "v2") throw new Error("expected v2");
+    const byId = new Map(BUILTIN_CODING_WORKFLOW_IR.columns.map((c) => [c.id, c]));
+    expect(byId.get("triage")).toEqual({ id: "triage", name: "Planning", traits: [{ trait: "intake" }] });
+  });
+
   it("maps default-workflow traits to columns verbatim (R12)", () => {
     if (BUILTIN_CODING_WORKFLOW_IR.version !== "v2") throw new Error("expected v2");
     const byId = new Map(BUILTIN_CODING_WORKFLOW_IR.columns.map((c) => [c.id, c]));
diff --git a/packages/core/src/__tests__/builtin-workflows.test.ts b/packages/core/src/__tests__/builtin-workflows.test.ts
index 0fbcff0039..cdbf473a0b 100644
--- a/packages/core/src/__tests__/builtin-workflows.test.ts
+++ b/packages/core/src/__tests__/builtin-workflows.test.ts
@@ -10,6 +10,7 @@ import {
 } from "../builtin-workflows.js";
 import { BUILTIN_CODING_WORKFLOW_IR } from "../builtin-coding-workflow-ir.js";
 import { BUILTIN_STEPWISE_CODING_WORKFLOW_IR } from "../builtin-stepwise-coding-workflow-ir.js";
+import { BUILTIN_PR_WORKFLOW_IR } from "../builtin-pr-workflow-ir.js";
 import { BROWSER_VERIFICATION_GROUP_ID, BROWSER_VERIFICATION_STEP_NODE_ID } from "../builtin-browser-verification-group.js";
 import { CODE_REVIEW_STEP_NODE_ID } from "../builtin-code-review-group.js";
 import { PLAN_REVIEW_GROUP_ID, PLAN_REVIEW_STEP_NODE_ID } from "../builtin-plan-review-group.js";
@@ -417,6 +418,17 @@ describe("built-in workflows", () => {
     ]);
   });
 
+  // FNXC:Workflows 2026-07-05-00:00: FN-7599 — hand-authored default workflows (stepwise-coding, pr-workflow)
+  // must also label the intake column "Planning" while keeping the "triage" id, matching builtin-coding.
+  it("hand-authored default workflows label the intake column 'Planning' (FN-7599)", () => {
+    for (const ir of [BUILTIN_STEPWISE_CODING_WORKFLOW_IR, BUILTIN_PR_WORKFLOW_IR]) {
+      expect(ir.version).toBe("v2");
+      if (ir.version !== "v2") throw new Error("expected v2");
+      const triageColumn = ir.columns.find((column) => column.id === "triage");
+      expect(triageColumn).toEqual({ id: "triage", name: "Planning", traits: [{ trait: "intake" }] });
+    }
+  });
+
   it("builtin:coding catalog entry is backed by the stepwise final-review IR", () => {
     const coding = getBuiltinWorkflow("builtin:coding");
     expect(coding).toBeDefined();
diff --git a/packages/core/src/builtin-coding-workflow-ir.ts b/packages/core/src/builtin-coding-workflow-ir.ts
index 19c1ab10f1..0e6f678a7d 100644
--- a/packages/core/src/builtin-coding-workflow-ir.ts
+++ b/packages/core/src/builtin-coding-workflow-ir.ts
@@ -45,7 +45,8 @@ const RAW_BUILTIN_CODING_WORKFLOW_IR: WorkflowIr = {
   version: "v2",
   name: "builtin-coding-workflow",
   columns: [
-    { id: "triage", name: "Triage", traits: [{ trait: "intake" }] },
+    // FNXC:Workflows 2026-07-05-00:00: Default-workflow intake column now displays as "Planning" while keeping the `triage` id for lifecycle/DB/type stability (FN-7599).
+    { id: "triage", name: "Planning", traits: [{ trait: "intake" }] },
     {
       id: "todo",
       name: "Todo",
diff --git a/packages/core/src/builtin-pr-workflow-ir.ts b/packages/core/src/builtin-pr-workflow-ir.ts
index 136ac7b422..71552b1012 100644
--- a/packages/core/src/builtin-pr-workflow-ir.ts
+++ b/packages/core/src/builtin-pr-workflow-ir.ts
@@ -60,7 +60,7 @@ const RAW_BUILTIN_PR_WORKFLOW_IR: WorkflowIr = {
   version: "v2",
   name: "builtin-pr",
   columns: [
-    { id: "triage", name: "Triage", traits: [{ trait: "intake" }] },
+    { id: "triage", name: "Planning", traits: [{ trait: "intake" }] },
     {
       id: "in-progress",
       name: "In progress",
diff --git a/packages/core/src/builtin-stepwise-coding-workflow-ir.ts b/packages/core/src/builtin-stepwise-coding-workflow-ir.ts
index 730d17eba8..2f93c37090 100644
--- a/packages/core/src/builtin-stepwise-coding-workflow-ir.ts
+++ b/packages/core/src/builtin-stepwise-coding-workflow-ir.ts
@@ -60,7 +60,7 @@ const RAW_BUILTIN_STEPWISE_CODING_WORKFLOW_IR: WorkflowIr = {
   version: "v2",
   name: "builtin-stepwise-coding",
   columns: [
-    { id: "triage", name: "Triage", traits: [{ trait: "intake" }] },
+    { id: "triage", name: "Planning", traits: [{ trait: "intake" }] },
     {
       id: "todo",
       name: "Todo",

From 5b193d2d08ed9719e5435c176d2be0b3a4b7ee2e Mon Sep 17 00:00:00 2001
From: gsxdsm <gsxdsm@users.noreply.github.com>
Date: Sun, 5 Jul 2026 17:03:56 -0700
Subject: [PATCH 52/65] FN-7600: fix Nudge control stuck on
 periodic-observation copy when overseer is active

Attach the transient plannerOverseerState snapshot to the single-task detail route so the Nudge control reflects live overseer observation instead of always showing the periodic-observation message.

- GET /api/tasks/:id now best-effort attaches plannerOverseerState (mirrors the list route), never throwing on enrichment failure.
- TaskDetailModal reads overseerSnapshot from workingTask (merged full-detail object) instead of the raw task prop, so detail refetches via fetchTaskDetail (dependency chips, Documents view, logs, post-open refetch) no longer drop the snapshot.
- Added regression tests for the detail-route enrichment and the modal's Nudge-availability behavior.
- Added a patch changeset documenting the fix.

Files changed:
 .changeset/fn-7600-oversight-nudge-detail-snapshot.md             |   7 ++
 packages/dashboard/app/components/TaskDetailModal.tsx             |  14 ++-
 .../TaskDetailModal.oversight-controls.test.tsx                   | 131 +++++++++++++++++++++
 .../__tests__/tasks-planner-overseer-state.test.ts                |  95 +++++++++++++++
 packages/dashboard/src/routes/register-task-workflow-routes.ts    |  25 +++-
 5 files changed, 269 insertions(+), 3 deletions(-)

Fusion-Task-Id: FN-7600

Fusion-Task-Lineage: 500614d0-091a-461c-8e7b-329a7b791502

Co-authored-by: Fusion (runfusion.ai) <noreply@runfusion.ai>
---
 ...fn-7600-oversight-nudge-detail-snapshot.md |   7 +
 .../app/components/TaskDetailModal.tsx        |  14 +-
 ...askDetailModal.oversight-controls.test.tsx | 131 ++++++++++++++++++
 .../tasks-planner-overseer-state.test.ts      |  95 +++++++++++++
 .../routes/register-task-workflow-routes.ts   |  25 +++-
 5 files changed, 269 insertions(+), 3 deletions(-)
 create mode 100644 .changeset/fn-7600-oversight-nudge-detail-snapshot.md

diff --git a/.changeset/fn-7600-oversight-nudge-detail-snapshot.md b/.changeset/fn-7600-oversight-nudge-detail-snapshot.md
new file mode 100644
index 0000000000..2690189613
--- /dev/null
+++ b/.changeset/fn-7600-oversight-nudge-detail-snapshot.md
@@ -0,0 +1,7 @@
+---
+"@runfusion/fusion": patch
+---
+
+summary: Fix the task-detail Nudge control staying disabled when the overseer is actively watching.
+category: fix
+dev: GET /api/tasks/:id now attaches the transient plannerOverseerState snapshot (mirrors the list route); TaskDetailModal reads the snapshot from workingTask so detail refetches no longer drop it.
diff --git a/packages/dashboard/app/components/TaskDetailModal.tsx b/packages/dashboard/app/components/TaskDetailModal.tsx
index 010c127e3b..8f2b73d279 100644
--- a/packages/dashboard/app/components/TaskDetailModal.tsx
+++ b/packages/dashboard/app/components/TaskDetailModal.tsx
@@ -3183,7 +3183,19 @@ export function TaskDetailContent({
   copy-only, selected via the already-computed `overseerHumanControlSuppressed`
   / `overseerActive` booleans below.
   */
-  const overseerSnapshot = task.plannerOverseerState ?? null;
+  /*
+  FNXC:PlannerOversight 2026-07-05-00:00:
+  FN-7600: this used to read `task.plannerOverseerState` — the transient
+  snapshot enrichment from `GET /api/tasks` (list) — but the modal is
+  frequently opened via `fetchTaskDetail` (dependency chips, Documents view,
+  logs, or the post-open detail refetch) where the parent `task` prop never
+  carries the snapshot, so `overseerActive`/`canNudgeOverseer` were almost
+  always false and Nudge showed the periodic-observation copy even while the
+  overseer was actively watching. `GET /api/tasks/:id` now attaches the same
+  snapshot (mirrors the list route), so read it from `workingTask` — the
+  full-detail-backed merged object — instead of the raw prop.
+  */
+  const overseerSnapshot = workingTask.plannerOverseerState ?? null;
   const overseerActive = Boolean(overseerSnapshot);
   const isDoneOrArchivedColumn = task.column === "done" || task.column === "archived";
   const isOverseerHumanReviewTerminal = task.column === "in-review" && !effectiveAutoMerge;
diff --git a/packages/dashboard/app/components/__tests__/TaskDetailModal.oversight-controls.test.tsx b/packages/dashboard/app/components/__tests__/TaskDetailModal.oversight-controls.test.tsx
index 768ed722a7..18bf22f1ad 100644
--- a/packages/dashboard/app/components/__tests__/TaskDetailModal.oversight-controls.test.tsx
+++ b/packages/dashboard/app/components/__tests__/TaskDetailModal.oversight-controls.test.tsx
@@ -407,6 +407,137 @@ describe("TaskDetailModal oversight controls", () => {
   });
 });
 
+/*
+FNXC:PlannerOversight 2026-07-05-00:00:
+FN-7600 regression coverage: the modal previously read `overseerSnapshot` from
+the raw `task` prop, which loses the snapshot whenever the modal is opened via
+`fetchTaskDetail` (dependency chips, Documents view, logs) because those call
+sites pass a slim `Task` (no `prompt` key) that never carries
+`plannerOverseerState` — only the full-detail fetch response does. These
+tests reproduce that exact path: a slim task prop with NO snapshot, plus a
+mocked `fetchTaskDetail` resolving a full TaskDetail WITH an active snapshot,
+and assert Nudge enables (helper absent) once the fetched detail lands — at
+both the desktop inline site and the mobile overflow-menu site.
+*/
+describe("TaskDetailModal oversight controls — snapshot delivered via fetched full detail (FN-7600)", () => {
+  const originalInnerWidth = window.innerWidth;
+
+  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 });
+  });
+
+  afterEach(() => {
+    Object.defineProperty(window, "innerWidth", { value: originalInnerWidth, configurable: true });
+  });
+
+  function makeSlimTaskWithoutSnapshot(overrides: Record<string, unknown> = {}) {
+    // Omit `prompt`/`log`/`steps` so the modal treats this as a slim `Task`
+    // (not a `TaskDetail`) and triggers the `fetchTaskDetail` fetch-on-open
+    // path instead of using the prop directly as `fullDetail`.
+    const { prompt: _prompt, log: _log, steps: _steps, plannerOverseerState: _snap, ...task } = makeTask({
+      id: "FN-220",
+      column: "in-progress",
+      plannerOversightLevel: "autonomous",
+      ...overrides,
+    });
+    return task;
+  }
+
+  it("desktop: enables Nudge and hides the disabled-reason helper once the fetched full detail carries an active snapshot", async () => {
+    const api = await import("../../api");
+    vi.mocked(api.fetchTaskDetail).mockResolvedValueOnce(makeTask({
+      id: "FN-220",
+      column: "in-progress",
+      plannerOversightLevel: "autonomous",
+      plannerOverseerState: activeSnapshot,
+    }));
+
+    render(
+      <TaskDetailModal
+        task={makeSlimTaskWithoutSnapshot() as any}
+        onClose={noop}
+        onMoveTask={noopMove}
+        onDeleteTask={noopDelete}
+        onMergeTask={noopMerge}
+        onOpenDetail={noopOpenDetail}
+        addToast={noop}
+      />,
+    );
+
+    const nudgeBtn = await screen.findByTestId("detail-overseer-nudge");
+    await waitFor(() => {
+      expect(nudgeBtn).not.toBeDisabled();
+    });
+    expect(screen.queryByTestId("detail-overseer-nudge-disabled-reason")).not.toBeInTheDocument();
+  });
+
+  it("desktop: still shows the periodic-observation copy while the fetched full detail carries no snapshot", async () => {
+    const api = await import("../../api");
+    vi.mocked(api.fetchTaskDetail).mockResolvedValueOnce(makeTask({
+      id: "FN-221",
+      column: "in-progress",
+      plannerOversightLevel: "autonomous",
+    }));
+
+    render(
+      <TaskDetailModal
+        task={makeSlimTaskWithoutSnapshot({ id: "FN-221" }) as any}
+        onClose={noop}
+        onMoveTask={noopMove}
+        onDeleteTask={noopDelete}
+        onMergeTask={noopMerge}
+        onOpenDetail={noopOpenDetail}
+        addToast={noop}
+      />,
+    );
+
+    const nudgeBtn = await screen.findByTestId("detail-overseer-nudge");
+    expect(nudgeBtn).toBeDisabled();
+    const reason = await screen.findByTestId("detail-overseer-nudge-disabled-reason");
+    expect(reason).toHaveTextContent("Nudge becomes available once the overseer is observing this task's current stage");
+  });
+
+  it("mobile: enables Nudge and hides the disabled-reason helper behind the overflow menu once the fetched full detail carries an active snapshot", async () => {
+    Object.defineProperty(window, "innerWidth", { value: 375, configurable: true });
+
+    const api = await import("../../api");
+    vi.mocked(api.fetchTaskDetail).mockResolvedValueOnce(makeTask({
+      id: "FN-222",
+      column: "in-progress",
+      plannerOversightLevel: "autonomous",
+      plannerOverseerState: activeSnapshot,
+    }));
+
+    render(
+      <TaskDetailModal
+        task={makeSlimTaskWithoutSnapshot({ id: "FN-222" }) as any}
+        onClose={noop}
+        onMoveTask={noopMove}
+        onDeleteTask={noopDelete}
+        onMergeTask={noopMerge}
+        onOpenDetail={noopOpenDetail}
+        addToast={noop}
+      />,
+    );
+
+    const trigger = await screen.findByTestId("detail-oversight-menu-trigger");
+    fireEvent.click(trigger);
+
+    const nudgeBtn = await screen.findByTestId("detail-overseer-nudge");
+    await waitFor(() => {
+      expect(nudgeBtn).not.toBeDisabled();
+    });
+    expect(screen.queryByTestId("detail-overseer-nudge-disabled-reason")).not.toBeInTheDocument();
+  });
+});
+
 /*
  * FNXC:PlannerOversight 2026-07-04-20:30 (FN-7558):
  * FN-7521's original mobile suite asserted the oversight quick-controls
diff --git a/packages/dashboard/src/routes/__tests__/tasks-planner-overseer-state.test.ts b/packages/dashboard/src/routes/__tests__/tasks-planner-overseer-state.test.ts
index f401b54d33..468a590fca 100644
--- a/packages/dashboard/src/routes/__tests__/tasks-planner-overseer-state.test.ts
+++ b/packages/dashboard/src/routes/__tests__/tasks-planner-overseer-state.test.ts
@@ -112,3 +112,98 @@ describe("GET /tasks — plannerOverseerState enrichment", () => {
     expect(found && "plannerOverseerState" in found).toBe(false);
   });
 });
+
+// FN-7600: GET /tasks/:id (detail route) must attach the same transient
+// `plannerOverseerState` snapshot as the list route above — the Task Detail
+// modal's Overseer/Nudge controls read the snapshot from the full-detail
+// payload, not the list payload, so the detail route previously never
+// carried it and Nudge always showed the periodic-observation disabled copy.
+describe("GET /tasks/:id — plannerOverseerState enrichment", () => {
+  let store: TaskStore;
+  let rootDir: string;
+  let globalDir: string;
+
+  beforeEach(async () => {
+    rootDir = mkdtempSync(join(tmpdir(), "planner-overseer-state-detail-root-"));
+    globalDir = mkdtempSync(join(tmpdir(), "planner-overseer-state-detail-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;
+  }
+
+  it("attaches plannerOverseerState when the engine snapshot accessor returns a 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,
+    };
+
+    const engineStub: Partial<ProjectEngine> = {
+      getTaskStore: () => store,
+      getPlannerOverseerRuntimeSnapshot: (taskId: string) => (taskId === task.id ? snapshot : null),
+    };
+
+    const app = buildApp(engineStub);
+    const res = await REQUEST(app, "GET", `/api/tasks/${task.id}`);
+    expect(res.status).toBe(200);
+    expect((res.body as Record<string, unknown>).plannerOverseerState).toEqual(snapshot);
+  });
+
+  it("omits plannerOverseerState entirely (no key) when the accessor returns null", async () => {
+    const task = await store.createTask({ description: "idle task" });
+
+    const engineStub: Partial<ProjectEngine> = {
+      getTaskStore: () => store,
+      getPlannerOverseerRuntimeSnapshot: () => null,
+    };
+
+    const app = buildApp(engineStub);
+    const res = await REQUEST(app, "GET", `/api/tasks/${task.id}`);
+    expect(res.status).toBe(200);
+    expect("plannerOverseerState" in (res.body as Record<string, unknown>)).toBe(false);
+  });
+
+  it("returns 200 with the un-enriched task when the accessor throws (detail load never fails)", async () => {
+    const task = await store.createTask({ description: "throwing task" });
+
+    const engineStub: Partial<ProjectEngine> = {
+      getTaskStore: () => store,
+      getPlannerOverseerRuntimeSnapshot: () => {
+        throw new Error("boom");
+      },
+    };
+
+    const app = buildApp(engineStub);
+    const res = await REQUEST(app, "GET", `/api/tasks/${task.id}`);
+    expect(res.status).toBe(200);
+    expect("plannerOverseerState" in (res.body as Record<string, unknown>)).toBe(false);
+  });
+
+  it("returns 200 with the un-enriched task when no engine is present at all", async () => {
+    const task = await store.createTask({ description: "no engine task" });
+
+    const app = buildApp(undefined);
+    const res = await REQUEST(app, "GET", `/api/tasks/${task.id}`);
+    expect(res.status).toBe(200);
+    expect("plannerOverseerState" in (res.body as Record<string, unknown>)).toBe(false);
+  });
+});
diff --git a/packages/dashboard/src/routes/register-task-workflow-routes.ts b/packages/dashboard/src/routes/register-task-workflow-routes.ts
index 6884cd5130..e4b93c4206 100644
--- a/packages/dashboard/src/routes/register-task-workflow-routes.ts
+++ b/packages/dashboard/src/routes/register-task-workflow-routes.ts
@@ -2933,11 +2933,32 @@ export function registerTaskWorkflowRoutes(ctx: ApiRoutesContext, deps: TaskWork
   // Get single task with prompt content
   router.get("/tasks/:id", async (req, res) => {
     try {
-      const { store: scopedStore } = await getProjectContext(req);
+      const { store: scopedStore, engine } = await getProjectContext(req);
       const task = await scopedStore.getTask(req.params.id, {
         activityLogLimit: TASK_DETAIL_ACTIVITY_LOG_LIMIT,
       });
-      res.json(trimTaskDetailActivityLog(task));
+      let enrichedTask = task;
+      // FNXC:PlannerOversight 2026-07-05-00:00:
+      // FN-7600: the Task Detail modal's Overseer/Nudge controls read
+      // `plannerOverseerState` from the merged full-detail object, but this
+      // detail route previously never attached it (only the list route did,
+      // per FN-7531 above) — so opening the modal via fetchTaskDetail
+      // (dependency chips, Documents view, logs, or the post-open detail
+      // refetch) always lost the snapshot and the Nudge button showed the
+      // periodic-observation disabled copy even when the overseer was
+      // actively watching. Mirror the list-route contract exactly: best-
+      // effort, never throws, and omits the key (not `null`) when the
+      // accessor returns no active observation.
+      try {
+        const plannerOverseerState = engine?.getPlannerOverseerRuntimeSnapshot(task.id);
+        if (plannerOverseerState) {
+          enrichedTask = { ...task, plannerOverseerState };
+        }
+      } catch {
+        // Planner-overseer-state enrichment is best-effort and must never
+        // fail the task-detail load — fall through with the un-enriched task.
+      }
+      res.json(trimTaskDetailActivityLog(enrichedTask));
     } catch (err: unknown) {
       if (err instanceof ApiError) {
         throw err;

From 2025f9d56d04cf63f6f7441ca8971ae1b2690bd2 Mon Sep 17 00:00:00 2001
From: gsxdsm <gsxdsm@users.noreply.github.com>
Date: Sun, 5 Jul 2026 17:13:36 -0700
Subject: [PATCH 53/65] chore(release): v0.56.0

Version bump via changesets.
---
 .../FN-7491-triage-splitting-setting.md       |   7 -
 .../FN-7492-task-card-plan-review-progress.md |   7 -
 .changeset/FN-7541-remove-chat-eye-icon.md    |   7 -
 .../FN-7546-oversight-controls-clarity.md     |   7 -
 ...unify-task-detail-quick-control-styling.md |   7 -
 .changeset/activity-menu-ios.md               |   7 -
 ...x-anthropic-subscription-fragment-login.md |   7 -
 ...ropic-subscription-relogin-after-logout.md |   7 -
 ...tom-executor-kills-live-ephemeral-tasks.md |   7 -
 .../fix-windows-terminal-worktrunk-popup.md   |   7 -
 .../fn-7468-onboarding-quick-providers.md     |   7 -
 ...n-7469-select-created-project-directory.md |   7 -
 .changeset/fn-7470-git-onboarding.md          |   7 -
 .changeset/fn-7471-desktop-update-version.md  |   7 -
 .../fn-7472-windows-desktop-close-quits.md    |   7 -
 ...fn-7473-desktop-anthropic-oauth-browser.md |   7 -
 .../fn-7474-github-onboarding-actions.md      |   7 -
 .changeset/fn-7475-github-setup-warning.md    |   7 -
 .changeset/fn-7476-desktop-engine-banner.md   |   7 -
 .../fn-7477-connection-manager-clarity.md     |   7 -
 .../fn-7478-local-server-switch-option.md     |   7 -
 .changeset/fn-7479-right-dock-task-popup.md   |   7 -
 .changeset/fn-7482-code-review-remediation.md |   7 -
 .../fn-7486-merge-recovery-noop-ownership.md  |   7 -
 .changeset/fn-7488-source-free-completion.md  |   7 -
 .changeset/fn-7490-push-to-remote-setting.md  |   7 -
 .changeset/fn-7493-task-popup-layer.md        |   7 -
 .changeset/fn-7494-keyboard-shortcuts.md      |   7 -
 .changeset/fn-7495-settings-search.md         |   7 -
 .../fn-7497-chat-first-event-timeout.md       |   7 -
 .changeset/fn-7498-original-task-prompt.md    |   7 -
 .../fn-7499-before-after-transformation.md    |   7 -
 .changeset/fn-7500-terminal-shortcuts.md      |   7 -
 .changeset/fn-7502-terminal-below-layout.md   |   7 -
 .changeset/fn-7503-agent-log-timing.md        |   7 -
 .../fn-7504-mobile-chat-composer-keyboard.md  |   7 -
 .../fn-7505-settings-default-descriptions.md  |   7 -
 .changeset/fn-7506-settings-reset.md          |   7 -
 ...fn-7508-planner-oversight-level-setting.md |   7 -
 ...509-per-task-planner-oversight-override.md |   7 -
 .changeset/fn-7510-oversight-default.md       |   7 -
 .../fn-7511-planner-overseer-monitoring.md    |   7 -
 .../fn-7512-planner-bounded-recovery.md       |   7 -
 .../fn-7513-planner-confirmation-gate.md      |   7 -
 .../fn-7514-overseer-human-control-guard.md   |   7 -
 ...-7515-planner-oversight-config-exposure.md |   7 -
 ...n-7518-oversight-notification-verbosity.md |   7 -
 .../fn-7519-planner-intervention-timeline.md  |   7 -
 .changeset/fn-7520-planner-overseer-events.md |   7 -
 .changeset/fn-7523-task-revert.md             |   7 -
 .changeset/fn-7524-ai-undo-revert.md          |   7 -
 .changeset/fn-7525-revert-card-affordance.md  |   7 -
 .changeset/fn-7526-plan-auto-approve.md       |   7 -
 ...n-7527-desktop-switch-server-navigation.md |   7 -
 .../fn-7528-task-performance-capture.md       |   7 -
 ...fn-7531-planner-overseer-state-exposure.md |   7 -
 .changeset/fn-7532-branch-group-completion.md |   7 -
 .../fn-7534-branch-group-archived-member.md   |   7 -
 .../fn-7535-global-gitlab-setting-save.md     |   7 -
 .../fn-7536-activity-dropdown-mobile.md       |   7 -
 .../fn-7537-backup-automation-manual-run.md   |   7 -
 .changeset/fn-7539-oversight-badge-default.md |   7 -
 .../fn-7542-remove-overseer-state-badge.md    |   7 -
 ...7543-original-prompt-markdown-collapsed.md |   7 -
 ...44-artifact-cross-instance-live-refresh.md |   7 -
 .changeset/fn-7547-workspace-task-revert.md   |   7 -
 .../fn-7548-per-sha-revert-granularity.md     |   7 -
 .../fn-7550-terminal-shortcut-scroll.md       |   7 -
 .../fn-7551-overseer-timeline-wiring.md       |   7 -
 ...552-mobile-authentication-global-prefix.md |   7 -
 .../fn-7553-keyboard-shortcuts-section.md     |   7 -
 .changeset/fn-7554-pr-based-revert.md         |   7 -
 .changeset/fn-7556-ai-undo-workflow.md        |   7 -
 .../fn-7557-plan-auto-approve-default.md      |   7 -
 .../fn-7559-approval-gate-disambiguation.md   |   7 -
 .changeset/fn-7560-mobile-terminal-footer.md  |   7 -
 ...-release-gate-disclaimer-false-positive.md |   7 -
 .changeset/fn-7561-mobile-terminal-spacing.md |   7 -
 .changeset/fn-7561-plan-review-replan-loop.md |   7 -
 .../fn-7563-overseer-badge-explanation.md     |   7 -
 ...pprove-plan-release-authorization-guard.md |   7 -
 .../fn-7565-mobile-terminal-close-corner.md   |   7 -
 .changeset/fn-7567-mobile-terminal-spacing.md |   7 -
 .changeset/fn-7568-fn-cli-release-asset.md    |   7 -
 .../fn-7569-plan-approval-idempotent.md       |   7 -
 ...intervention-timeline-activity-dropdown.md |   7 -
 .../fn-7574-oauth-expiry-detection-refresh.md |   7 -
 .changeset/fn-7575-release-version-comment.md |   7 -
 ...apper-subscription-getapikey-delegation.md |   7 -
 .changeset/fn-7577-workspace-pr-revert.md     |   7 -
 .../fn-7578-ai-undo-workflow-setting-ui.md    |   7 -
 .../fn-7579-ask-user-exit-gate-nodes.md       |   7 -
 .../fn-7579-tracking-dedup-stale-issue.md     |   7 -
 .../fn-7582-oversight-guideline-copy.md       |   7 -
 .changeset/fn-7584-brainstorming-builtin.md   |   7 -
 .changeset/fn-7591-coding-ideas-intake.md     |   7 -
 .changeset/fn-7591-intake-card-disappears.md  |   7 -
 .changeset/fn-7593-before-after-top.md        |   7 -
 ...597-priority-dropdown-matches-oversight.md |   7 -
 .changeset/fn-7599-planning-column-rename.md  |   7 -
 ...fn-7600-oversight-nudge-detail-snapshot.md |   7 -
 .changeset/fn-coding-ideas-workflow.md        |   7 -
 ...e-branch-strategy-and-parked-validation.md |   7 -
 ...anner-overseer-no-recover-healthy-tasks.md |   7 -
 CHANGELOG.md                                  | 417 ++++++++++++++++--
 package.json                                  |   2 +-
 packages/cli-alias/CHANGELOG.md               | 110 +++++
 packages/cli-alias/package.json               |   2 +-
 packages/cli/CHANGELOG.md                     | 320 ++++++++++++++
 packages/cli/package.json                     |   2 +-
 packages/core/CHANGELOG.md                    |   2 +
 packages/core/package.json                    |   2 +-
 packages/dashboard/CHANGELOG.md               |  17 +
 packages/dashboard/package.json               |   2 +-
 packages/desktop/CHANGELOG.md                 |   8 +
 packages/desktop/package.json                 |   2 +-
 packages/droid-cli/CHANGELOG.md               |   6 +
 packages/droid-cli/package.json               |   2 +-
 packages/engine/CHANGELOG.md                  |   7 +
 packages/engine/package.json                  |   2 +-
 packages/i18n/CHANGELOG.md                    |   6 +
 packages/i18n/package.json                    |   2 +-
 packages/mobile/CHANGELOG.md                  |   2 +
 packages/mobile/package.json                  |   2 +-
 packages/pi-claude-cli/CHANGELOG.md           |   2 +
 packages/pi-claude-cli/package.json           |   2 +-
 packages/plugin-sdk/CHANGELOG.md              |   6 +
 packages/plugin-sdk/package.json              |   2 +-
 .../fusion-plugin-auto-label/CHANGELOG.md     |   6 +
 .../fusion-plugin-auto-label/package.json     |   2 +-
 .../fusion-plugin-ci-status/CHANGELOG.md      |   6 +
 .../fusion-plugin-ci-status/package.json      |   2 +-
 .../fusion-plugin-notification/CHANGELOG.md   |   6 +
 .../fusion-plugin-notification/package.json   |   2 +-
 .../fusion-plugin-settings-demo/CHANGELOG.md  |   6 +
 .../fusion-plugin-settings-demo/package.json  |   2 +-
 .../fusion-plugin-acp-runtime/CHANGELOG.md    |   7 +
 .../fusion-plugin-acp-runtime/package.json    |   2 +-
 .../fusion-plugin-agent-browser/CHANGELOG.md  |   6 +
 .../fusion-plugin-agent-browser/package.json  |   2 +-
 .../CHANGELOG.md                              |   7 +
 .../package.json                              |   2 +-
 .../CHANGELOG.md                              |   7 +
 .../package.json                              |   2 +-
 .../fusion-plugin-cursor-runtime/CHANGELOG.md |   6 +
 .../fusion-plugin-cursor-runtime/package.json |   2 +-
 .../CHANGELOG.md                              |   7 +
 .../package.json                              |   2 +-
 .../fusion-plugin-droid-runtime/CHANGELOG.md  |   6 +
 .../fusion-plugin-droid-runtime/package.json  |   2 +-
 .../CHANGELOG.md                              |   7 +
 .../package.json                              |   2 +-
 .../fusion-plugin-hermes-runtime/CHANGELOG.md |   6 +
 .../fusion-plugin-hermes-runtime/package.json |   2 +-
 .../fusion-plugin-linear-import/CHANGELOG.md  |   7 +
 .../fusion-plugin-linear-import/package.json  |   2 +-
 .../CHANGELOG.md                              |   6 +
 .../package.json                              |   2 +-
 .../CHANGELOG.md                              |   6 +
 .../package.json                              |   2 +-
 plugins/fusion-plugin-reports/CHANGELOG.md    |   8 +
 plugins/fusion-plugin-reports/package.json    |   2 +-
 plugins/fusion-plugin-roadmap/CHANGELOG.md    |   7 +
 plugins/fusion-plugin-roadmap/package.json    |   2 +-
 .../fusion-plugin-whatsapp-chat/CHANGELOG.md  |   6 +
 .../fusion-plugin-whatsapp-chat/package.json  |   2 +-
 166 files changed, 1009 insertions(+), 807 deletions(-)
 delete mode 100644 .changeset/FN-7491-triage-splitting-setting.md
 delete mode 100644 .changeset/FN-7492-task-card-plan-review-progress.md
 delete mode 100644 .changeset/FN-7541-remove-chat-eye-icon.md
 delete mode 100644 .changeset/FN-7546-oversight-controls-clarity.md
 delete mode 100644 .changeset/FN-7585-unify-task-detail-quick-control-styling.md
 delete mode 100644 .changeset/activity-menu-ios.md
 delete mode 100644 .changeset/fix-anthropic-subscription-fragment-login.md
 delete mode 100644 .changeset/fix-anthropic-subscription-relogin-after-logout.md
 delete mode 100644 .changeset/fix-phantom-executor-kills-live-ephemeral-tasks.md
 delete mode 100644 .changeset/fix-windows-terminal-worktrunk-popup.md
 delete mode 100644 .changeset/fn-7468-onboarding-quick-providers.md
 delete mode 100644 .changeset/fn-7469-select-created-project-directory.md
 delete mode 100644 .changeset/fn-7470-git-onboarding.md
 delete mode 100644 .changeset/fn-7471-desktop-update-version.md
 delete mode 100644 .changeset/fn-7472-windows-desktop-close-quits.md
 delete mode 100644 .changeset/fn-7473-desktop-anthropic-oauth-browser.md
 delete mode 100644 .changeset/fn-7474-github-onboarding-actions.md
 delete mode 100644 .changeset/fn-7475-github-setup-warning.md
 delete mode 100644 .changeset/fn-7476-desktop-engine-banner.md
 delete mode 100644 .changeset/fn-7477-connection-manager-clarity.md
 delete mode 100644 .changeset/fn-7478-local-server-switch-option.md
 delete mode 100644 .changeset/fn-7479-right-dock-task-popup.md
 delete mode 100644 .changeset/fn-7482-code-review-remediation.md
 delete mode 100644 .changeset/fn-7486-merge-recovery-noop-ownership.md
 delete mode 100644 .changeset/fn-7488-source-free-completion.md
 delete mode 100644 .changeset/fn-7490-push-to-remote-setting.md
 delete mode 100644 .changeset/fn-7493-task-popup-layer.md
 delete mode 100644 .changeset/fn-7494-keyboard-shortcuts.md
 delete mode 100644 .changeset/fn-7495-settings-search.md
 delete mode 100644 .changeset/fn-7497-chat-first-event-timeout.md
 delete mode 100644 .changeset/fn-7498-original-task-prompt.md
 delete mode 100644 .changeset/fn-7499-before-after-transformation.md
 delete mode 100644 .changeset/fn-7500-terminal-shortcuts.md
 delete mode 100644 .changeset/fn-7502-terminal-below-layout.md
 delete mode 100644 .changeset/fn-7503-agent-log-timing.md
 delete mode 100644 .changeset/fn-7504-mobile-chat-composer-keyboard.md
 delete mode 100644 .changeset/fn-7505-settings-default-descriptions.md
 delete mode 100644 .changeset/fn-7506-settings-reset.md
 delete mode 100644 .changeset/fn-7508-planner-oversight-level-setting.md
 delete mode 100644 .changeset/fn-7509-per-task-planner-oversight-override.md
 delete mode 100644 .changeset/fn-7510-oversight-default.md
 delete mode 100644 .changeset/fn-7511-planner-overseer-monitoring.md
 delete mode 100644 .changeset/fn-7512-planner-bounded-recovery.md
 delete mode 100644 .changeset/fn-7513-planner-confirmation-gate.md
 delete mode 100644 .changeset/fn-7514-overseer-human-control-guard.md
 delete mode 100644 .changeset/fn-7515-planner-oversight-config-exposure.md
 delete mode 100644 .changeset/fn-7518-oversight-notification-verbosity.md
 delete mode 100644 .changeset/fn-7519-planner-intervention-timeline.md
 delete mode 100644 .changeset/fn-7520-planner-overseer-events.md
 delete mode 100644 .changeset/fn-7523-task-revert.md
 delete mode 100644 .changeset/fn-7524-ai-undo-revert.md
 delete mode 100644 .changeset/fn-7525-revert-card-affordance.md
 delete mode 100644 .changeset/fn-7526-plan-auto-approve.md
 delete mode 100644 .changeset/fn-7527-desktop-switch-server-navigation.md
 delete mode 100644 .changeset/fn-7528-task-performance-capture.md
 delete mode 100644 .changeset/fn-7531-planner-overseer-state-exposure.md
 delete mode 100644 .changeset/fn-7532-branch-group-completion.md
 delete mode 100644 .changeset/fn-7534-branch-group-archived-member.md
 delete mode 100644 .changeset/fn-7535-global-gitlab-setting-save.md
 delete mode 100644 .changeset/fn-7536-activity-dropdown-mobile.md
 delete mode 100644 .changeset/fn-7537-backup-automation-manual-run.md
 delete mode 100644 .changeset/fn-7539-oversight-badge-default.md
 delete mode 100644 .changeset/fn-7542-remove-overseer-state-badge.md
 delete mode 100644 .changeset/fn-7543-original-prompt-markdown-collapsed.md
 delete mode 100644 .changeset/fn-7544-artifact-cross-instance-live-refresh.md
 delete mode 100644 .changeset/fn-7547-workspace-task-revert.md
 delete mode 100644 .changeset/fn-7548-per-sha-revert-granularity.md
 delete mode 100644 .changeset/fn-7550-terminal-shortcut-scroll.md
 delete mode 100644 .changeset/fn-7551-overseer-timeline-wiring.md
 delete mode 100644 .changeset/fn-7552-mobile-authentication-global-prefix.md
 delete mode 100644 .changeset/fn-7553-keyboard-shortcuts-section.md
 delete mode 100644 .changeset/fn-7554-pr-based-revert.md
 delete mode 100644 .changeset/fn-7556-ai-undo-workflow.md
 delete mode 100644 .changeset/fn-7557-plan-auto-approve-default.md
 delete mode 100644 .changeset/fn-7559-approval-gate-disambiguation.md
 delete mode 100644 .changeset/fn-7560-mobile-terminal-footer.md
 delete mode 100644 .changeset/fn-7560-release-gate-disclaimer-false-positive.md
 delete mode 100644 .changeset/fn-7561-mobile-terminal-spacing.md
 delete mode 100644 .changeset/fn-7561-plan-review-replan-loop.md
 delete mode 100644 .changeset/fn-7563-overseer-badge-explanation.md
 delete mode 100644 .changeset/fn-7564-approve-plan-release-authorization-guard.md
 delete mode 100644 .changeset/fn-7565-mobile-terminal-close-corner.md
 delete mode 100644 .changeset/fn-7567-mobile-terminal-spacing.md
 delete mode 100644 .changeset/fn-7568-fn-cli-release-asset.md
 delete mode 100644 .changeset/fn-7569-plan-approval-idempotent.md
 delete mode 100644 .changeset/fn-7571-intervention-timeline-activity-dropdown.md
 delete mode 100644 .changeset/fn-7574-oauth-expiry-detection-refresh.md
 delete mode 100644 .changeset/fn-7575-release-version-comment.md
 delete mode 100644 .changeset/fn-7576-cli-wrapper-subscription-getapikey-delegation.md
 delete mode 100644 .changeset/fn-7577-workspace-pr-revert.md
 delete mode 100644 .changeset/fn-7578-ai-undo-workflow-setting-ui.md
 delete mode 100644 .changeset/fn-7579-ask-user-exit-gate-nodes.md
 delete mode 100644 .changeset/fn-7579-tracking-dedup-stale-issue.md
 delete mode 100644 .changeset/fn-7582-oversight-guideline-copy.md
 delete mode 100644 .changeset/fn-7584-brainstorming-builtin.md
 delete mode 100644 .changeset/fn-7591-coding-ideas-intake.md
 delete mode 100644 .changeset/fn-7591-intake-card-disappears.md
 delete mode 100644 .changeset/fn-7593-before-after-top.md
 delete mode 100644 .changeset/fn-7597-priority-dropdown-matches-oversight.md
 delete mode 100644 .changeset/fn-7599-planning-column-rename.md
 delete mode 100644 .changeset/fn-7600-oversight-nudge-detail-snapshot.md
 delete mode 100644 .changeset/fn-coding-ideas-workflow.md
 delete mode 100644 .changeset/mission-triage-branch-strategy-and-parked-validation.md
 delete mode 100644 .changeset/planner-overseer-no-recover-healthy-tasks.md

diff --git a/.changeset/FN-7491-triage-splitting-setting.md b/.changeset/FN-7491-triage-splitting-setting.md
deleted file mode 100644
index a8a2494275..0000000000
--- a/.changeset/FN-7491-triage-splitting-setting.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": patch
----
-
-summary: Add a workflow setting to disable automatic large-task triage splitting.
-category: feature
-dev: Adds triageProactiveSubtaskSplittingEnabled while preserving explicit breakIntoSubtasks requests.
diff --git a/.changeset/FN-7492-task-card-plan-review-progress.md b/.changeset/FN-7492-task-card-plan-review-progress.md
deleted file mode 100644
index 9250f398c2..0000000000
--- a/.changeset/FN-7492-task-card-plan-review-progress.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": patch
----
-
-summary: Show active Plan Review progress on triage task cards.
-category: fix
-dev: TaskCard now renders the existing progress affordance for Triage only when unified progress has active workflow work.
diff --git a/.changeset/FN-7541-remove-chat-eye-icon.md b/.changeset/FN-7541-remove-chat-eye-icon.md
deleted file mode 100644
index abf2336a76..0000000000
--- a/.changeset/FN-7541-remove-chat-eye-icon.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": patch
----
-
-summary: Remove the eye icon markdown/plain toggle from chat; messages always render as Markdown.
-category: breaking
-dev: Removed ChatView `chat-thread-header-render-toggle` (desktop + mobile), `showAllAsPlain` state, and `chat.showRenderedMarkdown`/`chat.showPlainText` i18n keys (FN-7541).
diff --git a/.changeset/FN-7546-oversight-controls-clarity.md b/.changeset/FN-7546-oversight-controls-clarity.md
deleted file mode 100644
index 632089357e..0000000000
--- a/.changeset/FN-7546-oversight-controls-clarity.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": patch
----
-
-summary: Clarify task-detail oversight Nudge/Explain controls: visible label, disabled reason, always-openable Explain panel.
-category: fix
-dev: TaskDetailModal now renders a `detail-oversight-controls-label` group label and `detail-overseer-nudge-disabled-reason` helper text (both gated by the existing oversight-cluster visibility condition); Explain no longer disables on `!canExplainOverseer` since it is read-only. Nudge's `canNudgeOverseer` gate and Stop's confirm dialog are unchanged.
diff --git a/.changeset/FN-7585-unify-task-detail-quick-control-styling.md b/.changeset/FN-7585-unify-task-detail-quick-control-styling.md
deleted file mode 100644
index b536ea7b2a..0000000000
--- a/.changeset/FN-7585-unify-task-detail-quick-control-styling.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": patch
----
-
-summary: Unify border, radius, and height of the task-detail Priority/Execution/Oversight controls.
-category: fix
-dev: Adds a shared --detail-control-border-radius token alongside --detail-priority-control-min-height so .detail-priority-chip, .detail-execution-mode-toggle, .detail-oversight-chip, and .detail-oversight-menu-trigger all resolve the same border-width/color/radius/height.
diff --git a/.changeset/activity-menu-ios.md b/.changeset/activity-menu-ios.md
deleted file mode 100644
index f4a8c962c7..0000000000
--- a/.changeset/activity-menu-ios.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": patch
----
-
-summary: Keep the task-detail Activity view menu open during mobile iOS taps.
-category: fix
-dev: Guards the Activity views dropdown against iOS visualViewport resize/scroll echoes during menu opening.
diff --git a/.changeset/fix-anthropic-subscription-fragment-login.md b/.changeset/fix-anthropic-subscription-fragment-login.md
deleted file mode 100644
index 85d2c35fc6..0000000000
--- a/.changeset/fix-anthropic-subscription-fragment-login.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": patch
----
-
-summary: Fix Anthropic subscription login when pasted callback URLs contain fragment OAuth parameters.
-category: fix
-dev: Normalizes pasted OAuth callback fragments before resolving dashboard manual-code login prompts.
diff --git a/.changeset/fix-anthropic-subscription-relogin-after-logout.md b/.changeset/fix-anthropic-subscription-relogin-after-logout.md
deleted file mode 100644
index e6c3bb56b3..0000000000
--- a/.changeset/fix-anthropic-subscription-relogin-after-logout.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": patch
----
-
-summary: Fix Claude/Anthropic subscription re-login showing "Login did not complete" after logging out.
-category: fix
-dev: Anthropic subscription OAuth is aliased across the legacy `anthropic` row (where interactive login persists the credential) and the `anthropic-subscription` id (where the settings card's in-memory logged-out suppression and status read are keyed). Re-login wrote only `anthropic`, so `loggedOutProviders` kept suppressing `anthropic-subscription` and the card reported failure despite a valid stored credential until process restart. auth-storage's proxy now clears the logged-out state on both aliases when either is re-authenticated (new `login` trap + hardened `set` trap via `clearReauthenticatedLogoutState`; raw api_key writes stay scoped to their own card). Also surfaces background OAuth login failures on `GET /auth/status` (`loginError`) + server logs so future paste-callback failures are diagnosable instead of a generic error.
diff --git a/.changeset/fix-phantom-executor-kills-live-ephemeral-tasks.md b/.changeset/fix-phantom-executor-kills-live-ephemeral-tasks.md
deleted file mode 100644
index 6c3bde0dc3..0000000000
--- a/.changeset/fix-phantom-executor-kills-live-ephemeral-tasks.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": patch
----
-
-summary: Stop self-healing from killing actively-running tasks after ~30 minutes.
-category: fix
-dev: FN-7566. isPhantomExecutorBinding's liveness gate (heartbeat/checkout/runAudit) was blind to ephemeral executor agents, leaving only the age>graceMs*3 threshold, so any ephemeral-executor task running longer than ~30 min was reclaimed to `todo` mid-flight. Adds the in-process live-session veto (activeSessionRegistry path / executingTaskLock / isTaskActive), mirroring the isWorkspaceTaskLive/sessionDead predicate, and honors clearPhantomExecutorBinding's live-session refusal in reclaimSelfOwnedBranchConflicts.
diff --git a/.changeset/fix-windows-terminal-worktrunk-popup.md b/.changeset/fix-windows-terminal-worktrunk-popup.md
deleted file mode 100644
index d44499dc33..0000000000
--- a/.changeset/fix-windows-terminal-worktrunk-popup.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": patch
----
-
-summary: Stop Windows Terminal version dialogs from popping up when opening the dashboard or Settings on Windows.
-category: fix
-dev: Root cause was the worktrunk integration, not the embedded terminal: worktrunk's CLI is named `wt`, which collides with Windows Terminal (`wt.exe`) on PATH, so probing it with `wt --version` launched Windows Terminal. Fixed by (1) `useWorktrunkInstallStatus` only auto-fetching `/api/worktrunk/status` when the integration is enabled (user opt-in) instead of on every Settings/dashboard mount, and (2) an engine-level guard in `probeWorktrunk` that refuses to exec a resolved `wt` that is the Windows Terminal alias (under `WindowsApps` / a `WindowsTerminal` package dir), covering all resolution surfaces.
diff --git a/.changeset/fn-7468-onboarding-quick-providers.md b/.changeset/fn-7468-onboarding-quick-providers.md
deleted file mode 100644
index 5fec19580c..0000000000
--- a/.changeset/fn-7468-onboarding-quick-providers.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": minor
----
-
-summary: Expand first-run AI provider quick-start choices beyond Anthropic.
-category: feature
-dev: Moves advanced/all-provider onboarding controls under the quick-start provider section.
diff --git a/.changeset/fn-7469-select-created-project-directory.md b/.changeset/fn-7469-select-created-project-directory.md
deleted file mode 100644
index 2572f60643..0000000000
--- a/.changeset/fn-7469-select-created-project-directory.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": patch
----
-
-summary: Select newly created folders automatically during project setup.
-category: fix
-dev: Adds DirectoryPicker opt-in selection for project-registration surfaces while preserving default picker behavior.
diff --git a/.changeset/fn-7470-git-onboarding.md b/.changeset/fn-7470-git-onboarding.md
deleted file mode 100644
index f58fd6e383..0000000000
--- a/.changeset/fn-7470-git-onboarding.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": minor
----
-
-summary: Show Git prerequisite guidance during first-run GitHub onboarding.
-category: feature
-dev: Adds bounded server-host git availability to auth status and onboarding.
diff --git a/.changeset/fn-7471-desktop-update-version.md b/.changeset/fn-7471-desktop-update-version.md
deleted file mode 100644
index 127e445d57..0000000000
--- a/.changeset/fn-7471-desktop-update-version.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": patch
----
-
-summary: Prevent Desktop update banners from using 0.0.0 as the current version.
-category: fix
-dev: Dashboard update checks now resolve packaged @fusion/desktop metadata and fail closed for unresolved versions.
diff --git a/.changeset/fn-7472-windows-desktop-close-quits.md b/.changeset/fn-7472-windows-desktop-close-quits.md
deleted file mode 100644
index 21f08bc954..0000000000
--- a/.changeset/fn-7472-windows-desktop-close-quits.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": patch
----
-
-summary: Quit Fusion Desktop on Windows when the window is closed.
-category: fix
-dev: Updates Electron close lifecycle so Windows shutdown reaches embedded runtime cleanup.
diff --git a/.changeset/fn-7473-desktop-anthropic-oauth-browser.md b/.changeset/fn-7473-desktop-anthropic-oauth-browser.md
deleted file mode 100644
index 0ba9284e63..0000000000
--- a/.changeset/fn-7473-desktop-anthropic-oauth-browser.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": patch
----
-
-summary: Open desktop Anthropic Subscription OAuth logins in the system browser.
-category: fix
-dev: Adds Electron window-open policy coverage and preserves Settings auth polling completion paths.
diff --git a/.changeset/fn-7474-github-onboarding-actions.md b/.changeset/fn-7474-github-onboarding-actions.md
deleted file mode 100644
index effca3756f..0000000000
--- a/.changeset/fn-7474-github-onboarding-actions.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": minor
----
-
-summary: Add GitHub OAuth and CLI setup actions to first-run onboarding.
-category: feature
-dev: GitHub onboarding now shows in-flow OAuth connect, gh auth login, and gh install guidance.
diff --git a/.changeset/fn-7475-github-setup-warning.md b/.changeset/fn-7475-github-setup-warning.md
deleted file mode 100644
index ddb9fae15a..0000000000
--- a/.changeset/fn-7475-github-setup-warning.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": patch
----
-
-summary: Delay GitHub setup warnings for one day and add a dashboard connect action.
-category: fix
-dev: Dashboard setup warnings now gate GitHub prompts per project and route the CTA to Settings → Authentication.
diff --git a/.changeset/fn-7476-desktop-engine-banner.md b/.changeset/fn-7476-desktop-engine-banner.md
deleted file mode 100644
index 5b29ed00c6..0000000000
--- a/.changeset/fn-7476-desktop-engine-banner.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": patch
----
-
-summary: Fix a false AI engine not running banner in desktop mode.
-category: fix
-dev: Distinguishes transient embedded desktop engine startup from true dashboard-only mode.
diff --git a/.changeset/fn-7477-connection-manager-clarity.md b/.changeset/fn-7477-connection-manager-clarity.md
deleted file mode 100644
index bcb18981e7..0000000000
--- a/.changeset/fn-7477-connection-manager-clarity.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": patch
----
-
-summary: Clarify the desktop Connection Manager add-remote flow.
-category: fix
-dev: Desktop Connection Manager now separates Local Server context from saved remote profiles and collapses the remote editor until add/edit.
diff --git a/.changeset/fn-7478-local-server-switch-option.md b/.changeset/fn-7478-local-server-switch-option.md
deleted file mode 100644
index 26378a00a4..0000000000
--- a/.changeset/fn-7478-local-server-switch-option.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": patch
----
-
-summary: Restore Local Server in the desktop Switch server list.
-category: fix
-dev: Desktop Connection Manager now lists local and saved remote destinations together.
diff --git a/.changeset/fn-7479-right-dock-task-popup.md b/.changeset/fn-7479-right-dock-task-popup.md
deleted file mode 100644
index fc5cbabe00..0000000000
--- a/.changeset/fn-7479-right-dock-task-popup.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": patch
----
-
-summary: Make right-dock task list clicks respect the task popup setting.
-category: fix
-dev: Threads openMobileTasksInPopup through the right-dock Tasks list route while preserving embedded dock detail when disabled.
diff --git a/.changeset/fn-7482-code-review-remediation.md b/.changeset/fn-7482-code-review-remediation.md
deleted file mode 100644
index 0b9d79d018..0000000000
--- a/.changeset/fn-7482-code-review-remediation.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": patch
----
-
-summary: Auto-retry retryable Code Review remediation failures.
-category: fix
-dev: Prevents retryable code-review-remediation graph failures from stranding tasks in in-review.
diff --git a/.changeset/fn-7486-merge-recovery-noop-ownership.md b/.changeset/fn-7486-merge-recovery-noop-ownership.md
deleted file mode 100644
index eff2f7557e..0000000000
--- a/.changeset/fn-7486-merge-recovery-noop-ownership.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": patch
----
-
-summary: Fix no-op task branch recovery after a previously landed task.
-category: fix
-dev: Merge/recovery ownership classification now checks no-diff branches before foreign trailer rejection.
diff --git a/.changeset/fn-7488-source-free-completion.md b/.changeset/fn-7488-source-free-completion.md
deleted file mode 100644
index 7a47fa068c..0000000000
--- a/.changeset/fn-7488-source-free-completion.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": patch
----
-
-summary: Allow documented source-free task-artifact deliveries to finish without commits.
-category: fix
-dev: fn_task_done now recognizes explicit gitignored .fusion/tasks artifact contracts while preserving source-change no-commit guards.
diff --git a/.changeset/fn-7490-push-to-remote-setting.md b/.changeset/fn-7490-push-to-remote-setting.md
deleted file mode 100644
index fcbcd51212..0000000000
--- a/.changeset/fn-7490-push-to-remote-setting.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": patch
----
-
-summary: Fix direct merges so Push to remote after merge honors the configured remote and branch.
-category: fix
-dev: Resolves remote-only push targets from the merge integration branch and preserves non-fatal push errors on done tasks.
diff --git a/.changeset/fn-7493-task-popup-layer.md b/.changeset/fn-7493-task-popup-layer.md
deleted file mode 100644
index 8447417427..0000000000
--- a/.changeset/fn-7493-task-popup-layer.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": patch
----
-
-summary: Keep task popups on the board layer with Activity menus above them.
-category: fix
-dev: Task-detail FloatingWindow callers use a lower layer band, and Activity view menus reposition after popup geometry changes.
diff --git a/.changeset/fn-7494-keyboard-shortcuts.md b/.changeset/fn-7494-keyboard-shortcuts.md
deleted file mode 100644
index 48eefcefe7..0000000000
--- a/.changeset/fn-7494-keyboard-shortcuts.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": minor
----
-
-summary: Add configurable dashboard keyboard shortcuts for Quick Chat and Terminal.
-category: feature
-dev: Global dashboardKeyboardShortcuts settings, guarded document-level key handling, and Escape topmost-popup dismissal.
diff --git a/.changeset/fn-7495-settings-search.md b/.changeset/fn-7495-settings-search.md
deleted file mode 100644
index e5ff54d07d..0000000000
--- a/.changeset/fn-7495-settings-search.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": minor
----
-
-summary: Add search in Settings so operators can find settings faster.
-category: feature
-dev: Dashboard Settings filters visible sections by setting labels and keywords.
diff --git a/.changeset/fn-7497-chat-first-event-timeout.md b/.changeset/fn-7497-chat-first-event-timeout.md
deleted file mode 100644
index d32b0d45cc..0000000000
--- a/.changeset/fn-7497-chat-first-event-timeout.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": patch
----
-
-summary: Keep accepted chat requests waiting instead of showing false first-event timeout failures.
-category: fix
-dev: Dashboard chat POST streams no longer abort accepted-but-silent responses on the client first-event timer.
diff --git a/.changeset/fn-7498-original-task-prompt.md b/.changeset/fn-7498-original-task-prompt.md
deleted file mode 100644
index e4a1a1b17d..0000000000
--- a/.changeset/fn-7498-original-task-prompt.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": patch
----
-
-summary: Show each task's original prompt in the Plan tab alongside the generated plan.
-category: fix
-dev: Adds a read-only Task Detail original-prompt section backed by task.description.
diff --git a/.changeset/fn-7499-before-after-transformation.md b/.changeset/fn-7499-before-after-transformation.md
deleted file mode 100644
index aa45ca63f9..0000000000
--- a/.changeset/fn-7499-before-after-transformation.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": patch
----
-
-summary: Add before-to-after transformation summaries to generated task definitions.
-category: feature
-dev: Built-in standard and fast triage prompts now require a `## Before → After Transformation` section.
diff --git a/.changeset/fn-7500-terminal-shortcuts.md b/.changeset/fn-7500-terminal-shortcuts.md
deleted file mode 100644
index e296300ad5..0000000000
--- a/.changeset/fn-7500-terminal-shortcuts.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": patch
----
-
-summary: Restore terminal Ctrl/Cmd copy and paste shortcuts.
-category: fix
-dev: Integrated and embedded terminals now own physical clipboard paste to avoid swallowed or duplicate input.
diff --git a/.changeset/fn-7502-terminal-below-layout.md b/.changeset/fn-7502-terminal-below-layout.md
deleted file mode 100644
index 6c7aa6e95f..0000000000
--- a/.changeset/fn-7502-terminal-below-layout.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": minor
----
-
-summary: Add a pinned below-application layout option for the dashboard terminal.
-category: feature
-dev: Terminal display mode now supports persisted docked, floating, and below layouts, with header controls replacing the footer shell.
diff --git a/.changeset/fn-7503-agent-log-timing.md b/.changeset/fn-7503-agent-log-timing.md
deleted file mode 100644
index 2b3c5ff780..0000000000
--- a/.changeset/fn-7503-agent-log-timing.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": patch
----
-
-summary: Show first-token and tool processing durations in task agent logs.
-category: feature
-dev: Adds optional agent-log timing fields `timeToFirstTokenMs` and `durationMs`.
diff --git a/.changeset/fn-7504-mobile-chat-composer-keyboard.md b/.changeset/fn-7504-mobile-chat-composer-keyboard.md
deleted file mode 100644
index 2bb827bed9..0000000000
--- a/.changeset/fn-7504-mobile-chat-composer-keyboard.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": patch
----
-
-summary: Fix mobile Chat composer being hidden behind the keyboard accessory bar.
-category: fix
-dev: Adds keyboard-open bottom clearance in ChatView so the composer clears the iOS input-assistant/autofill bar without a persistent .chat-thread transform or Android reserved-gap.
diff --git a/.changeset/fn-7505-settings-default-descriptions.md b/.changeset/fn-7505-settings-default-descriptions.md
deleted file mode 100644
index 23bf9f718c..0000000000
--- a/.changeset/fn-7505-settings-default-descriptions.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": patch
----
-
-summary: Settings descriptions now show each setting's default value.
-category: feature
-dev: Appended default-value copy to settings.* i18n descriptions across Global, Runtimes, and Project Settings sections, sourced from DEFAULT_GLOBAL_SETTINGS/DEFAULT_PROJECT_SETTINGS in settings-schema.ts; added settings-default-descriptions.test.tsx guarding that every surfaced setting states a default (or explicit "inherits"/"no default \u2014 unset") and that every DEFAULT_SETTINGS key is documented or allowlisted as not surfaced.
diff --git a/.changeset/fn-7506-settings-reset.md b/.changeset/fn-7506-settings-reset.md
deleted file mode 100644
index 8731353926..0000000000
--- a/.changeset/fn-7506-settings-reset.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": minor
----
-
-summary: Add a Reset Settings button to restore a menu's or all project settings to defaults.
-category: feature
-dev: New tested section→keys (scope-aware) registry (packages/dashboard/app/components/settings/section-keys.ts) drives per-menu reset via updateSettings/updateGlobalSettings with null-as-delete; non-blob sections (secrets, MCP, plugins, memory, auth, prompts, CLI agents, runtimes) are excluded with a documented reason.
diff --git a/.changeset/fn-7508-planner-oversight-level-setting.md b/.changeset/fn-7508-planner-oversight-level-setting.md
deleted file mode 100644
index 8fb77762f5..0000000000
--- a/.changeset/fn-7508-planner-oversight-level-setting.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": minor
----
-
-summary: Add a per-workflow planner oversight level setting (Off, Observe, Steer, Autonomous recovery).
-category: feature
-dev: New workflow setting `plannerOversightLevel` declared in BUILTIN_OVERSIGHT_SETTINGS; default `autonomous`. Per-task override and engine behavior land in follow-up tasks.
diff --git a/.changeset/fn-7509-per-task-planner-oversight-override.md b/.changeset/fn-7509-per-task-planner-oversight-override.md
deleted file mode 100644
index 4ccbe4ee99..0000000000
--- a/.changeset/fn-7509-per-task-planner-oversight-override.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": minor
----
-
-summary: Tasks can override the workflow planner oversight level (Off, Observe, Steer, Autonomous recovery).
-category: feature
-dev: New nullable Task.plannerOversightLevel field (migration 137, SCHEMA_VERSION 137) mirroring executionMode; NULL inherits the workflow setting. Adds resolveEffectivePlannerOversightLevel precedence helper. Dashboard UI/API threading and engine behavior land in follow-up tasks.
diff --git a/.changeset/fn-7510-oversight-default.md b/.changeset/fn-7510-oversight-default.md
deleted file mode 100644
index 94cce48169..0000000000
--- a/.changeset/fn-7510-oversight-default.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": minor
----
-
-summary: Planner oversight now defaults to full steering/control for every workflow unless explicitly changed.
-category: feature
-dev: Confirms the `plannerOversightLevel` workflow-setting default is the highest (autonomous) level; unset workflow value and unset per-task override both resolve to full steering via `resolveEffectivePlannerOversightLevel` (task override → workflow effective value → autonomous), adding dedicated regression coverage for the "unless explicitly disabled" precedence.
diff --git a/.changeset/fn-7511-planner-overseer-monitoring.md b/.changeset/fn-7511-planner-overseer-monitoring.md
deleted file mode 100644
index 7037d140bb..0000000000
--- a/.changeset/fn-7511-planner-overseer-monitoring.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": minor
----
-
-summary: Planner oversight now monitors tasks across executor, reviewer, merger, pull-request, and workflow-gate stages.
-category: feature
-dev: Adds records-only PlannerOverseerMonitor + resolveWatchedStage + OverseerStageObservation in @fusion/engine, gated by resolveEffectivePlannerOversightLevel (off = no observation) and wired into ProjectEngine via a bounded poll. Steering/recovery and UI land in FN-7512/FN-7515+.
diff --git a/.changeset/fn-7512-planner-bounded-recovery.md b/.changeset/fn-7512-planner-bounded-recovery.md
deleted file mode 100644
index 76586f23d0..0000000000
--- a/.changeset/fn-7512-planner-bounded-recovery.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": minor
----
-
-summary: Planner oversight can autonomously inject guidance, retry stuck/failed steps, and request fixes within bounded limits.
-category: feature
-dev: Adds pure `decidePlannerRecovery` + recovery types (core) and `PlannerRecoveryController` with injected guidance/retry/targeted-fix handlers (engine), consuming the FN-7511 observation. Acts only at effective level `autonomous`, caps attempts per (task, stage) via `PLANNER_RECOVERY_MAX_ATTEMPTS`, skips user-paused tasks, and excludes merge/PR/destructive actions (deferred to FN-7513) and comprehensive human-control safeguards (FN-7514).
diff --git a/.changeset/fn-7513-planner-confirmation-gate.md b/.changeset/fn-7513-planner-confirmation-gate.md
deleted file mode 100644
index 69b79446a0..0000000000
--- a/.changeset/fn-7513-planner-confirmation-gate.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": minor
----
-
-summary: Planner oversight now requires confirmation before merge/PR actions and destructive/external side effects.
-category: feature
-dev: Adds `PlannerActionSideEffectClass` + `PlannerConfirmationRequest` and `classifyPlannerActionSideEffect`/`requiresPlannerConfirmation` (core), extends `decidePlannerRecovery` with an `await_confirmation` action, and adds `requestConfirmation`/`resolveConfirmation` gating to `PlannerRecoveryController` (engine). Merge/PR and destructive/external actions never execute without a recorded approval; bounded recovery (guidance/retry/targeted-fix) is unchanged. UX rendering, human-control safeguards, timeline, and run-audit land in follow-up tasks.
diff --git a/.changeset/fn-7514-overseer-human-control-guard.md b/.changeset/fn-7514-overseer-human-control-guard.md
deleted file mode 100644
index 469d0ffb18..0000000000
--- a/.changeset/fn-7514-overseer-human-control-guard.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": minor
----
-
-summary: Planner overseer now stays fully hands-off for paused tasks and auto-merge-off / human-review tasks.
-category: feature
-dev: Adds the pure `evaluateOverseerHumanControl` policy (packages/engine/src/overseer-human-control-policy.ts), consulted at the top of `PlannerRecoveryController.tick()` before any action classification, confirmation gating, steering, retry, or dispatch — so a user-paused or `autoMerge:false`/human-review task never even records a pending confirmation. Reuses `allowsAutoMergeProcessing` from `@fusion/core` verbatim (never re-derives the auto-merge/human-review predicate). Distinguishes explicit user pause (`task.userPaused===true`, or `task.paused===true` with no `pausedReason`) from engine/self-healing parks (which always stamp a `pausedReason`). Emits a bounded `overseer:oversight-withheld-human-control` run-audit no-action event (metadata: `{ taskId, reason, stage, oversightLevel }`), deduped per (taskId, reason) so it does not spam every poll.
diff --git a/.changeset/fn-7515-planner-oversight-config-exposure.md b/.changeset/fn-7515-planner-oversight-config-exposure.md
deleted file mode 100644
index 8fa1d7229b..0000000000
--- a/.changeset/fn-7515-planner-oversight-config-exposure.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": minor
----
-
-summary: Configure planner oversight level per task and per project in the workflow editor and task create/detail.
-category: feature
-dev: Per-task `plannerOversightLevel` override exposed via TaskForm (Inherit/off/observe/steer/autonomous), threaded through createTask/updateTask; workflow-editor Values tab gets a first-class display entry. Workflow-native setting; not a project setting.
diff --git a/.changeset/fn-7518-oversight-notification-verbosity.md b/.changeset/fn-7518-oversight-notification-verbosity.md
deleted file mode 100644
index 18b3979702..0000000000
--- a/.changeset/fn-7518-oversight-notification-verbosity.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": minor
----
-
-summary: Add a configurable planner-overseer notification verbosity level (Silent/Errors/Important/All).
-category: feature
-dev: New workflow-native enum setting `plannerOversightNotificationLevel` in BUILTIN_OVERSIGHT_SETTINGS; default `important`. Resolves via resolveEffectiveSettings; emission gating that reads it lands in FN-7519/FN-7520.
diff --git a/.changeset/fn-7519-planner-intervention-timeline.md b/.changeset/fn-7519-planner-intervention-timeline.md
deleted file mode 100644
index 1118363906..0000000000
--- a/.changeset/fn-7519-planner-intervention-timeline.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": minor
----
-
-summary: Add a task-detail planner-overseer intervention timeline (stage, reason, action, outcome, attempts, links).
-category: feature
-dev: New core `PlannerInterventionEntry` model + `recordPlannerIntervention`/`getPlannerInterventionTimeline` helpers persisting via the run-audit store under the `overseer:intervention` mutation, plus a `PlannerInterventionTimeline` component rendered in the task-detail Planner Oversight cluster. Emission call-sites land in FN-7520.
diff --git a/.changeset/fn-7520-planner-overseer-events.md b/.changeset/fn-7520-planner-overseer-events.md
deleted file mode 100644
index b7850edd77..0000000000
--- a/.changeset/fn-7520-planner-overseer-events.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": minor
----
-
-summary: Emit planner-overseer run-audit events for observations, steering, retries, recovery, confirmations, and escalations.
-category: feature
-dev: New core emitters (emitOverseerObservation/Steering/RecoveryAttempt/Retry/Confirmation/Escalation) in planner-overseer-events.ts, each mapping its decision-point to the correct intervention action/outcome and delegating to FN-7519's recordPlannerIntervention under the overseer:intervention mutation. Producer call-sites land in FN-7511/FN-7512/FN-7513.
diff --git a/.changeset/fn-7523-task-revert.md b/.changeset/fn-7523-task-revert.md
deleted file mode 100644
index 4912dce4c3..0000000000
--- a/.changeset/fn-7523-task-revert.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": patch
----
-
-summary: Add an intelligent git-revert engine service and POST /api/tasks/:id/revert route.
-category: feature
-dev: New `packages/engine/src/task-revert.ts` exports `resolveTaskRevertCommits`, `classifyTaskRevert`, and `performTaskRevert` (squash/rebase/lineage attribution precedence, dry-run classification, guaranteed-clean rollback). Route enforces done/archived-only and autoMerge-off guard rails; conflicting results are returned unresolved for sibling FN-7524 (AI-undo) to act on. Workspace tasks return `unsupported`.
diff --git a/.changeset/fn-7524-ai-undo-revert.md b/.changeset/fn-7524-ai-undo-revert.md
deleted file mode 100644
index 3a78674fac..0000000000
--- a/.changeset/fn-7524-ai-undo-revert.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": minor
----
-
-summary: Add an AI-undo fallback task when reverting a done task via git conflicts or is unsupported.
-category: feature
-dev: `POST /api/tasks/:id/revert` now accepts `{ mode?: "git" | "ai" | "auto" }` (default `"auto"`). `"auto"` tries the FN-7523 git-revert path first and falls back to creating an AI-undo board task (`{ mode: "ai", createdTaskId, alreadyOpen? }`) on a conflicting or unsupported (e.g. workspace) git result; `needsHuman` (autoMerge-off) never triggers the fallback. `"ai"` always creates the AI-undo task; `"git"` keeps the FN-7523 git-only contract, which is otherwise unchanged. New engine exports: `createAiUndoTask`, `buildAiUndoTaskDescription`, `REVERT_OF_METADATA_KEY`. New core store method `TaskStore.findOpenRevertTaskForSource` backs the idempotency guard (an open undo task suppresses a duplicate; a closed one does not).
diff --git a/.changeset/fn-7525-revert-card-affordance.md b/.changeset/fn-7525-revert-card-affordance.md
deleted file mode 100644
index 2444d32ac2..0000000000
--- a/.changeset/fn-7525-revert-card-affordance.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": minor
----
-
-summary: Add a Revert action to Done/Archived task cards to undo landed changes.
-category: feature
-dev: Wires onRevertTask through Board/List/Detail surfaces; calls POST /tasks/:id/revert in "auto" mode with a conflict-confirm AI-undo fallback (mode: "ai").
diff --git a/.changeset/fn-7526-plan-auto-approve.md b/.changeset/fn-7526-plan-auto-approve.md
deleted file mode 100644
index 7dce0c5a0b..0000000000
--- a/.changeset/fn-7526-plan-auto-approve.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": patch
----
-
-summary: Auto-approve now reliably sends specified plans to the board without a manual approval stop.
-category: fix
-dev: FN-7526 — investigated the reported "plans still park at awaiting-approval when auto-approve is on" symptom; resolvePlanApprovalRequired, mergeEffectiveSettings/applyWorkflowSettingsOverlay, and every finalizeApprovedTask call site (specifyTask, recoverApprovedTask, retryUnavailablePlanReview, tryFinalizeExplicitDuplicateMarker) already honored project planApprovalMode: "auto-approve-all" over a stored workflow requirePlanApproval value — no production defect reproduced. Added end-to-end regression coverage across every enumerated surface (Plan Review reviewer-outage retry, refinement routing, self-healing starved-refinement recovery) using the real mergeEffectiveSettings pipeline instead of isolated bare-settings unit calls, plus explicit assertions that the independent release-authorization and Workflow Plan Review gates remain intact under auto-approve-all, so a future bare-settings call site is caught immediately instead of silently reintroducing the reported behavior.
diff --git a/.changeset/fn-7527-desktop-switch-server-navigation.md b/.changeset/fn-7527-desktop-switch-server-navigation.md
deleted file mode 100644
index 19784749de..0000000000
--- a/.changeset/fn-7527-desktop-switch-server-navigation.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": patch
----
-
-summary: Fix the in-dashboard Switch server menu not switching desktop local/remote.
-category: fix
-dev: The desktop shell's redirect effects in App.tsx read a dead `localServer` field that the preload never populates; extracted `resolveDesktopShellRedirectTarget` in appLifecycle.ts now derives the navigation target from the live `localRuntime`/`activeProfileId` state for both directions, and the unused `localServer` field was removed from `ShellConnectionState`.
diff --git a/.changeset/fn-7528-task-performance-capture.md b/.changeset/fn-7528-task-performance-capture.md
deleted file mode 100644
index c460beaa73..0000000000
--- a/.changeset/fn-7528-task-performance-capture.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": minor
----
-
-summary: Capture a structured performance snapshot when an agent task completes.
-category: feature
-dev: New AgentReflectionService.captureTaskPerformance persists a non-LLM post-task ReflectionMetrics record (duration, packages/files touched, verification command + scope, retry/rework count) and emits ids/counts-only `reflection:captured` run-audit telemetry; populates performanceSummary/latestReflection.
diff --git a/.changeset/fn-7531-planner-overseer-state-exposure.md b/.changeset/fn-7531-planner-overseer-state-exposure.md
deleted file mode 100644
index e47ffac7bc..0000000000
--- a/.changeset/fn-7531-planner-overseer-state-exposure.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": minor
----
-
-summary: Task cards can now show the planner overseer's active state (idle/watching/steering/recovering/awaiting-confirmation).
-category: feature
-dev: Adds a serializable `PlannerOverseerRuntimeSnapshot` + pure `derivePlannerOverseerState` (core), a read-only `ProjectEngine.getPlannerOverseerRuntimeSnapshot(taskId)` accessor assembling it from the FN-7511 monitor + FN-7512/7513 recovery controller, and a best-effort additive `plannerOverseerState` enrichment on `GET /api/tasks` (mirrors the `branchProgress` pattern; never persisted, never fails the board load). Consumed by FN-7516's TaskCard.
diff --git a/.changeset/fn-7532-branch-group-completion.md b/.changeset/fn-7532-branch-group-completion.md
deleted file mode 100644
index 8b18b6cb39..0000000000
--- a/.changeset/fn-7532-branch-group-completion.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": patch
----
-
-summary: Fix branch group completion checklists to show accurate landed/finished counts.
-category: fix
-dev: runAiMerge (the sole merge path since master-plan U0) never resolved branch-group routing or stamped mergeDetails.mergeTargetBranch/mergeTargetSource, so isBranchGroupMemberLanded permanently reported shared-group members as not landed. Routes through resolveBranchGroupMergeRouting (matching the legacy merger.ts pattern) and stamps the target fields on both the landed and no-op finalize paths; preserves merge-target-safety in isBranchGroupMemberLanded (a sibling/mismatched-branch member still never counts as landed).
diff --git a/.changeset/fn-7534-branch-group-archived-member.md b/.changeset/fn-7534-branch-group-archived-member.md
deleted file mode 100644
index d79c918c9d..0000000000
--- a/.changeset/fn-7534-branch-group-archived-member.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": patch
----
-
-summary: Branch groups no longer report complete (or become promotable) when an unlanded member is archived.
-category: fix
-dev: listTasksByBranchGroup membership now scans with includeArchived:true so an archived-but-unlanded member stays counted in total instead of silently dropping out; mergeDetails is now persisted on ArchivedTaskEntry so an archived member that had already landed keeps counting as landed. evaluateBranchGroupCompletion / promoteBranchGroup gate correctly; merge-target-safety in isBranchGroupMemberLanded is unchanged.
diff --git a/.changeset/fn-7535-global-gitlab-setting-save.md b/.changeset/fn-7535-global-gitlab-setting-save.md
deleted file mode 100644
index adf4d7d16c..0000000000
--- a/.changeset/fn-7535-global-gitlab-setting-save.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": patch
----
-
-summary: Fix the global GitLab integration setting not persisting when saved.
-category: fix
-dev: splitSettingsSave now diffs the five global GitLab keys (gitlabEnabled, gitlabInstanceUrl, gitlabApiBaseUrl, gitlabAuthToken, gitlabAuthTokenType) against scoped global initials only, never the project-effective merged initialValues, so a project override no longer suppresses a real global save.
diff --git a/.changeset/fn-7536-activity-dropdown-mobile.md b/.changeset/fn-7536-activity-dropdown-mobile.md
deleted file mode 100644
index 1fefce406b..0000000000
--- a/.changeset/fn-7536-activity-dropdown-mobile.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": patch
----
-
-summary: Fix task-detail Activity view dropdown not opening reliably on mobile.
-category: fix
-dev: Guards the Activity menu's window resize/orientationchange/scroll close-listener with the same opening-tap timing guard already used for visualViewport, and exempts scroll events originating in the `.detail-tabs` scroller, so a same-gesture mobile tap echo (Android/iOS, fixed modal or `.floating-window--task-detail` popup) no longer closes the menu the instant it opens.
diff --git a/.changeset/fn-7537-backup-automation-manual-run.md b/.changeset/fn-7537-backup-automation-manual-run.md
deleted file mode 100644
index d367f5d451..0000000000
--- a/.changeset/fn-7537-backup-automation-manual-run.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": patch
----
-
-summary: Manual "Run now" for the Database Backup automation now runs in-process like the scheduler, matching cron behavior.
-category: fix
-dev: The legacy single-command and command-step manual automation run path (`executeSingleCommand` in packages/dashboard/src/routes.ts) now intercepts `isInProcessBackupCommand`/`isInProcessMemoryBackupCommand` via the scoped TaskStore, mirroring `RoutineRunner.executeCommand`/`CronRunner`, instead of always shelling out via `exec()`. `formatInProcessBackupError`, `isInProcessBackupCommand`, and `isInProcessMemoryBackupCommand` are now exported from `@fusion/engine` for reuse. Existing onStep/onText live-run callbacks already stream incremental output for command/backup runs; added regression coverage confirming this holds for the new interception branch.
diff --git a/.changeset/fn-7539-oversight-badge-default.md b/.changeset/fn-7539-oversight-badge-default.md
deleted file mode 100644
index c9ab7eaf20..0000000000
--- a/.changeset/fn-7539-oversight-badge-default.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": patch
----
-
-summary: Task cards no longer show the "Auto-recovery" oversight badge unless oversight is explicitly configured.
-category: fix
-dev: `TaskCard.tsx`'s `showOversightBadge` gate now also suppresses the badge when the effective level equals `DEFAULT_PLANNER_OVERSIGHT_LEVEL` ("autonomous") and there is no explicit per-task `plannerOversightLevel` override; an explicit per-task override of "autonomous" still renders the badge.
diff --git a/.changeset/fn-7542-remove-overseer-state-badge.md b/.changeset/fn-7542-remove-overseer-state-badge.md
deleted file mode 100644
index 3491a6b29d..0000000000
--- a/.changeset/fn-7542-remove-overseer-state-badge.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": patch
----
-
-summary: Remove the per-card overseer-state ("Executor") badge from task cards.
-category: fix
-dev: Deleted the FN-7516 `card-overseer-state-badge` render, its card-local `deriveOverseerCardWatchedStage` helper/label maps, and its CSS; the sibling oversight-level badge (`card-oversight-badge`) is unaffected.
diff --git a/.changeset/fn-7543-original-prompt-markdown-collapsed.md b/.changeset/fn-7543-original-prompt-markdown-collapsed.md
deleted file mode 100644
index 79284d7736..0000000000
--- a/.changeset/fn-7543-original-prompt-markdown-collapsed.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": patch
----
-
-summary: Original task prompt now renders as Markdown and is collapsed by default in the task Plan tab.
-category: feature
-dev: Task Detail Plan/Definition tab original-prompt section reuses the existing `.detail-source-toggle`/`.detail-source-chevron--expanded` collapse pattern and the shared `ReactMarkdown` pipeline (`remarkGfm`, `sharedRehypePlugins`, `markdownLinkifyComponents`); backed by read-only `task.description`, no change to the generated `PROMPT.md` editor/revision flow.
diff --git a/.changeset/fn-7544-artifact-cross-instance-live-refresh.md b/.changeset/fn-7544-artifact-cross-instance-live-refresh.md
deleted file mode 100644
index f890cc0447..0000000000
--- a/.changeset/fn-7544-artifact-cross-instance-live-refresh.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": patch
----
-
-summary: Fix agent-created artifacts not appearing live in the dashboard artifacts view.
-category: fix
-dev: Root cause was cross-instance artifact-registration replication, not the route/hook/render path (all already correct). `TaskStore.registerArtifact()` never bumped `lastModified`, and `checkForChanges()` (the polling replicator that lets a second TaskStore instance on the same project — e.g. the dashboard's cached store vs. the engine's own store — mirror events it did not write itself) only ever diffed the `tasks` table, never `artifacts`. A store instance that did not perform the write could therefore never observe or re-emit `artifact:registered`, leaving an already-open Documents/task Artifacts gallery stale until a full reload. Fixed by bumping `lastModified` on artifact writes and adding a strictly-increasing `rowid`-cursor poll over the `artifacts` table in `checkForChanges()`. See `packages/core/src/__tests__/artifacts.test.ts` and `packages/dashboard/src/routes/__tests__/artifacts-route-integration.test.ts` for regression coverage.
diff --git a/.changeset/fn-7547-workspace-task-revert.md b/.changeset/fn-7547-workspace-task-revert.md
deleted file mode 100644
index 1404ce5d4c..0000000000
--- a/.changeset/fn-7547-workspace-task-revert.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": minor
----
-
-summary: Support reverting multi-repo workspace tasks via git, all-or-nothing across sub-repos.
-category: feature
-dev: Extends `packages/engine/src/task-revert.ts` with `resolveWorkspaceTaskRevertCommits`/`revertWorkspaceTask` and wires `POST /api/tasks/:id/revert` to dispatch workspace tasks (`isWorkspaceTask`) to the new path; returns `{ mode: "git", clean, workspace: { repos: [...] }, conflicts? }`. Single-repo `performTaskRevert` path is unchanged.
diff --git a/.changeset/fn-7548-per-sha-revert-granularity.md b/.changeset/fn-7548-per-sha-revert-granularity.md
deleted file mode 100644
index 657bd6db0f..0000000000
--- a/.changeset/fn-7548-per-sha-revert-granularity.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": minor
----
-
-summary: Add per-sha revert commit granularity to the task revert API and service.
-category: feature
-dev: `performTaskRevert` and `POST /api/tasks/:id/revert` accept an optional `granularity: "squash" | "per-sha"` (default `"squash"`, unchanged FN-7523 behavior). `"per-sha"` creates one attributed `revert(FN-xxxx)` commit per original sha (each with its own `Fusion-Task-Id` trailer and audit line), skipping no-op shas without empty commits. A mid-batch conflict in either mode rolls back the whole batch to the pre-call HEAD — no partially-landed per-sha commits. The clean result now reports `revertCommitShas: string[]` (all created commits) alongside the existing `revertCommitSha` (kept for backward compatibility).
diff --git a/.changeset/fn-7550-terminal-shortcut-scroll.md b/.changeset/fn-7550-terminal-shortcut-scroll.md
deleted file mode 100644
index 89119231f1..0000000000
--- a/.changeset/fn-7550-terminal-shortcut-scroll.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": patch
----
-
-summary: Fix the mobile terminal shortcut bar so it scrolls horizontally to reach every key.
-category: fix
-dev: Added `min-width: 0` to `.terminal-shortcut-panel` to defeat the flex min-width:auto trap that clipped overflow instead of engaging `overflow-x: auto`.
diff --git a/.changeset/fn-7551-overseer-timeline-wiring.md b/.changeset/fn-7551-overseer-timeline-wiring.md
deleted file mode 100644
index 82d4775708..0000000000
--- a/.changeset/fn-7551-overseer-timeline-wiring.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": patch
----
-
-summary: Planner-oversight intervention timeline now populates from real engine activity.
-category: fix
-dev: Wires PlannerOverseerMonitor/PlannerRecoveryController decision points to the FN-7520 emitOverseer* façade with the real TaskStore; observation/escalation emission deduped per (task, stage[, signal]).
diff --git a/.changeset/fn-7552-mobile-authentication-global-prefix.md b/.changeset/fn-7552-mobile-authentication-global-prefix.md
deleted file mode 100644
index a36edea9cb..0000000000
--- a/.changeset/fn-7552-mobile-authentication-global-prefix.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": patch
----
-
-summary: Show the "Global" prefix on the Authentication entry in the mobile Settings picker.
-category: fix
-dev: resolveSettingsSectionOptionLabel now derives the Global-group prefix for storage-less (scope: undefined) sections in SettingsModal.tsx (FN-7552).
diff --git a/.changeset/fn-7553-keyboard-shortcuts-section.md b/.changeset/fn-7553-keyboard-shortcuts-section.md
deleted file mode 100644
index 79259dd4d5..0000000000
--- a/.changeset/fn-7553-keyboard-shortcuts-section.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": minor
----
-
-summary: Add a dedicated Keyboard Shortcuts settings section with click-to-record capture and more configurable actions.
-category: feature
-dev: Relocates dashboardKeyboardShortcuts into its own settings section, adds a ShortcutCaptureInput recorder, and extends DashboardShortcutAction with openFiles/openSettings/openCommandCenter/newTask actions wired into existing App nav handlers.
diff --git a/.changeset/fn-7554-pr-based-revert.md b/.changeset/fn-7554-pr-based-revert.md
deleted file mode 100644
index 5b164b3be2..0000000000
--- a/.changeset/fn-7554-pr-based-revert.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": minor
----
-
-summary: Open a revert PR for done/archived tasks when autoMerge is disabled instead of refusing.
-category: feature
-dev: `POST /api/tasks/:id/revert` gains an additive `{ mode: "pr", clean: true, prUrl, prNumber, revertBranch, existingPr? }` result for clean single-repo reverts under `autoMerge:false`, reusing `GitHubClient.createPr`, `findPrForBranch` idempotency, and the `manual:true` PR handoff. New engine export `prepareRevertPrBranch` (packages/engine/src/task-revert.ts) prepares the dedicated `fusion/revert-<id>` branch without ever mutating the base branch. Existing `{ mode: "git" | "ai", ... }` shapes and the `autoMerge:true` path are unchanged.
diff --git a/.changeset/fn-7556-ai-undo-workflow.md b/.changeset/fn-7556-ai-undo-workflow.md
deleted file mode 100644
index b087f540ba..0000000000
--- a/.changeset/fn-7556-ai-undo-workflow.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": minor
----
-
-summary: AI-undo tasks now default to a configurable, stricter review workflow.
-category: feature
-dev: New project setting `aiUndoTaskWorkflowId` (default `builtin:review-heavy`) selects the workflow for AI-undo board tasks created by `POST /api/tasks/:id/revert` (`mode: "ai"`, the `auto` conflict fallback, and the workspace conflict fallback all share the `createAiUndoResult()` closure, so all three inherit this default). A blank/unset value means the created task inherits the project default workflow (pre-FN-7556 behavior). The route validates the configured id via `getWorkflowDefinition`/`isBuiltinWorkflowId` and falls back to inherit (with a logged warning) on a blank or unknown value, so a misconfigured id never breaks AI-undo task creation. The engine's `createAiUndoTask` helper stays pure — it only forwards a `workflowId` it is given, never resolves the setting itself. The Settings Modal UI field for this setting is a deliberate follow-up task; the value is settable today only via the settings API.
diff --git a/.changeset/fn-7557-plan-auto-approve-default.md b/.changeset/fn-7557-plan-auto-approve-default.md
deleted file mode 100644
index f849b72911..0000000000
--- a/.changeset/fn-7557-plan-auto-approve-default.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": minor
----
-
-summary: Plan auto-approval is now the default; specified tasks skip manual approval unless you opt into workflow/require-all.
-category: feature
-dev: `DEFAULT_PROJECT_SETTINGS.planApprovalMode` flips `workflow` → `auto-approve-all`; existing projects with an explicit stored value are unchanged; consumed by `resolvePlanApprovalRequired` at the triage gating sites.
diff --git a/.changeset/fn-7559-approval-gate-disambiguation.md b/.changeset/fn-7559-approval-gate-disambiguation.md
deleted file mode 100644
index 7ac656be79..0000000000
--- a/.changeset/fn-7559-approval-gate-disambiguation.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": patch
----
-
-summary: Tasks held for release authorization or Plan Review are now shown distinctly, so auto-approve no longer looks broken.
-category: fix
-dev: FN-7559 — auto-approve-all bypasses only the manual plan-approval gate (unchanged, FN-7526). Release-authorization holds are surfaced with a new distinct status reason (`Task.awaitingApprovalReason: "release-authorization"`) and no longer render the generic manual Approve/Reject affordance in TaskCard/TaskDetailModal; Workflow Plan Review already used distinct statuses (`needs-replan`/`plan-review-unavailable`) and is unaffected. Both gates remain independent and intact — this is UI/data disambiguation only.
diff --git a/.changeset/fn-7560-mobile-terminal-footer.md b/.changeset/fn-7560-mobile-terminal-footer.md
deleted file mode 100644
index 6ae6140ab1..0000000000
--- a/.changeset/fn-7560-mobile-terminal-footer.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": patch
----
-
-summary: Move mobile terminal controls into a bottom footer so they no longer crowd the header, with a scrollable shortcut bar.
-category: fix
-dev: On the ≤768px terminal, the `.terminal-actions` cluster now renders in a `terminal-footer-actions` bar (with `min-width:0; overflow-x:auto`) instead of the header; desktop/floating/pinned-below keep the FN-7502 header layout. Preserves the FN-7550 shortcut-panel scroll fix.
diff --git a/.changeset/fn-7560-release-gate-disclaimer-false-positive.md b/.changeset/fn-7560-release-gate-disclaimer-false-positive.md
deleted file mode 100644
index 6ddbecef94..0000000000
--- a/.changeset/fn-7560-release-gate-disclaimer-false-positive.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": patch
----
-
-summary: Stop the release-authorization gate from holding tasks that merely disclaim releasing.
-category: fix
-dev: classifyReleaseTask now strips negated release-disclaimer clauses (e.g. "this task performs no release/publish; releases are owned by scripts/release.mjs") before signal matching in packages/engine/src/triage-release-authorization.ts, so revert/undo/UI specs are no longer false-flagged as release-class. Genuine "run pnpm release"/"publish @runfusion/fusion" intent still trips the gate.
diff --git a/.changeset/fn-7561-mobile-terminal-spacing.md b/.changeset/fn-7561-mobile-terminal-spacing.md
deleted file mode 100644
index 020bb8c7c0..0000000000
--- a/.changeset/fn-7561-mobile-terminal-spacing.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": patch
----
-
-summary: Fix mobile terminal text still rendering with excess inter-character gaps after font-load settle.
-category: fix
-dev: Root cause: xterm's OptionsService setter is a no-op when reassigning an already-current fontFamily/fontSize, so post-settle reapply never forced CharSizeService/DomRenderer to remeasure. Added `forceTerminalFontRemeasure()` in `terminalPreferences.ts`, used by both `TerminalModal.tsx` and `SessionTerminal.tsx` at every post-`waitForTerminalFontMetrics()` settle site.
diff --git a/.changeset/fn-7561-plan-review-replan-loop.md b/.changeset/fn-7561-plan-review-replan-loop.md
deleted file mode 100644
index 3bae0fe9b9..0000000000
--- a/.changeset/fn-7561-plan-review-replan-loop.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": patch
----
-
-summary: Stop Plan Review from looping tasks forever and fix its "can't find the plan" reviews.
-category: fix
-dev: FN-7561 — Plan Review pre-merge gate hardening in packages/engine/src/executor.ts. (1) The reviewer ran readonly with cwd=worktree but the spec lives at project-root .fusion/tasks/<id>/PROMPT.md, so "Read PROMPT.md" produced "no PROMPT.md found / data is in a DB" non-verdicts; the spec text is now injected into the reviewer prompt via readTaskArtifact. (2) A malformed reviewer response now self-retries once on the primary model when no fallback is configured. (3) A malformed (advisory_failure, no verdict) plan-review result can never trigger a triage replan. (4) The unbounded plan-review replan default is capped at 15 attempts with a loud halting log entry, so a persistently-disagreeing planner/reviewer no longer burns LLM calls indefinitely (FN-7525 ran 13+ attempts overnight).
diff --git a/.changeset/fn-7563-overseer-badge-explanation.md b/.changeset/fn-7563-overseer-badge-explanation.md
deleted file mode 100644
index 31b019ecfe..0000000000
--- a/.changeset/fn-7563-overseer-badge-explanation.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": patch
----
-
-summary: Planner-overseer task badge now shows a readable label and explains what it is waiting on.
-category: fix
-dev: TaskCard badge renders plannerOverseerStateLabel + plannerOverseerBadgeTooltip built from the existing PlannerOverseerRuntimeSnapshot (reason/watchedStage/signal/pendingConfirmation); presentation-only, no engine changes.
diff --git a/.changeset/fn-7564-approve-plan-release-authorization-guard.md b/.changeset/fn-7564-approve-plan-release-authorization-guard.md
deleted file mode 100644
index e225c8e2a9..0000000000
--- a/.changeset/fn-7564-approve-plan-release-authorization-guard.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": patch
----
-
-summary: Plan approve/reject API now blocks release-authorization holds, requiring the authorization marker first.
-category: fix
-dev: FN-7564 — POST /tasks/:id/approve-plan and /reject-plan now return 400 when task.awaitingApprovalReason === "release-authorization" (FN-7559 discriminator), enforcing the FN-6481 release-authorization gate at the API layer regardless of client. Manual-approval holds are unaffected.
diff --git a/.changeset/fn-7565-mobile-terminal-close-corner.md b/.changeset/fn-7565-mobile-terminal-close-corner.md
deleted file mode 100644
index 57f627a4b1..0000000000
--- a/.changeset/fn-7565-mobile-terminal-close-corner.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": patch
----
-
-summary: Pin the mobile terminal close (X) button to the top-right corner so it is easy to find and tap.
-category: fix
-dev: On the ≤768px terminal, the `terminal-close` button now carries a `terminal-close--corner` class (order:3 + margin-inline-start:auto) so it renders last in flex order and hugs the right edge next to the tab dropdown, instead of falling back to order:0 (far left). Desktop/floating/pinned-below placement inside `.terminal-actions` is unchanged.
diff --git a/.changeset/fn-7567-mobile-terminal-spacing.md b/.changeset/fn-7567-mobile-terminal-spacing.md
deleted file mode 100644
index 1462cca8e4..0000000000
--- a/.changeset/fn-7567-mobile-terminal-spacing.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": patch
----
-
-summary: Fix mobile terminal excess character spacing that survived earlier font-remeasure fixes.
-category: fix
-dev: `TerminalModal`/`SessionTerminal` re-bake xterm's `DomRenderer` letter-spacing compensation AFTER `fitAddon.fit()` settles the post-fit column count (not just before it), since `handleResize()` never re-bakes spacing itself. See `docs/solutions/ui-bugs/xterm-options-noop-remeasure-after-font-settle.md` recurrence #4.
diff --git a/.changeset/fn-7568-fn-cli-release-asset.md b/.changeset/fn-7568-fn-cli-release-asset.md
deleted file mode 100644
index 3ef5b22298..0000000000
--- a/.changeset/fn-7568-fn-cli-release-asset.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": patch
----
-
-summary: Rename downloadable CLI release binaries to the fn-cli-<platform> base name.
-category: internal
-dev: `binaryNameForTarget` in `packages/cli/build.ts` and the `release.yml` / `test-release.yml` matrices now emit `fn-cli-<suffix>`; the local dev binary stays `fn`/`fn.exe`.
diff --git a/.changeset/fn-7569-plan-approval-idempotent.md b/.changeset/fn-7569-plan-approval-idempotent.md
deleted file mode 100644
index 7e50bcf5b3..0000000000
--- a/.changeset/fn-7569-plan-approval-idempotent.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": patch
----
-
-summary: Manual plan approval no longer re-asks you to approve a plan you already approved when it hasn't changed.
-category: fix
-dev: FN-7569 — approving a plan records a fingerprint of the approved PROMPT.md (new nullable Task.approvedPlanFingerprint, migration 139). The manual plan-approval gate skips re-parking at awaiting-approval when a re-specification (replan, plan-review retry, self-healing rebound) produces the same plan; a changed plan or reject-plan still requires fresh approval. Release authorization, Workflow Plan Review, and auto-approve-all are unchanged.
diff --git a/.changeset/fn-7571-intervention-timeline-activity-dropdown.md b/.changeset/fn-7571-intervention-timeline-activity-dropdown.md
deleted file mode 100644
index a3af496a8b..0000000000
--- a/.changeset/fn-7571-intervention-timeline-activity-dropdown.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": patch
----
-
-summary: Move the planner intervention timeline into the task Activity view dropdown.
-category: feature
-dev: Removes the inline `PlannerInterventionTimeline` mount from the FN-7517 oversight cluster in `TaskDetailModal.tsx` and adds a fourth `interventions` `ActivitySegment`, shown in the Activity dropdown only when planner oversight is active for the task; falls back to Live if oversight turns off while Interventions is selected.
diff --git a/.changeset/fn-7574-oauth-expiry-detection-refresh.md b/.changeset/fn-7574-oauth-expiry-detection-refresh.md
deleted file mode 100644
index 1624b75079..0000000000
--- a/.changeset/fn-7574-oauth-expiry-detection-refresh.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": patch
----
-
-summary: Expired Claude subscription logins now show disconnected with a re-login prompt; tokens auto-refresh before expiry.
-category: fix
-dev: Unifies OAuth expiry detection between OAuthExpiryMonitor and /api/auth/status, and adds an engine-side proactive OAuth refresh scheduler wired in project-engine (guarded by skipNotifier). No token material logged.
diff --git a/.changeset/fn-7575-release-version-comment.md b/.changeset/fn-7575-release-version-comment.md
deleted file mode 100644
index e06e707639..0000000000
--- a/.changeset/fn-7575-release-version-comment.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": minor
----
-
-summary: Fusion self-repo issue-close comments now show current and target release versions.
-category: feature
-dev: GitHubIssueCommentService appends "Current version: v{current}" and "Target release: v{next-minor}" lines when the linked source issue is runfusion/fusion; other repos unchanged. Version resolved via getCliPackageVersion.
diff --git a/.changeset/fn-7576-cli-wrapper-subscription-getapikey-delegation.md b/.changeset/fn-7576-cli-wrapper-subscription-getapikey-delegation.md
deleted file mode 100644
index c0cd7d259c..0000000000
--- a/.changeset/fn-7576-cli-wrapper-subscription-getapikey-delegation.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": patch
----
-
-summary: Anthropic subscription reads now refresh the OAuth token automatically instead of silently failing when expired.
-category: fix
-dev: mergeAuthStorageReads getApiKey("anthropic-subscription") now delegates to the underlying engine authStorage.getApiKey (the only refresh-token HTTP round trip) instead of a local static expiry check; regression tests drive the wrapper directly. No token material logged.
diff --git a/.changeset/fn-7577-workspace-pr-revert.md b/.changeset/fn-7577-workspace-pr-revert.md
deleted file mode 100644
index a231551ed5..0000000000
--- a/.changeset/fn-7577-workspace-pr-revert.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": minor
----
-
-summary: Open one revert PR per sub-repo for workspace tasks when autoMerge is disabled.
-category: feature
-dev: `POST /api/tasks/:id/revert` gains an additive workspace `{ mode: "pr", clean: true, workspace: { repos: [{ repo, revertBranch, prUrl, prNumber, existingPr? }] } }` result for clean multi-repo reverts under `autoMerge:false`, extending FN-7554's single-repo `mode:"pr"` path. New engine export `prepareWorkspaceRevertPrBranches` (packages/engine/src/task-revert.ts) classifies every sub-repo first and only prepares a dedicated `fusion/revert-<id>` branch per sub-repo when all are clean/already-reverted (all-or-nothing at the branch-prep phase), never force-writing any sub-repo integration branch. The route resolves owner/repo and checks the rate limiter for every sub-repo before pushing/creating any PR, so GitHub-unconfigured/rate-limited cases degrade the whole task to `needsHuman` rather than opening a partial subset of PRs. Existing `{ mode: "git" | "ai" | "pr", ... }` shapes, the `autoMerge:true` workspace path, and FN-7554's single-repo path are unchanged.
diff --git a/.changeset/fn-7578-ai-undo-workflow-setting-ui.md b/.changeset/fn-7578-ai-undo-workflow-setting-ui.md
deleted file mode 100644
index a57c515d5c..0000000000
--- a/.changeset/fn-7578-ai-undo-workflow-setting-ui.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": minor
----
-
-summary: Add a Settings → General picker to choose the workflow used for AI-undo (revert) tasks.
-category: feature
-dev: Surfaces `aiUndoTaskWorkflowId` (default `builtin:review-heavy`) in GeneralSection; empty selection means "inherit project default workflow", matching the revert route's blank-is-inherit behavior from FN-7556.
diff --git a/.changeset/fn-7579-ask-user-exit-gate-nodes.md b/.changeset/fn-7579-ask-user-exit-gate-nodes.md
deleted file mode 100644
index 66172c6c82..0000000000
--- a/.changeset/fn-7579-ask-user-exit-gate-nodes.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": minor
----
-
-summary: Add "Ask user question" and "Exit gate" workflow nodes for mid-flow chat reach-out and early exit.
-category: feature
-dev: New IR node kinds `ask-user` (reuses await-input park/resume; surfaces the question in the task chat) and `exit-gate` (terminates the workflow early, optional condition). Editor palette + summaries + help updated; `prompt`+`awaitInput` remains a back-compat alias.
diff --git a/.changeset/fn-7579-tracking-dedup-stale-issue.md b/.changeset/fn-7579-tracking-dedup-stale-issue.md
deleted file mode 100644
index 9a3d2d26c8..0000000000
--- a/.changeset/fn-7579-tracking-dedup-stale-issue.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": patch
----
-
-summary: Stop GitHub tracking-issue creation from linking new tasks to old/closed issues.
-category: fix
-dev: github-tracking dedup now only reuses OPEN issues and requires a File-Scope path overlap (keyword-only matches no longer link). Prevents mis-linking a fresh task to a stale/resolved tracking issue (FN-7579). Setting `githubTrackingDedupEnabled` unchanged.
diff --git a/.changeset/fn-7582-oversight-guideline-copy.md b/.changeset/fn-7582-oversight-guideline-copy.md
deleted file mode 100644
index 4041f9f1c4..0000000000
--- a/.changeset/fn-7582-oversight-guideline-copy.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": patch
----
-
-summary: Clarify the oversight "Nudge unavailable" guideline so it no longer reads as an overseer fault.
-category: fix
-dev: TaskDetailModal oversight controls — reworded taskDetail.oversight.nudgeDisabledTitle and added taskDetail.oversight.nudgeSuppressedTitle to differentiate periodic-observation vs. manual-control states. No enablement/engine logic changed.
diff --git a/.changeset/fn-7584-brainstorming-builtin.md b/.changeset/fn-7584-brainstorming-builtin.md
deleted file mode 100644
index 21c73e7257..0000000000
--- a/.changeset/fn-7584-brainstorming-builtin.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": minor
----
-
-summary: Add a built-in "Brainstorming" workflow that talks to you before planning.
-category: feature
-dev: Registers `builtin:brainstorming` (non-default, default-enabled) composing FN-7579's `ask-user` → refine → `exit-gate`-on-approval phase ahead of the normal coding plan/execute/review/merge spine. Parity suite (`builtin-workflows.test.ts`) extended for the new entry.
diff --git a/.changeset/fn-7591-coding-ideas-intake.md b/.changeset/fn-7591-coding-ideas-intake.md
deleted file mode 100644
index 6db08f8a77..0000000000
--- a/.changeset/fn-7591-coding-ideas-intake.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": patch
----
-
-summary: New tasks created under the Coding (Ideas) workflow now land in the Ideas column and wait for you to promote them.
-category: fix
-dev: Dashboard create surfaces (InlineCreateCard, QuickEntryBox, NewTaskModal, insight/todo → task) no longer hard-code column:"triage"; the store now resolves the selected/default workflow's intake column. InlineCreateCard forwards workflowId at create time instead of applying it post-create. Also fixed a glue-layer regression in `useTaskHandlers.ts` (`handleBoardQuickCreate`/`handleModalCreate`) that re-forced column:"triage" even after the UI surfaces stopped sending it.
diff --git a/.changeset/fn-7591-intake-card-disappears.md b/.changeset/fn-7591-intake-card-disappears.md
deleted file mode 100644
index 819f32512c..0000000000
--- a/.changeset/fn-7591-intake-card-disappears.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": patch
----
-
-summary: Fix tasks vanishing from the board after being added to a workflow like Coding (Ideas).
-category: fix
-dev: Board.tsx forces a board-workflows refetch (deferred one tick, signature-guarded) whenever a rendered task is missing from the taskWorkflowIds map, so its real workflow and intake column resolve regardless of which create surface added it; the single-workflow grouping also re-homes a task whose column its workflow no longer declares into the intake lane instead of dropping it. Fixes the FN-7591 regression where intake-column cards (column "ideas") fell back to the default workflow, which has no such column, and were filtered out until a manual reload.
diff --git a/.changeset/fn-7593-before-after-top.md b/.changeset/fn-7593-before-after-top.md
deleted file mode 100644
index 43186a0490..0000000000
--- a/.changeset/fn-7593-before-after-top.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": patch
----
-
-summary: Move the Before → After transformation summary to the top of generated task definitions.
-category: fix
-dev: Reorders the standard and fast triage `PROMPT.md` templates in packages/core/src/agent-prompts.ts so `## Before → After Transformation` is the first content section, ahead of `## Review Level` and `## Mission`, matching FN-7499's glance-verification intent.
diff --git a/.changeset/fn-7597-priority-dropdown-matches-oversight.md b/.changeset/fn-7597-priority-dropdown-matches-oversight.md
deleted file mode 100644
index 4d89e6363c..0000000000
--- a/.changeset/fn-7597-priority-dropdown-matches-oversight.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": patch
----
-
-summary: Task-detail Priority dropdown now matches the Oversight dropdown's size, border, and typography.
-category: fix
-dev: Removed the Priority-only forced select/option uppercase, added a neutral chip background scoped to `.detail-priority-chip.card-priority-badge--normal` for the untinted `normal` level, and reused the FN-7585 shared `--btn-border-width`/`--border`/`--detail-control-border-radius`/`--detail-priority-control-min-height` tokens so both dropdowns render as one control style across desktop and the mobile oversight-overflow surface.
diff --git a/.changeset/fn-7599-planning-column-rename.md b/.changeset/fn-7599-planning-column-rename.md
deleted file mode 100644
index 59cac03411..0000000000
--- a/.changeset/fn-7599-planning-column-rename.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": patch
----
-
-summary: Default workflow boards now label the intake column "Planning" instead of "Triage".
-category: fix
-dev: Renamed the `name` of the `id: "triage"` intake column to "Planning" in builtin-coding, builtin-stepwise-coding, and builtin-pr workflow IRs (column id unchanged; linear built-ins inherit via canonicalBuiltinWorkflowColumns). COLUMN_LABELS.triage was already "Planning".
diff --git a/.changeset/fn-7600-oversight-nudge-detail-snapshot.md b/.changeset/fn-7600-oversight-nudge-detail-snapshot.md
deleted file mode 100644
index 2690189613..0000000000
--- a/.changeset/fn-7600-oversight-nudge-detail-snapshot.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": patch
----
-
-summary: Fix the task-detail Nudge control staying disabled when the overseer is actively watching.
-category: fix
-dev: GET /api/tasks/:id now attaches the transient plannerOverseerState snapshot (mirrors the list route); TaskDetailModal reads the snapshot from workingTask so detail refetches no longer drop it.
diff --git a/.changeset/fn-coding-ideas-workflow.md b/.changeset/fn-coding-ideas-workflow.md
deleted file mode 100644
index 4f8fa8f9e1..0000000000
--- a/.changeset/fn-coding-ideas-workflow.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": minor
----
-
-summary: Add a "Coding (Ideas)" workflow with a manual Ideas intake and a merged Todo planner column.
-category: feature
-dev: New `builtin:coding-ideas` clones the default stepwise pipeline with an `ideas` intake (autoTriage:false) in front of a merged `todo` planner+capacity column. createTask lands cards in the workflow's intake column; the triage service plans unplanned todo tasks in place; the scheduler skips bootstrap-prompt todo tasks; TaskCard gains a Start button and a Ready badge.
diff --git a/.changeset/mission-triage-branch-strategy-and-parked-validation.md b/.changeset/mission-triage-branch-strategy-and-parked-validation.md
deleted file mode 100644
index 0966318fa7..0000000000
--- a/.changeset/mission-triage-branch-strategy-and-parked-validation.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": patch
----
-
-summary: Honor mission branchStrategy when triage omits branchAssignment; skip validation for inactive missions.
-category: fix
-dev: resolveBranchAssignmentContext returns undefined for absent mode so triage falls back to mission.branchStrategy; processTaskOutcome gates on mission.status === "active" like recoverActiveMissions.
diff --git a/.changeset/planner-overseer-no-recover-healthy-tasks.md b/.changeset/planner-overseer-no-recover-healthy-tasks.md
deleted file mode 100644
index 9c96edc1ed..0000000000
--- a/.changeset/planner-overseer-no-recover-healthy-tasks.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": patch
----
-
-summary: Planner overseer no longer marks healthy in-progress tasks as "recovering" or steers them.
-category: fix
-dev: `decidePlannerRecovery` now returns `none` for healthy (`progressing`/`complete`) and `awaiting-human` executor/workflow-gate signals instead of falling through to `inject_guidance`; only `stuck`/`blocked`/`failed` trigger autonomous steering. Also dedupes the `PlannerOverseerMonitor` activity-feed heartbeat so an unchanged `(stage, signal, reason)` observation is logged once per change, not every poll tick. Fixes the "overseer recovering" badge appearing on every autonomous card and the needless AI-consuming guidance injections (FN-7577).
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 18882c459c..60d1b72104 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,60 +2,365 @@
 
 User-facing release notes aggregated across all packages. This file is auto-synced from each `packages/*/CHANGELOG.md` by `scripts/release.mjs` — do not edit by hand.
 
-## 0.55.0
+## 0.56.0
 
 ### New
 
-- Allow configuring permissions for ephemeral and permanent agents.
-- Add a Settings override for the local Cursor CLI binary path.
-- Add GitLab instance URL settings for GitLab.com and self-managed servers.
-- Add GitLab access-token settings for personal, project, and group tokens.
-- Add GitLab project issue, group issue, and merge request imports.
-- Display linked GitLab tracking metadata and stale badges on tasks.
-- Add GitLab comment and auto-close lifecycle actions for linked work items.
-- Add GitLab as a Command Center Signals connector.
-- Add explicit onboarding choices to use, initialize, or clone a git repository.
-- Let chat update existing agents without delete/recreate.
-- Add sidebar rename buttons to direct Chat conversations.
-- Add a bundled Linear import plugin for creating tasks from Linear issues.
-- Add a mandatory Planning Mode deepening checkpoint before final summaries.
-- Add visible create buttons and recursive search to Project Files.
-- Collapse mobile Chat thread controls into one compact header row.
-- Add a GitLab enable toggle and collapsible Settings controls.
+- Add a workflow setting to disable automatic large-task triage splitting.
+- Expand first-run AI provider quick-start choices beyond Anthropic.
+- Show Git prerequisite guidance during first-run GitHub onboarding.
+- Add GitHub OAuth and CLI setup actions to first-run onboarding.
+- Add configurable dashboard keyboard shortcuts for Quick Chat and Terminal.
+- Add search in Settings so operators can find settings faster.
+- Add before-to-after transformation summaries to generated task definitions.
+- Add a pinned below-application layout option for the dashboard terminal.
+- Show first-token and tool processing durations in task agent logs.
+- Settings descriptions now show each setting's default value.
+- Add a Reset Settings button to restore a menu's or all project settings to defaults.
+- Add a per-workflow planner oversight level setting (Off, Observe, Steer, Autonomous recovery).
+- Tasks can override the workflow planner oversight level (Off, Observe, Steer, Autonomous recovery).
+- Planner oversight now defaults to full steering/control for every workflow unless explicitly changed.
+- Planner oversight now monitors tasks across executor, reviewer, merger, pull-request, and workflow-gate stages.
+- Planner oversight can autonomously inject guidance, retry stuck/failed steps, and request fixes within bounded limits.
+- Planner oversight now requires confirmation before merge/PR actions and destructive/external side effects.
+- Planner overseer now stays fully hands-off for paused tasks and auto-merge-off / human-review tasks.
+- Configure planner oversight level per task and per project in the workflow editor and task create/detail.
+- Add a configurable planner-overseer notification verbosity level (Silent/Errors/Important/All).
+- Add a task-detail planner-overseer intervention timeline (stage, reason, action, outcome, attempts, links).
+- Emit planner-overseer run-audit events for observations, steering, retries, recovery, confirmations, and escalations.
+- Add an intelligent git-revert engine service and POST /api/tasks/:id/revert route.
+- Add an AI-undo fallback task when reverting a done task via git conflicts or is unsupported.
+- Add a Revert action to Done/Archived task cards to undo landed changes.
+- Capture a structured performance snapshot when an agent task completes.
+- Task cards can now show the planner overseer's active state (idle/watching/steering/recovering/awaiting-confirmation).
+- Original task prompt now renders as Markdown and is collapsed by default in the task Plan tab.
+- Support reverting multi-repo workspace tasks via git, all-or-nothing across sub-repos.
+- Add per-sha revert commit granularity to the task revert API and service.
+- Add a dedicated Keyboard Shortcuts settings section with click-to-record capture and more configurable actions.
+- Open a revert PR for done/archived tasks when autoMerge is disabled instead of refusing.
+- AI-undo tasks now default to a configurable, stricter review workflow.
+- Plan auto-approval is now the default; specified tasks skip manual approval unless you opt into workflow/require-all.
+- Move the planner intervention timeline into the task Activity view dropdown.
+- Fusion self-repo issue-close comments now show current and target release versions.
+- Open one revert PR per sub-repo for workspace tasks when autoMerge is disabled.
+- Add a Settings → General picker to choose the workflow used for AI-undo (revert) tasks.
+- Add "Ask user question" and "Exit gate" workflow nodes for mid-flow chat reach-out and early exit.
+- Add a built-in "Brainstorming" workflow that talks to you before planning.
+- Add a "Coding (Ideas)" workflow with a manual Ideas intake and a merged Todo planner column.
 
 ### Fixed
 
-- Stop recurring Windows Terminal warning popups during terminal startup.
-- Fix dashboard localStorage quota exhaustion from stale SWR caches and add a Clear local data escape hatch.
-- Fix `fusion desktop` on Windows and published npm installs (Electron dependency, GPU/sandbox flags, dashboard reuse).
-- First-run agent setup no longer errors on a duplicate CEO; desktop Switch-server button now opens the connection menu.
-- Allow operators to delete archived tasks.
-- Show workflow template block boundary connectors in the graph editor.
-- Preserve the selected dashboard project across browser refreshes.
-- Detect Cursor CLI installations that expose Windows cmd or bat shims.
-- Preserve GitLab tracking metadata for CLI and extension imports.
-- Keep Planning Mode Refine Further from getting stuck on duplicate generation.
-- Show task status badges on Documents task groups.
-- Suppress misleading Anthropic Subscription re-login banners when another Anthropic auth method is active.
-- Keep Anthropic authentication cards grouped near the top in Settings.
-- Stop planner model fallback loops with a clear terminal triage error.
-- Recover stale task branch-group references from Task Detail after server restarts.
-- Return GitHub issue import actions to the main issue list.
-- Prevent Planning Mode sessions from failing when MCP resolution returns no shaped result.
-- Fix Android mobile terminal spacing while the keyboard is open.
-- Fix Last 30 days token usage to include every model in Command Center.
-- Include supported chat interactions in Command Center token usage totals.
-- Preserve workflow setting edits made while a values save is still in flight.
-- Preserve migrated workflow settings when project identity is assigned later.
-- Show the bundled Linear Import plugin in Plugin Manager and dashboard plugin surfaces.
-- Fix the mobile Chat header so back navigation and session selection stay on one row.
-- Fix iOS mobile terminal spacing when opening terminals with the keyboard already visible.
-- Default fresh startup and theme reset to System mode.
-- Remember task popup size and position when switching between tasks.
-- Fix iPhone Safari terminal text spacing with the keyboard open.
-- Count planning tasks correctly in the dashboard footer queue metric.
-- Show conversation titles in the mobile Chat dropdown.
-- Merges no longer fail when a task adds a dependency without updating the lockfile.
+- Show active Plan Review progress on triage task cards.
+- Clarify task-detail oversight Nudge/Explain controls: visible label, disabled reason, always-openable Explain panel.
+- Unify border, radius, and height of the task-detail Priority/Execution/Oversight controls.
+- Keep the task-detail Activity view menu open during mobile iOS taps.
+- Fix Anthropic subscription login when pasted callback URLs contain fragment OAuth parameters.
+- Fix Claude/Anthropic subscription re-login showing "Login did not complete" after logging out.
+- Stop self-healing from killing actively-running tasks after ~30 minutes.
+- Stop Windows Terminal version dialogs from popping up when opening the dashboard or Settings on Windows.
+- Select newly created folders automatically during project setup.
+- Prevent Desktop update banners from using 0.0.0 as the current version.
+- Quit Fusion Desktop on Windows when the window is closed.
+- Open desktop Anthropic Subscription OAuth logins in the system browser.
+- Delay GitHub setup warnings for one day and add a dashboard connect action.
+- Fix a false AI engine not running banner in desktop mode.
+- Clarify the desktop Connection Manager add-remote flow.
+- Restore Local Server in the desktop Switch server list.
+- Make right-dock task list clicks respect the task popup setting.
+- Auto-retry retryable Code Review remediation failures.
+- Fix no-op task branch recovery after a previously landed task.
+- Allow documented source-free task-artifact deliveries to finish without commits.
+- Fix direct merges so Push to remote after merge honors the configured remote and branch.
+- Keep task popups on the board layer with Activity menus above them.
+- Keep accepted chat requests waiting instead of showing false first-event timeout failures.
+- Show each task's original prompt in the Plan tab alongside the generated plan.
+- Restore terminal Ctrl/Cmd copy and paste shortcuts.
+- Fix mobile Chat composer being hidden behind the keyboard accessory bar.
+- Auto-approve now reliably sends specified plans to the board without a manual approval stop.
+- Fix the in-dashboard Switch server menu not switching desktop local/remote.
+- Fix branch group completion checklists to show accurate landed/finished counts.
+- Branch groups no longer report complete (or become promotable) when an unlanded member is archived.
+- Fix the global GitLab integration setting not persisting when saved.
+- Fix task-detail Activity view dropdown not opening reliably on mobile.
+- Manual "Run now" for the Database Backup automation now runs in-process like the scheduler, matching cron behavior.
+- Task cards no longer show the "Auto-recovery" oversight badge unless oversight is explicitly configured.
+- Remove the per-card overseer-state ("Executor") badge from task cards.
+- Fix agent-created artifacts not appearing live in the dashboard artifacts view.
+- Fix the mobile terminal shortcut bar so it scrolls horizontally to reach every key.
+- Planner-oversight intervention timeline now populates from real engine activity.
+- Show the "Global" prefix on the Authentication entry in the mobile Settings picker.
+- Tasks held for release authorization or Plan Review are now shown distinctly, so auto-approve no longer looks broken.
+- Move mobile terminal controls into a bottom footer so they no longer crowd the header, with a scrollable shortcut bar.
+- Stop the release-authorization gate from holding tasks that merely disclaim releasing.
+- Fix mobile terminal text still rendering with excess inter-character gaps after font-load settle.
+- Stop Plan Review from looping tasks forever and fix its "can't find the plan" reviews.
+- Planner-overseer task badge now shows a readable label and explains what it is waiting on.
+- Plan approve/reject API now blocks release-authorization holds, requiring the authorization marker first.
+- Pin the mobile terminal close (X) button to the top-right corner so it is easy to find and tap.
+- Fix mobile terminal excess character spacing that survived earlier font-remeasure fixes.
+- Manual plan approval no longer re-asks you to approve a plan you already approved when it hasn't changed.
+- Expired Claude subscription logins now show disconnected with a re-login prompt; tokens auto-refresh before expiry.
+- Anthropic subscription reads now refresh the OAuth token automatically instead of silently failing when expired.
+- Stop GitHub tracking-issue creation from linking new tasks to old/closed issues.
+- Clarify the oversight "Nudge unavailable" guideline so it no longer reads as an overseer fault.
+- New tasks created under the Coding (Ideas) workflow now land in the Ideas column and wait for you to promote them.
+- Fix tasks vanishing from the board after being added to a workflow like Coding (Ideas).
+- Move the Before → After transformation summary to the top of generated task definitions.
+- Task-detail Priority dropdown now matches the Oversight dropdown's size, border, and typography.
+- Default workflow boards now label the intake column "Planning" instead of "Triage".
+- Fix the task-detail Nudge control staying disabled when the overseer is actively watching.
+- Honor mission branchStrategy when triage omits branchAssignment; skip validation for inactive missions.
+- Planner overseer no longer marks healthy in-progress tasks as "recovering" or steers them.
+
+### Breaking
+
+- Remove the eye icon markdown/plain toggle from chat; messages always render as Markdown.
+
+### Internal
+
+- Rename downloadable CLI release binaries to the fn-cli-<platform> base name.
+
+## 0.55.0
+
+### @fusion/dashboard
+
+#### Patch Changes
+
+- @fusion/core@0.55.0
+- @fusion/engine@0.55.0
+- @fusion/i18n@0.39.19
+- @fusion-plugin-examples/cli-printing-press@0.1.36
+- @fusion-plugin-examples/compound-engineering@0.1.19
+- @fusion-plugin-examples/dependency-graph@0.1.50
+- @fusion-plugin-examples/roadmap@0.1.38
+- @fusion-plugin-examples/cursor-runtime@0.1.38
+- @fusion-plugin-examples/droid-runtime@0.1.45
+- @fusion-plugin-examples/hermes-runtime@0.2.69
+- @fusion-plugin-examples/openclaw-runtime@0.2.69
+- @fusion-plugin-examples/paperclip-runtime@0.2.69
+
+### @fusion/desktop
+
+#### Patch Changes
+
+- @fusion/core@0.55.0
+- @fusion/dashboard@0.55.0
+- @fusion/engine@0.55.0
+
+### @fusion/engine
+
+#### Patch Changes
+
+- @fusion/core@0.55.0
+- @fusion/pi-claude-cli@0.55.0
+
+### @fusion/plugin-sdk
+
+#### Patch Changes
+
+- @fusion/core@0.55.0
+
+### @runfusion/fusion
+
+#### Minor Changes
+
+- 8580910: summary: Allow configuring permissions for ephemeral and permanent agents.
+  category: feature
+  dev: Applies capability grants and runtime permission policies consistently across agent lifetimes.
+- 5738766: summary: Add GitLab instance URL settings for GitLab.com and self-managed servers.
+  category: feature
+  dev: Adds typed GitLab web/API URL configuration and dashboard controls for later GitLab integration subtasks.
+- fafe4c9: summary: Add GitLab access-token settings for personal, project, and group tokens.
+  category: feature
+  dev: Documents required GitLab API scopes and adds token auth resolution for later GitLab integration tasks.
+- 865dec2: summary: Add GitLab project issue, group issue, and merge request imports.
+  category: feature
+  dev: Adds HTTP API GitLab import routes, dashboard affordances, CLI commands, and extension tools.
+- 34be333: summary: Add GitLab comment and auto-close lifecycle actions for linked work items.
+  category: feature
+  dev: Uses GitLab REST notes and state-event APIs with configured self-managed instance URLs.
+- 1f6befc: summary: Add GitLab as a Command Center Signals connector.
+  category: feature
+  dev: Adds GitLab webhook token verification and issue/MR signal normalization for Command Center incidents.
+- 91737b1: summary: Add explicit onboarding choices to use, initialize, or clone a git repository.
+  category: feature
+  dev: Setup wizard now sends gitSetupMode while preserving cloneUrl-only project registration clients.
+- 91fb53f: summary: Let chat update existing agents without delete/recreate.
+  category: feature
+  dev: Adds the fn_agent_update Pi extension tool for scoped AgentStore.updateAgent config edits.
+- dfb6e52: summary: Add a bundled Linear import plugin for creating tasks from Linear issues.
+  category: feature
+  dev: Ships fusion-plugin-linear-import with plugin settings, routes, tools, dashboard view, and bundled-plugin packaging.
+- ec0256f: summary: Add a mandatory Planning Mode deepening checkpoint before final summaries.
+  category: feature
+  dev: Planning sessions now persist pending summaries behind a "Would you like to go deeper?" checkpoint.
+- 5984f32: summary: Add visible create buttons and recursive search to Project Files.
+  category: feature
+  dev: Files — Project uses the existing workspace-safe create and /files/search APIs with settings pickers left compact.
+- f973334: summary: Add a GitLab enable toggle and collapsible Settings controls.
+  category: feature
+  dev: Adds gitlabEnabled gating for GitLab API operations while preserving saved configuration.
+
+#### Patch Changes
+
+- 306e516: summary: Stop recurring Windows Terminal warning popups during terminal startup.
+  category: fix
+  dev: Keeps embedded terminal bootstrap on supported shells and surfaces actionable inline errors.
+- 9df13c7: summary: Fix dashboard localStorage quota exhaustion from stale SWR caches and add a Clear local data escape hatch.
+  category: fix
+  dev: Stale SWR hydration entries (per-chat-session/per-room message caches) were never garbage-collected; readCache now lazily deletes stale entries, a boot sweep prunes anything older than 24h, and Settings → General exposes a user-facing "Clear local data" button that preserves the auth token.
+- c7641f9: summary: Fix `fusion desktop` on Windows and published npm installs (Electron dependency, GPU/sandbox flags, dashboard reuse).
+  category: fix
+  dev: `packages/cli/package.json` now depends on `electron` at runtime; previously the desktop launcher called `require("electron")`, which is only available inside the source checkout (via `pnpm-workspace.yaml` `onlyBuiltDependencies`) and is missing for npm consumers, causing `fusion desktop` to hang or fail silently. The launcher now applies GPU/sandbox-disabling Electron flags only on Windows (`os.platform() === "win32"`), keeps hardware acceleration and the Chromium sandbox on macOS/Linux, exports `FUSION_SERVER_PORT` so the desktop reuses the CLI-started dashboard instead of double-binding ports, and isolates desktop user-data under `~/.fusion/desktop-user-data`. Relocating the profile performs a one-time copy of the previous default Electron profile (`user-data-migration.ts`) so upgrading operators keep window geometry/session. `packages/desktop/scripts/build.ts` now fails the build if `main.js`/`preload.js`/`client/index.html` are missing from `dist/` or the staged `deploy/dist/`, preventing shipping an incomplete `app.asar`.
+- da662c4: summary: First-run agent setup no longer errors on a duplicate CEO; desktop Switch-server button now opens the connection menu.
+  category: fix
+  dev: Onboarding agent creation (ModelOnboardingModal + SetupWizardModal) treats a 409 "Agent with this name already exists" as success and advances, since the default CEO can be created from more than one first-run surface. The desktop preload now bridges the `shell:open-connection-manager` IPC (sent by main when the header Switch-server button is clicked) into the `window` DOM event ShellContext listens for, so NativeShellConnectionManager (Local/Remote toggle + remote profiles) actually opens.
+- 377eee6: summary: Allow operators to delete archived tasks.
+  category: fix
+  dev: Extends task deletion to archive-db snapshots while preserving soft-delete tombstones and ID reservation.
+- 9ee33f9: summary: Show workflow template block boundary connectors in the graph editor.
+  category: fix
+  dev: Adds visual-only foreach/loop/optional-group template boundary edges that are filtered from persisted IR.
+- 3453d16: summary: Preserve the selected dashboard project across browser refreshes.
+  category: fix
+  dev: Project selection now updates and hydrates from the existing `?project=` dashboard URL contract.
+- 777f647: summary: Detect Cursor CLI installations that expose Windows cmd or bat shims.
+  category: fix
+  dev: Cursor runtime probes and model discovery now shell-spawn only on Windows and preserve spawn diagnostics.
+- abb1917: summary: Add a Settings override for the local Cursor CLI binary path.
+  category: feature
+  dev: Adds global `cursorCliBinaryPath` and threads it through Cursor CLI probes, auth status, enable validation, and model discovery.
+- b8e126e: summary: Display linked GitLab tracking metadata and stale badges on tasks.
+  category: feature
+  dev: Persists GitLab tracking metadata separately from GitHub tracking fields.
+- c49a933: summary: Preserve GitLab tracking metadata for CLI and extension imports.
+  category: fix
+  dev: GitLab project, group, and merge-request imports now carry gitlabTracking metadata alongside sourceIssue provenance.
+- 53d5bb1: summary: Keep Planning Mode Refine Further from getting stuck on duplicate generation.
+  category: fix
+  dev: Guards completed-summary refinement as a single-flight UI turn and preserves the active planning stream on same-refine in-progress responses.
+- b493a1e: summary: Show task status badges on Documents task groups.
+  category: fix
+  dev: DocumentsView now renders taskColumn metadata in task document group headers and covers collapsed done/non-done states.
+- e5be924: summary: Suppress misleading Anthropic Subscription re-login banners when another Anthropic auth method is active.
+  category: fix
+  dev: Keeps subscription OAuth expired in Settings while hiding only the global urgent banner entry when API key or Claude CLI auth is active.
+- 326c72b: summary: Keep Anthropic authentication cards grouped near the top in Settings.
+  category: fix
+  dev: Sorts Claude CLI, Anthropic Subscription, and Anthropic API Key before other auth cards within each auth group.
+- 1d6bb08: summary: Stop planner model fallback loops with a clear terminal triage error.
+  category: fix
+  dev: Bounds prompt-time/session-creation model fallback exhaustion and persists failed triage state.
+- aa8f1f3: summary: Recover stale task branch-group references from Task Detail after server restarts.
+  category: fix
+  dev: Adds branch_group restart regression coverage and non-origin integration-branch diagnostics.
+- 72adb52: summary: Add sidebar rename buttons to direct Chat conversations.
+  category: feature
+  dev: Reuses ChatView's existing rename dialog and useChat renameSession path.
+- 25fecd7: summary: Return GitHub issue import actions to the main issue list.
+  category: fix
+  dev: Updates Import Tasks issue import/close navigation and regression coverage.
+- ffcb54b: summary: Prevent Planning Mode sessions from failing when MCP resolution returns no shaped result.
+  category: fix
+  dev: Dashboard planning lanes now default malformed MCP resolver output to an empty server set while preserving MCP forwarding.
+- 8d7abb8: summary: Fix Android mobile terminal spacing while the keyboard is open.
+  category: fix
+  dev: Terminal mobile sizing now tracks visualViewport width for keyboard-open xterm fits.
+- 22fd0da: summary: Fix Last 30 days token usage to include every model in Command Center.
+  category: fix
+  dev: Corrects Command Center token analytics range attribution for durable multi-model task usage.
+- 765218f: summary: Include supported chat interactions in Command Center token usage totals.
+  category: fix
+  dev: Records chat-session and room-responder token usage separately from task execution tokens and aggregates both sources in token analytics.
+- 1d6011c: summary: Collapse mobile Chat thread controls into one compact header row.
+  category: feature
+  dev: Mobile direct-chat moves back/session controls into ViewHeader and floats the Markdown/plain toggle.
+- 2050323: summary: Preserve workflow setting edits made while a values save is still in flight.
+  category: fix
+  dev: WorkflowSettingsPanel and Project Models workflow lane saves now clear only snapshot-matching pending keys.
+- 3fac409: summary: Preserve migrated workflow settings when project identity is assigned later.
+  category: fix
+  dev: Backfills rootDir-keyed workflow_settings rows into the durable project identity row, keeping identity values on conflicts.
+- 78ebeaf: summary: Show the bundled Linear Import plugin in Plugin Manager and dashboard plugin surfaces.
+  category: fix
+  dev: Keeps fusion-plugin-linear-import registered across the built-in Plugin Manager catalog while reusing existing registry, dashboard view, and bundled packaging paths.
+- 1430a42: summary: Fix the mobile Chat header so back navigation and session selection stay on one row.
+  category: fix
+  dev: Keeps the direct-chat mobile header collapsed while preserving desktop and room-chat layouts.
+- 7a4b0bf: summary: Fix iOS mobile terminal spacing when opening terminals with the keyboard already visible.
+  category: fix
+  dev: Seeds iOS keyboard-open viewport baselines for TerminalModal and SessionTerminal before xterm fit/resize.
+- 00afb22: summary: Default fresh startup and theme reset to System mode.
+  category: fix
+  dev: Fresh global settings, pre-hydration scripts, and Appearance reset now keep Shadcn Ember while following OS light/dark preference.
+- 9532520: summary: Remember task popup size and position when switching between tasks.
+  category: fix
+  dev: Task-detail FloatingWindow instances share the `floating-window:task-detail` geometry key.
+- 7300bf5: summary: Fix iPhone Safari terminal text spacing with the keyboard open.
+  category: fix
+  dev: Disables WebKit text-size adjustment inside dashboard xterm measurement subtrees.
+- 30a11ac: summary: Count planning tasks correctly in the dashboard footer queue metric.
+  category: fix
+  dev: Footer counter tests now cover queued, running, stuck, blocked, review, overlap, background AI, and Done absence.
+- d9ef514: summary: Show conversation titles in the mobile Chat dropdown.
+  category: fix
+  dev: Keeps the provider logo while removing model-name text from the mobile direct-chat trigger.
+- e4349ee: summary: Merges no longer fail when a task adds a dependency without updating the lockfile.
+  category: fix
+  dev: In merge-dependency-sync.ts, an inferred frozen install (pnpm/yarn/bun) that fails with an outdated-lockfile error now retries once non-frozen (pnpm gets explicit --no-frozen-lockfile) to regenerate the lockfile in the clean-room worktree, recomputing the install marker. Configured worktreeInitCommand keeps its authoritative frozen intent and still hard-fails. Surfaced via the merge:ai-deps-sync run-audit event (healed/healedCommand).
+
+### runfusion.ai
+
+#### Patch Changes
+
+- Updated dependencies [306e516]
+- Updated dependencies [9df13c7]
+- Updated dependencies [c7641f9]
+- Updated dependencies [da662c4]
+- Updated dependencies [377eee6]
+- Updated dependencies [9ee33f9]
+- Updated dependencies [8580910]
+- Updated dependencies [3453d16]
+- Updated dependencies [777f647]
+- Updated dependencies [abb1917]
+- Updated dependencies [5738766]
+- Updated dependencies [fafe4c9]
+- Updated dependencies [865dec2]
+- Updated dependencies [b8e126e]
+- Updated dependencies [34be333]
+- Updated dependencies [1f6befc]
+- Updated dependencies [c49a933]
+- Updated dependencies [53d5bb1]
+- Updated dependencies [91737b1]
+- Updated dependencies [b493a1e]
+- Updated dependencies [e5be924]
+- Updated dependencies [326c72b]
+- Updated dependencies [1d6bb08]
+- Updated dependencies [aa8f1f3]
+- Updated dependencies [91fb53f]
+- Updated dependencies [72adb52]
+- Updated dependencies [25fecd7]
+- Updated dependencies [dfb6e52]
+- Updated dependencies [ec0256f]
+- Updated dependencies [5984f32]
+- Updated dependencies [ffcb54b]
+- Updated dependencies [8d7abb8]
+- Updated dependencies [22fd0da]
+- Updated dependencies [765218f]
+- Updated dependencies [1d6011c]
+- Updated dependencies [2050323]
+- Updated dependencies [3fac409]
+- Updated dependencies [f973334]
+- Updated dependencies [78ebeaf]
+- Updated dependencies [1430a42]
+- Updated dependencies [7a4b0bf]
+- Updated dependencies [00afb22]
+- Updated dependencies [9532520]
+- Updated dependencies [7300bf5]
+- Updated dependencies [30a11ac]
+- Updated dependencies [d9ef514]
+- Updated dependencies [e4349ee]
+  - @runfusion/fusion@0.55.0
 
 ## 0.54.0
 
@@ -12122,6 +12427,14 @@ for reference.
 - Updated dependencies [a2ed6d0]
   - @runfusion/fusion@0.1.0
 
+## 0.39.20
+
+### @fusion/i18n
+
+#### Patch Changes
+
+- @fusion/core@0.56.0
+
 ## 0.39.19
 
 ### @fusion/i18n
@@ -12276,6 +12589,14 @@ for reference.
 
 - @fusion/core@0.40.0
 
+## 0.11.46
+
+### @fusion/droid-cli
+
+#### Patch Changes
+
+- @fusion-plugin-examples/droid-runtime@0.1.46
+
 ## 0.11.45
 
 ### @fusion/droid-cli
diff --git a/package.json b/package.json
index 35dcd38c79..dd01cdf9c9 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "fusion-workspace",
-  "version": "0.55.0",
+  "version": "0.56.0",
   "private": true,
   "license": "MIT",
   "homepage": "https://github.com/Runfusion/Fusion#readme",
diff --git a/packages/cli-alias/CHANGELOG.md b/packages/cli-alias/CHANGELOG.md
index f0deb8a7cb..cbcb5126d8 100644
--- a/packages/cli-alias/CHANGELOG.md
+++ b/packages/cli-alias/CHANGELOG.md
@@ -1,5 +1,115 @@
 # runfusion.ai
 
+## 0.56.0
+
+### Patch Changes
+
+- Updated dependencies [8668a05]
+- Updated dependencies [978cdda]
+- Updated dependencies [635fca2]
+- Updated dependencies [3d55102]
+- Updated dependencies [0f1cd0a]
+- Updated dependencies [b42ba9f]
+- Updated dependencies [a7559b0]
+- Updated dependencies [4b530a6]
+- Updated dependencies [a5ac3c3]
+- Updated dependencies [8912399]
+- Updated dependencies [d16c8b4]
+- Updated dependencies [b800f7d]
+- Updated dependencies [315f3bc]
+- Updated dependencies [9dc248e]
+- Updated dependencies [52dbc0e]
+- Updated dependencies [ced783e]
+- Updated dependencies [50cdab1]
+- Updated dependencies [50786f2]
+- Updated dependencies [b4b1f6d]
+- Updated dependencies [e8b7362]
+- Updated dependencies [0900a38]
+- Updated dependencies [a2b09f2]
+- Updated dependencies [0f05156]
+- Updated dependencies [20184ac]
+- Updated dependencies [82493e0]
+- Updated dependencies [5689346]
+- Updated dependencies [b42be87]
+- Updated dependencies [2f23d22]
+- Updated dependencies [efa8105]
+- Updated dependencies [61c8bdc]
+- Updated dependencies [e8dc2ae]
+- Updated dependencies [d2e3134]
+- Updated dependencies [b0208c1]
+- Updated dependencies [7d8a1b8]
+- Updated dependencies [2797803]
+- Updated dependencies [a2d6349]
+- Updated dependencies [4baa4c4]
+- Updated dependencies [87a700c]
+- Updated dependencies [68f5153]
+- Updated dependencies [aa757bc]
+- Updated dependencies [0689250]
+- Updated dependencies [12a6d1b]
+- Updated dependencies [81f2053]
+- Updated dependencies [2cc84b5]
+- Updated dependencies [79ab367]
+- Updated dependencies [c16cc9e]
+- Updated dependencies [aae603b]
+- Updated dependencies [d10ea9a]
+- Updated dependencies [bf68839]
+- Updated dependencies [53d7b7e]
+- Updated dependencies [c4d81fe]
+- Updated dependencies [e7cb2f1]
+- Updated dependencies [4707eb5]
+- Updated dependencies [3b52a4d]
+- Updated dependencies [5ad8ec8]
+- Updated dependencies [726cbf8]
+- Updated dependencies [36bd74e]
+- Updated dependencies [df0be88]
+- Updated dependencies [ec9ac61]
+- Updated dependencies [8d36b99]
+- Updated dependencies [ad744aa]
+- Updated dependencies [5c3d58a]
+- Updated dependencies [b4be515]
+- Updated dependencies [62ddb19]
+- Updated dependencies [883c73e]
+- Updated dependencies [2ed06f9]
+- Updated dependencies [8c6f76c]
+- Updated dependencies [d09b57f]
+- Updated dependencies [3d58260]
+- Updated dependencies [052a277]
+- Updated dependencies [f992e6a]
+- Updated dependencies [2df6c35]
+- Updated dependencies [94e9d15]
+- Updated dependencies [3dd227b]
+- Updated dependencies [6e4c207]
+- Updated dependencies [6d364fc]
+- Updated dependencies [b471aec]
+- Updated dependencies [9d4a45b]
+- Updated dependencies [72b77bf]
+- Updated dependencies [c08498e]
+- Updated dependencies [24b27e8]
+- Updated dependencies [fb45157]
+- Updated dependencies [7c0be53]
+- Updated dependencies [71dfd3a]
+- Updated dependencies [9592e3a]
+- Updated dependencies [c31f9ef]
+- Updated dependencies [ce9df29]
+- Updated dependencies [78d4db9]
+- Updated dependencies [196abb5]
+- Updated dependencies [7435849]
+- Updated dependencies [73b38ba]
+- Updated dependencies [42bbe58]
+- Updated dependencies [45e5a26]
+- Updated dependencies [a1a6b09]
+- Updated dependencies [53fe0d7]
+- Updated dependencies [cf3fe8b]
+- Updated dependencies [8b4e522]
+- Updated dependencies [f30d55f]
+- Updated dependencies [20379e8]
+- Updated dependencies [e0f3d3d]
+- Updated dependencies [5b193d2]
+- Updated dependencies [ecbbb29]
+- Updated dependencies [546ef16]
+- Updated dependencies [b173f76]
+  - @runfusion/fusion@0.56.0
+
 ## 0.55.0
 
 ### Patch Changes
diff --git a/packages/cli-alias/package.json b/packages/cli-alias/package.json
index 4188db1797..214ec777c8 100644
--- a/packages/cli-alias/package.json
+++ b/packages/cli-alias/package.json
@@ -1,6 +1,6 @@
 {
   "name": "runfusion.ai",
-  "version": "0.55.0",
+  "version": "0.56.0",
   "license": "MIT",
   "description": "Launch Fusion with `npx runfusion.ai` — tiny alias for @runfusion/fusion.",
   "homepage": "https://runfusion.ai",
diff --git a/packages/cli/CHANGELOG.md b/packages/cli/CHANGELOG.md
index a6f808e15e..7f2d684887 100644
--- a/packages/cli/CHANGELOG.md
+++ b/packages/cli/CHANGELOG.md
@@ -1,5 +1,325 @@
 # @runfusion/fusion
 
+## 0.56.0
+
+### Minor Changes
+
+- d16c8b4: summary: Expand first-run AI provider quick-start choices beyond Anthropic.
+  category: feature
+  dev: Moves advanced/all-provider onboarding controls under the quick-start provider section.
+- 315f3bc: summary: Show Git prerequisite guidance during first-run GitHub onboarding.
+  category: feature
+  dev: Adds bounded server-host git availability to auth status and onboarding.
+- 50cdab1: summary: Add GitHub OAuth and CLI setup actions to first-run onboarding.
+  category: feature
+  dev: GitHub onboarding now shows in-flow OAuth connect, gh auth login, and gh install guidance.
+- 2f23d22: summary: Add configurable dashboard keyboard shortcuts for Quick Chat and Terminal.
+  category: feature
+  dev: Global dashboardKeyboardShortcuts settings, guarded document-level key handling, and Escape topmost-popup dismissal.
+- efa8105: summary: Add search in Settings so operators can find settings faster.
+  category: feature
+  dev: Dashboard Settings filters visible sections by setting labels and keywords.
+- 7d8a1b8: summary: Add a pinned below-application layout option for the dashboard terminal.
+  category: feature
+  dev: Terminal display mode now supports persisted docked, floating, and below layouts, with header controls replacing the footer shell.
+- 87a700c: summary: Add a Reset Settings button to restore a menu's or all project settings to defaults.
+  category: feature
+  dev: New tested section→keys (scope-aware) registry (packages/dashboard/app/components/settings/section-keys.ts) drives per-menu reset via updateSettings/updateGlobalSettings with null-as-delete; non-blob sections (secrets, MCP, plugins, memory, auth, prompts, CLI agents, runtimes) are excluded with a documented reason.
+- 68f5153: summary: Add a per-workflow planner oversight level setting (Off, Observe, Steer, Autonomous recovery).
+  category: feature
+  dev: New workflow setting `plannerOversightLevel` declared in BUILTIN_OVERSIGHT_SETTINGS; default `autonomous`. Per-task override and engine behavior land in follow-up tasks.
+- aa757bc: summary: Tasks can override the workflow planner oversight level (Off, Observe, Steer, Autonomous recovery).
+  category: feature
+  dev: New nullable Task.plannerOversightLevel field (migration 137, SCHEMA_VERSION 137) mirroring executionMode; NULL inherits the workflow setting. Adds resolveEffectivePlannerOversightLevel precedence helper. Dashboard UI/API threading and engine behavior land in follow-up tasks.
+- 0689250: summary: Planner oversight now defaults to full steering/control for every workflow unless explicitly changed.
+  category: feature
+  dev: Confirms the `plannerOversightLevel` workflow-setting default is the highest (autonomous) level; unset workflow value and unset per-task override both resolve to full steering via `resolveEffectivePlannerOversightLevel` (task override → workflow effective value → autonomous), adding dedicated regression coverage for the "unless explicitly disabled" precedence.
+- 12a6d1b: summary: Planner oversight now monitors tasks across executor, reviewer, merger, pull-request, and workflow-gate stages.
+  category: feature
+  dev: Adds records-only PlannerOverseerMonitor + resolveWatchedStage + OverseerStageObservation in @fusion/engine, gated by resolveEffectivePlannerOversightLevel (off = no observation) and wired into ProjectEngine via a bounded poll. Steering/recovery and UI land in FN-7512/FN-7515+.
+- 81f2053: summary: Planner oversight can autonomously inject guidance, retry stuck/failed steps, and request fixes within bounded limits.
+  category: feature
+  dev: Adds pure `decidePlannerRecovery` + recovery types (core) and `PlannerRecoveryController` with injected guidance/retry/targeted-fix handlers (engine), consuming the FN-7511 observation. Acts only at effective level `autonomous`, caps attempts per (task, stage) via `PLANNER_RECOVERY_MAX_ATTEMPTS`, skips user-paused tasks, and excludes merge/PR/destructive actions (deferred to FN-7513) and comprehensive human-control safeguards (FN-7514).
+- 2cc84b5: summary: Planner oversight now requires confirmation before merge/PR actions and destructive/external side effects.
+  category: feature
+  dev: Adds `PlannerActionSideEffectClass` + `PlannerConfirmationRequest` and `classifyPlannerActionSideEffect`/`requiresPlannerConfirmation` (core), extends `decidePlannerRecovery` with an `await_confirmation` action, and adds `requestConfirmation`/`resolveConfirmation` gating to `PlannerRecoveryController` (engine). Merge/PR and destructive/external actions never execute without a recorded approval; bounded recovery (guidance/retry/targeted-fix) is unchanged. UX rendering, human-control safeguards, timeline, and run-audit land in follow-up tasks.
+- 79ab367: summary: Planner overseer now stays fully hands-off for paused tasks and auto-merge-off / human-review tasks.
+  category: feature
+  dev: Adds the pure `evaluateOverseerHumanControl` policy (packages/engine/src/overseer-human-control-policy.ts), consulted at the top of `PlannerRecoveryController.tick()` before any action classification, confirmation gating, steering, retry, or dispatch — so a user-paused or `autoMerge:false`/human-review task never even records a pending confirmation. Reuses `allowsAutoMergeProcessing` from `@fusion/core` verbatim (never re-derives the auto-merge/human-review predicate). Distinguishes explicit user pause (`task.userPaused===true`, or `task.paused===true` with no `pausedReason`) from engine/self-healing parks (which always stamp a `pausedReason`). Emits a bounded `overseer:oversight-withheld-human-control` run-audit no-action event (metadata: `{ taskId, reason, stage, oversightLevel }`), deduped per (taskId, reason) so it does not spam every poll.
+- c16cc9e: summary: Configure planner oversight level per task and per project in the workflow editor and task create/detail.
+  category: feature
+  dev: Per-task `plannerOversightLevel` override exposed via TaskForm (Inherit/off/observe/steer/autonomous), threaded through createTask/updateTask; workflow-editor Values tab gets a first-class display entry. Workflow-native setting; not a project setting.
+- aae603b: summary: Add a configurable planner-overseer notification verbosity level (Silent/Errors/Important/All).
+  category: feature
+  dev: New workflow-native enum setting `plannerOversightNotificationLevel` in BUILTIN_OVERSIGHT_SETTINGS; default `important`. Resolves via resolveEffectiveSettings; emission gating that reads it lands in FN-7519/FN-7520.
+- d10ea9a: summary: Add a task-detail planner-overseer intervention timeline (stage, reason, action, outcome, attempts, links).
+  category: feature
+  dev: New core `PlannerInterventionEntry` model + `recordPlannerIntervention`/`getPlannerInterventionTimeline` helpers persisting via the run-audit store under the `overseer:intervention` mutation, plus a `PlannerInterventionTimeline` component rendered in the task-detail Planner Oversight cluster. Emission call-sites land in FN-7520.
+- bf68839: summary: Emit planner-overseer run-audit events for observations, steering, retries, recovery, confirmations, and escalations.
+  category: feature
+  dev: New core emitters (emitOverseerObservation/Steering/RecoveryAttempt/Retry/Confirmation/Escalation) in planner-overseer-events.ts, each mapping its decision-point to the correct intervention action/outcome and delegating to FN-7519's recordPlannerIntervention under the overseer:intervention mutation. Producer call-sites land in FN-7511/FN-7512/FN-7513.
+- c4d81fe: summary: Add an AI-undo fallback task when reverting a done task via git conflicts or is unsupported.
+  category: feature
+  dev: `POST /api/tasks/:id/revert` now accepts `{ mode?: "git" | "ai" | "auto" }` (default `"auto"`). `"auto"` tries the FN-7523 git-revert path first and falls back to creating an AI-undo board task (`{ mode: "ai", createdTaskId, alreadyOpen? }`) on a conflicting or unsupported (e.g. workspace) git result; `needsHuman` (autoMerge-off) never triggers the fallback. `"ai"` always creates the AI-undo task; `"git"` keeps the FN-7523 git-only contract, which is otherwise unchanged. New engine exports: `createAiUndoTask`, `buildAiUndoTaskDescription`, `REVERT_OF_METADATA_KEY`. New core store method `TaskStore.findOpenRevertTaskForSource` backs the idempotency guard (an open undo task suppresses a duplicate; a closed one does not).
+- e7cb2f1: summary: Add a Revert action to Done/Archived task cards to undo landed changes.
+  category: feature
+  dev: Wires onRevertTask through Board/List/Detail surfaces; calls POST /tasks/:id/revert in "auto" mode with a conflict-confirm AI-undo fallback (mode: "ai").
+- 5ad8ec8: summary: Capture a structured performance snapshot when an agent task completes.
+  category: feature
+  dev: New AgentReflectionService.captureTaskPerformance persists a non-LLM post-task ReflectionMetrics record (duration, packages/files touched, verification command + scope, retry/rework count) and emits ids/counts-only `reflection:captured` run-audit telemetry; populates performanceSummary/latestReflection.
+- 726cbf8: summary: Task cards can now show the planner overseer's active state (idle/watching/steering/recovering/awaiting-confirmation).
+  category: feature
+  dev: Adds a serializable `PlannerOverseerRuntimeSnapshot` + pure `derivePlannerOverseerState` (core), a read-only `ProjectEngine.getPlannerOverseerRuntimeSnapshot(taskId)` accessor assembling it from the FN-7511 monitor + FN-7512/7513 recovery controller, and a best-effort additive `plannerOverseerState` enrichment on `GET /api/tasks` (mirrors the `branchProgress` pattern; never persisted, never fails the board load). Consumed by FN-7516's TaskCard.
+- 2ed06f9: summary: Support reverting multi-repo workspace tasks via git, all-or-nothing across sub-repos.
+  category: feature
+  dev: Extends `packages/engine/src/task-revert.ts` with `resolveWorkspaceTaskRevertCommits`/`revertWorkspaceTask` and wires `POST /api/tasks/:id/revert` to dispatch workspace tasks (`isWorkspaceTask`) to the new path; returns `{ mode: "git", clean, workspace: { repos: [...] }, conflicts? }`. Single-repo `performTaskRevert` path is unchanged.
+- 8c6f76c: summary: Add per-sha revert commit granularity to the task revert API and service.
+  category: feature
+  dev: `performTaskRevert` and `POST /api/tasks/:id/revert` accept an optional `granularity: "squash" | "per-sha"` (default `"squash"`, unchanged FN-7523 behavior). `"per-sha"` creates one attributed `revert(FN-xxxx)` commit per original sha (each with its own `Fusion-Task-Id` trailer and audit line), skipping no-op shas without empty commits. A mid-batch conflict in either mode rolls back the whole batch to the pre-call HEAD — no partially-landed per-sha commits. The clean result now reports `revertCommitShas: string[]` (all created commits) alongside the existing `revertCommitSha` (kept for backward compatibility).
+- f992e6a: summary: Add a dedicated Keyboard Shortcuts settings section with click-to-record capture and more configurable actions.
+  category: feature
+  dev: Relocates dashboardKeyboardShortcuts into its own settings section, adds a ShortcutCaptureInput recorder, and extends DashboardShortcutAction with openFiles/openSettings/openCommandCenter/newTask actions wired into existing App nav handlers.
+- 2df6c35: summary: Open a revert PR for done/archived tasks when autoMerge is disabled instead of refusing.
+  category: feature
+  dev: `POST /api/tasks/:id/revert` gains an additive `{ mode: "pr", clean: true, prUrl, prNumber, revertBranch, existingPr? }` result for clean single-repo reverts under `autoMerge:false`, reusing `GitHubClient.createPr`, `findPrForBranch` idempotency, and the `manual:true` PR handoff. New engine export `prepareRevertPrBranch` (packages/engine/src/task-revert.ts) prepares the dedicated `fusion/revert-<id>` branch without ever mutating the base branch. Existing `{ mode: "git" | "ai", ... }` shapes and the `autoMerge:true` path are unchanged.
+- 94e9d15: summary: AI-undo tasks now default to a configurable, stricter review workflow.
+  category: feature
+  dev: New project setting `aiUndoTaskWorkflowId` (default `builtin:review-heavy`) selects the workflow for AI-undo board tasks created by `POST /api/tasks/:id/revert` (`mode: "ai"`, the `auto` conflict fallback, and the workspace conflict fallback all share the `createAiUndoResult()` closure, so all three inherit this default). A blank/unset value means the created task inherits the project default workflow (pre-FN-7556 behavior). The route validates the configured id via `getWorkflowDefinition`/`isBuiltinWorkflowId` and falls back to inherit (with a logged warning) on a blank or unknown value, so a misconfigured id never breaks AI-undo task creation. The engine's `createAiUndoTask` helper stays pure — it only forwards a `workflowId` it is given, never resolves the setting itself. The Settings Modal UI field for this setting is a deliberate follow-up task; the value is settable today only via the settings API.
+- 3dd227b: summary: Plan auto-approval is now the default; specified tasks skip manual approval unless you opt into workflow/require-all.
+  category: feature
+  dev: `DEFAULT_PROJECT_SETTINGS.planApprovalMode` flips `workflow` → `auto-approve-all`; existing projects with an explicit stored value are unchanged; consumed by `resolvePlanApprovalRequired` at the triage gating sites.
+- 78d4db9: summary: Fusion self-repo issue-close comments now show current and target release versions.
+  category: feature
+  dev: GitHubIssueCommentService appends "Current version: v{current}" and "Target release: v{next-minor}" lines when the linked source issue is runfusion/fusion; other repos unchanged. Version resolved via getCliPackageVersion.
+- 7435849: summary: Open one revert PR per sub-repo for workspace tasks when autoMerge is disabled.
+  category: feature
+  dev: `POST /api/tasks/:id/revert` gains an additive workspace `{ mode: "pr", clean: true, workspace: { repos: [{ repo, revertBranch, prUrl, prNumber, existingPr? }] } }` result for clean multi-repo reverts under `autoMerge:false`, extending FN-7554's single-repo `mode:"pr"` path. New engine export `prepareWorkspaceRevertPrBranches` (packages/engine/src/task-revert.ts) classifies every sub-repo first and only prepares a dedicated `fusion/revert-<id>` branch per sub-repo when all are clean/already-reverted (all-or-nothing at the branch-prep phase), never force-writing any sub-repo integration branch. The route resolves owner/repo and checks the rate limiter for every sub-repo before pushing/creating any PR, so GitHub-unconfigured/rate-limited cases degrade the whole task to `needsHuman` rather than opening a partial subset of PRs. Existing `{ mode: "git" | "ai" | "pr", ... }` shapes, the `autoMerge:true` workspace path, and FN-7554's single-repo path are unchanged.
+- 73b38ba: summary: Add a Settings → General picker to choose the workflow used for AI-undo (revert) tasks.
+  category: feature
+  dev: Surfaces `aiUndoTaskWorkflowId` (default `builtin:review-heavy`) in GeneralSection; empty selection means "inherit project default workflow", matching the revert route's blank-is-inherit behavior from FN-7556.
+- 42bbe58: summary: Add "Ask user question" and "Exit gate" workflow nodes for mid-flow chat reach-out and early exit.
+  category: feature
+  dev: New IR node kinds `ask-user` (reuses await-input park/resume; surfaces the question in the task chat) and `exit-gate` (terminates the workflow early, optional condition). Editor palette + summaries + help updated; `prompt`+`awaitInput` remains a back-compat alias.
+- 53fe0d7: summary: Add a built-in "Brainstorming" workflow that talks to you before planning.
+  category: feature
+  dev: Registers `builtin:brainstorming` (non-default, default-enabled) composing FN-7579's `ask-user` → refine → `exit-gate`-on-approval phase ahead of the normal coding plan/execute/review/merge spine. Parity suite (`builtin-workflows.test.ts`) extended for the new entry.
+- ecbbb29: summary: Add a "Coding (Ideas)" workflow with a manual Ideas intake and a merged Todo planner column.
+  category: feature
+  dev: New `builtin:coding-ideas` clones the default stepwise pipeline with an `ideas` intake (autoTriage:false) in front of a merged `todo` planner+capacity column. createTask lands cards in the workflow's intake column; the triage service plans unplanned todo tasks in place; the scheduler skips bootstrap-prompt todo tasks; TaskCard gains a Start button and a Ready badge.
+
+### Patch Changes
+
+- 8668a05: summary: Add a workflow setting to disable automatic large-task triage splitting.
+  category: feature
+  dev: Adds triageProactiveSubtaskSplittingEnabled while preserving explicit breakIntoSubtasks requests.
+- 978cdda: summary: Show active Plan Review progress on triage task cards.
+  category: fix
+  dev: TaskCard now renders the existing progress affordance for Triage only when unified progress has active workflow work.
+- 635fca2: summary: Remove the eye icon markdown/plain toggle from chat; messages always render as Markdown.
+  category: breaking
+  dev: Removed ChatView `chat-thread-header-render-toggle` (desktop + mobile), `showAllAsPlain` state, and `chat.showRenderedMarkdown`/`chat.showPlainText` i18n keys (FN-7541).
+- 3d55102: summary: Clarify task-detail oversight Nudge/Explain controls: visible label, disabled reason, always-openable Explain panel.
+  category: fix
+  dev: TaskDetailModal now renders a `detail-oversight-controls-label` group label and `detail-overseer-nudge-disabled-reason` helper text (both gated by the existing oversight-cluster visibility condition); Explain no longer disables on `!canExplainOverseer` since it is read-only. Nudge's `canNudgeOverseer` gate and Stop's confirm dialog are unchanged.
+- 0f1cd0a: summary: Unify border, radius, and height of the task-detail Priority/Execution/Oversight controls.
+  category: fix
+  dev: Adds a shared --detail-control-border-radius token alongside --detail-priority-control-min-height so .detail-priority-chip, .detail-execution-mode-toggle, .detail-oversight-chip, and .detail-oversight-menu-trigger all resolve the same border-width/color/radius/height.
+- b42ba9f: summary: Keep the task-detail Activity view menu open during mobile iOS taps.
+  category: fix
+  dev: Guards the Activity views dropdown against iOS visualViewport resize/scroll echoes during menu opening.
+- a7559b0: summary: Fix Anthropic subscription login when pasted callback URLs contain fragment OAuth parameters.
+  category: fix
+  dev: Normalizes pasted OAuth callback fragments before resolving dashboard manual-code login prompts.
+- 4b530a6: summary: Fix Claude/Anthropic subscription re-login showing "Login did not complete" after logging out.
+  category: fix
+  dev: Anthropic subscription OAuth is aliased across the legacy `anthropic` row (where interactive login persists the credential) and the `anthropic-subscription` id (where the settings card's in-memory logged-out suppression and status read are keyed). Re-login wrote only `anthropic`, so `loggedOutProviders` kept suppressing `anthropic-subscription` and the card reported failure despite a valid stored credential until process restart. auth-storage's proxy now clears the logged-out state on both aliases when either is re-authenticated (new `login` trap + hardened `set` trap via `clearReauthenticatedLogoutState`; raw api_key writes stay scoped to their own card). Also surfaces background OAuth login failures on `GET /auth/status` (`loginError`) + server logs so future paste-callback failures are diagnosable instead of a generic error.
+- a5ac3c3: summary: Stop self-healing from killing actively-running tasks after ~30 minutes.
+  category: fix
+  dev: FN-7566. isPhantomExecutorBinding's liveness gate (heartbeat/checkout/runAudit) was blind to ephemeral executor agents, leaving only the age>graceMs\*3 threshold, so any ephemeral-executor task running longer than ~30 min was reclaimed to `todo` mid-flight. Adds the in-process live-session veto (activeSessionRegistry path / executingTaskLock / isTaskActive), mirroring the isWorkspaceTaskLive/sessionDead predicate, and honors clearPhantomExecutorBinding's live-session refusal in reclaimSelfOwnedBranchConflicts.
+- 8912399: summary: Stop Windows Terminal version dialogs from popping up when opening the dashboard or Settings on Windows.
+  category: fix
+  dev: Root cause was the worktrunk integration, not the embedded terminal: worktrunk's CLI is named `wt`, which collides with Windows Terminal (`wt.exe`) on PATH, so probing it with `wt --version` launched Windows Terminal. Fixed by (1) `useWorktrunkInstallStatus` only auto-fetching `/api/worktrunk/status` when the integration is enabled (user opt-in) instead of on every Settings/dashboard mount, and (2) an engine-level guard in `probeWorktrunk` that refuses to exec a resolved `wt` that is the Windows Terminal alias (under `WindowsApps` / a `WindowsTerminal` package dir), covering all resolution surfaces.
+- b800f7d: summary: Select newly created folders automatically during project setup.
+  category: fix
+  dev: Adds DirectoryPicker opt-in selection for project-registration surfaces while preserving default picker behavior.
+- 9dc248e: summary: Prevent Desktop update banners from using 0.0.0 as the current version.
+  category: fix
+  dev: Dashboard update checks now resolve packaged @fusion/desktop metadata and fail closed for unresolved versions.
+- 52dbc0e: summary: Quit Fusion Desktop on Windows when the window is closed.
+  category: fix
+  dev: Updates Electron close lifecycle so Windows shutdown reaches embedded runtime cleanup.
+- ced783e: summary: Open desktop Anthropic Subscription OAuth logins in the system browser.
+  category: fix
+  dev: Adds Electron window-open policy coverage and preserves Settings auth polling completion paths.
+- 50786f2: summary: Delay GitHub setup warnings for one day and add a dashboard connect action.
+  category: fix
+  dev: Dashboard setup warnings now gate GitHub prompts per project and route the CTA to Settings → Authentication.
+- b4b1f6d: summary: Fix a false AI engine not running banner in desktop mode.
+  category: fix
+  dev: Distinguishes transient embedded desktop engine startup from true dashboard-only mode.
+- e8b7362: summary: Clarify the desktop Connection Manager add-remote flow.
+  category: fix
+  dev: Desktop Connection Manager now separates Local Server context from saved remote profiles and collapses the remote editor until add/edit.
+- 0900a38: summary: Restore Local Server in the desktop Switch server list.
+  category: fix
+  dev: Desktop Connection Manager now lists local and saved remote destinations together.
+- a2b09f2: summary: Make right-dock task list clicks respect the task popup setting.
+  category: fix
+  dev: Threads openMobileTasksInPopup through the right-dock Tasks list route while preserving embedded dock detail when disabled.
+- 0f05156: summary: Auto-retry retryable Code Review remediation failures.
+  category: fix
+  dev: Prevents retryable code-review-remediation graph failures from stranding tasks in in-review.
+- 20184ac: summary: Fix no-op task branch recovery after a previously landed task.
+  category: fix
+  dev: Merge/recovery ownership classification now checks no-diff branches before foreign trailer rejection.
+- 82493e0: summary: Allow documented source-free task-artifact deliveries to finish without commits.
+  category: fix
+  dev: fn_task_done now recognizes explicit gitignored .fusion/tasks artifact contracts while preserving source-change no-commit guards.
+- 5689346: summary: Fix direct merges so Push to remote after merge honors the configured remote and branch.
+  category: fix
+  dev: Resolves remote-only push targets from the merge integration branch and preserves non-fatal push errors on done tasks.
+- b42be87: summary: Keep task popups on the board layer with Activity menus above them.
+  category: fix
+  dev: Task-detail FloatingWindow callers use a lower layer band, and Activity view menus reposition after popup geometry changes.
+- 61c8bdc: summary: Keep accepted chat requests waiting instead of showing false first-event timeout failures.
+  category: fix
+  dev: Dashboard chat POST streams no longer abort accepted-but-silent responses on the client first-event timer.
+- e8dc2ae: summary: Show each task's original prompt in the Plan tab alongside the generated plan.
+  category: fix
+  dev: Adds a read-only Task Detail original-prompt section backed by task.description.
+- d2e3134: summary: Add before-to-after transformation summaries to generated task definitions.
+  category: feature
+  dev: Built-in standard and fast triage prompts now require a `## Before → After Transformation` section.
+- b0208c1: summary: Restore terminal Ctrl/Cmd copy and paste shortcuts.
+  category: fix
+  dev: Integrated and embedded terminals now own physical clipboard paste to avoid swallowed or duplicate input.
+- 2797803: summary: Show first-token and tool processing durations in task agent logs.
+  category: feature
+  dev: Adds optional agent-log timing fields `timeToFirstTokenMs` and `durationMs`.
+- a2d6349: summary: Fix mobile Chat composer being hidden behind the keyboard accessory bar.
+  category: fix
+  dev: Adds keyboard-open bottom clearance in ChatView so the composer clears the iOS input-assistant/autofill bar without a persistent .chat-thread transform or Android reserved-gap.
+- 4baa4c4: summary: Settings descriptions now show each setting's default value.
+  category: feature
+  dev: Appended default-value copy to settings.\* i18n descriptions across Global, Runtimes, and Project Settings sections, sourced from DEFAULT_GLOBAL_SETTINGS/DEFAULT_PROJECT_SETTINGS in settings-schema.ts; added settings-default-descriptions.test.tsx guarding that every surfaced setting states a default (or explicit "inherits"/"no default \u2014 unset") and that every DEFAULT_SETTINGS key is documented or allowlisted as not surfaced.
+- 53d7b7e: summary: Add an intelligent git-revert engine service and POST /api/tasks/:id/revert route.
+  category: feature
+  dev: New `packages/engine/src/task-revert.ts` exports `resolveTaskRevertCommits`, `classifyTaskRevert`, and `performTaskRevert` (squash/rebase/lineage attribution precedence, dry-run classification, guaranteed-clean rollback). Route enforces done/archived-only and autoMerge-off guard rails; conflicting results are returned unresolved for sibling FN-7524 (AI-undo) to act on. Workspace tasks return `unsupported`.
+- 4707eb5: summary: Auto-approve now reliably sends specified plans to the board without a manual approval stop.
+  category: fix
+  dev: FN-7526 — investigated the reported "plans still park at awaiting-approval when auto-approve is on" symptom; resolvePlanApprovalRequired, mergeEffectiveSettings/applyWorkflowSettingsOverlay, and every finalizeApprovedTask call site (specifyTask, recoverApprovedTask, retryUnavailablePlanReview, tryFinalizeExplicitDuplicateMarker) already honored project planApprovalMode: "auto-approve-all" over a stored workflow requirePlanApproval value — no production defect reproduced. Added end-to-end regression coverage across every enumerated surface (Plan Review reviewer-outage retry, refinement routing, self-healing starved-refinement recovery) using the real mergeEffectiveSettings pipeline instead of isolated bare-settings unit calls, plus explicit assertions that the independent release-authorization and Workflow Plan Review gates remain intact under auto-approve-all, so a future bare-settings call site is caught immediately instead of silently reintroducing the reported behavior.
+- 3b52a4d: summary: Fix the in-dashboard Switch server menu not switching desktop local/remote.
+  category: fix
+  dev: The desktop shell's redirect effects in App.tsx read a dead `localServer` field that the preload never populates; extracted `resolveDesktopShellRedirectTarget` in appLifecycle.ts now derives the navigation target from the live `localRuntime`/`activeProfileId` state for both directions, and the unused `localServer` field was removed from `ShellConnectionState`.
+- 36bd74e: summary: Fix branch group completion checklists to show accurate landed/finished counts.
+  category: fix
+  dev: runAiMerge (the sole merge path since master-plan U0) never resolved branch-group routing or stamped mergeDetails.mergeTargetBranch/mergeTargetSource, so isBranchGroupMemberLanded permanently reported shared-group members as not landed. Routes through resolveBranchGroupMergeRouting (matching the legacy merger.ts pattern) and stamps the target fields on both the landed and no-op finalize paths; preserves merge-target-safety in isBranchGroupMemberLanded (a sibling/mismatched-branch member still never counts as landed).
+- df0be88: summary: Branch groups no longer report complete (or become promotable) when an unlanded member is archived.
+  category: fix
+  dev: listTasksByBranchGroup membership now scans with includeArchived:true so an archived-but-unlanded member stays counted in total instead of silently dropping out; mergeDetails is now persisted on ArchivedTaskEntry so an archived member that had already landed keeps counting as landed. evaluateBranchGroupCompletion / promoteBranchGroup gate correctly; merge-target-safety in isBranchGroupMemberLanded is unchanged.
+- ec9ac61: summary: Fix the global GitLab integration setting not persisting when saved.
+  category: fix
+  dev: splitSettingsSave now diffs the five global GitLab keys (gitlabEnabled, gitlabInstanceUrl, gitlabApiBaseUrl, gitlabAuthToken, gitlabAuthTokenType) against scoped global initials only, never the project-effective merged initialValues, so a project override no longer suppresses a real global save.
+- 8d36b99: summary: Fix task-detail Activity view dropdown not opening reliably on mobile.
+  category: fix
+  dev: Guards the Activity menu's window resize/orientationchange/scroll close-listener with the same opening-tap timing guard already used for visualViewport, and exempts scroll events originating in the `.detail-tabs` scroller, so a same-gesture mobile tap echo (Android/iOS, fixed modal or `.floating-window--task-detail` popup) no longer closes the menu the instant it opens.
+- ad744aa: summary: Manual "Run now" for the Database Backup automation now runs in-process like the scheduler, matching cron behavior.
+  category: fix
+  dev: The legacy single-command and command-step manual automation run path (`executeSingleCommand` in packages/dashboard/src/routes.ts) now intercepts `isInProcessBackupCommand`/`isInProcessMemoryBackupCommand` via the scoped TaskStore, mirroring `RoutineRunner.executeCommand`/`CronRunner`, instead of always shelling out via `exec()`. `formatInProcessBackupError`, `isInProcessBackupCommand`, and `isInProcessMemoryBackupCommand` are now exported from `@fusion/engine` for reuse. Existing onStep/onText live-run callbacks already stream incremental output for command/backup runs; added regression coverage confirming this holds for the new interception branch.
+- 5c3d58a: summary: Task cards no longer show the "Auto-recovery" oversight badge unless oversight is explicitly configured.
+  category: fix
+  dev: `TaskCard.tsx`'s `showOversightBadge` gate now also suppresses the badge when the effective level equals `DEFAULT_PLANNER_OVERSIGHT_LEVEL` ("autonomous") and there is no explicit per-task `plannerOversightLevel` override; an explicit per-task override of "autonomous" still renders the badge.
+- b4be515: summary: Remove the per-card overseer-state ("Executor") badge from task cards.
+  category: fix
+  dev: Deleted the FN-7516 `card-overseer-state-badge` render, its card-local `deriveOverseerCardWatchedStage` helper/label maps, and its CSS; the sibling oversight-level badge (`card-oversight-badge`) is unaffected.
+- 62ddb19: summary: Original task prompt now renders as Markdown and is collapsed by default in the task Plan tab.
+  category: feature
+  dev: Task Detail Plan/Definition tab original-prompt section reuses the existing `.detail-source-toggle`/`.detail-source-chevron--expanded` collapse pattern and the shared `ReactMarkdown` pipeline (`remarkGfm`, `sharedRehypePlugins`, `markdownLinkifyComponents`); backed by read-only `task.description`, no change to the generated `PROMPT.md` editor/revision flow.
+- 883c73e: summary: Fix agent-created artifacts not appearing live in the dashboard artifacts view.
+  category: fix
+  dev: Root cause was cross-instance artifact-registration replication, not the route/hook/render path (all already correct). `TaskStore.registerArtifact()` never bumped `lastModified`, and `checkForChanges()` (the polling replicator that lets a second TaskStore instance on the same project — e.g. the dashboard's cached store vs. the engine's own store — mirror events it did not write itself) only ever diffed the `tasks` table, never `artifacts`. A store instance that did not perform the write could therefore never observe or re-emit `artifact:registered`, leaving an already-open Documents/task Artifacts gallery stale until a full reload. Fixed by bumping `lastModified` on artifact writes and adding a strictly-increasing `rowid`-cursor poll over the `artifacts` table in `checkForChanges()`. See `packages/core/src/__tests__/artifacts.test.ts` and `packages/dashboard/src/routes/__tests__/artifacts-route-integration.test.ts` for regression coverage.
+- d09b57f: summary: Fix the mobile terminal shortcut bar so it scrolls horizontally to reach every key.
+  category: fix
+  dev: Added `min-width: 0` to `.terminal-shortcut-panel` to defeat the flex min-width:auto trap that clipped overflow instead of engaging `overflow-x: auto`.
+- 3d58260: summary: Planner-oversight intervention timeline now populates from real engine activity.
+  category: fix
+  dev: Wires PlannerOverseerMonitor/PlannerRecoveryController decision points to the FN-7520 emitOverseer\* façade with the real TaskStore; observation/escalation emission deduped per (task, stage[, signal]).
+- 052a277: summary: Show the "Global" prefix on the Authentication entry in the mobile Settings picker.
+  category: fix
+  dev: resolveSettingsSectionOptionLabel now derives the Global-group prefix for storage-less (scope: undefined) sections in SettingsModal.tsx (FN-7552).
+- 6e4c207: summary: Tasks held for release authorization or Plan Review are now shown distinctly, so auto-approve no longer looks broken.
+  category: fix
+  dev: FN-7559 — auto-approve-all bypasses only the manual plan-approval gate (unchanged, FN-7526). Release-authorization holds are surfaced with a new distinct status reason (`Task.awaitingApprovalReason: "release-authorization"`) and no longer render the generic manual Approve/Reject affordance in TaskCard/TaskDetailModal; Workflow Plan Review already used distinct statuses (`needs-replan`/`plan-review-unavailable`) and is unaffected. Both gates remain independent and intact — this is UI/data disambiguation only.
+- 6d364fc: summary: Move mobile terminal controls into a bottom footer so they no longer crowd the header, with a scrollable shortcut bar.
+  category: fix
+  dev: On the ≤768px terminal, the `.terminal-actions` cluster now renders in a `terminal-footer-actions` bar (with `min-width:0; overflow-x:auto`) instead of the header; desktop/floating/pinned-below keep the FN-7502 header layout. Preserves the FN-7550 shortcut-panel scroll fix.
+- b471aec: summary: Stop the release-authorization gate from holding tasks that merely disclaim releasing.
+  category: fix
+  dev: classifyReleaseTask now strips negated release-disclaimer clauses (e.g. "this task performs no release/publish; releases are owned by scripts/release.mjs") before signal matching in packages/engine/src/triage-release-authorization.ts, so revert/undo/UI specs are no longer false-flagged as release-class. Genuine "run pnpm release"/"publish @runfusion/fusion" intent still trips the gate.
+- 9d4a45b: summary: Fix mobile terminal text still rendering with excess inter-character gaps after font-load settle.
+  category: fix
+  dev: Root cause: xterm's OptionsService setter is a no-op when reassigning an already-current fontFamily/fontSize, so post-settle reapply never forced CharSizeService/DomRenderer to remeasure. Added `forceTerminalFontRemeasure()` in `terminalPreferences.ts`, used by both `TerminalModal.tsx` and `SessionTerminal.tsx` at every post-`waitForTerminalFontMetrics()` settle site.
+- 72b77bf: summary: Stop Plan Review from looping tasks forever and fix its "can't find the plan" reviews.
+  category: fix
+  dev: FN-7561 — Plan Review pre-merge gate hardening in packages/engine/src/executor.ts. (1) The reviewer ran readonly with cwd=worktree but the spec lives at project-root .fusion/tasks/<id>/PROMPT.md, so "Read PROMPT.md" produced "no PROMPT.md found / data is in a DB" non-verdicts; the spec text is now injected into the reviewer prompt via readTaskArtifact. (2) A malformed reviewer response now self-retries once on the primary model when no fallback is configured. (3) A malformed (advisory_failure, no verdict) plan-review result can never trigger a triage replan. (4) The unbounded plan-review replan default is capped at 15 attempts with a loud halting log entry, so a persistently-disagreeing planner/reviewer no longer burns LLM calls indefinitely (FN-7525 ran 13+ attempts overnight).
+- c08498e: summary: Planner-overseer task badge now shows a readable label and explains what it is waiting on.
+  category: fix
+  dev: TaskCard badge renders plannerOverseerStateLabel + plannerOverseerBadgeTooltip built from the existing PlannerOverseerRuntimeSnapshot (reason/watchedStage/signal/pendingConfirmation); presentation-only, no engine changes.
+- 24b27e8: summary: Plan approve/reject API now blocks release-authorization holds, requiring the authorization marker first.
+  category: fix
+  dev: FN-7564 — POST /tasks/:id/approve-plan and /reject-plan now return 400 when task.awaitingApprovalReason === "release-authorization" (FN-7559 discriminator), enforcing the FN-6481 release-authorization gate at the API layer regardless of client. Manual-approval holds are unaffected.
+- fb45157: summary: Pin the mobile terminal close (X) button to the top-right corner so it is easy to find and tap.
+  category: fix
+  dev: On the ≤768px terminal, the `terminal-close` button now carries a `terminal-close--corner` class (order:3 + margin-inline-start:auto) so it renders last in flex order and hugs the right edge next to the tab dropdown, instead of falling back to order:0 (far left). Desktop/floating/pinned-below placement inside `.terminal-actions` is unchanged.
+- 7c0be53: summary: Fix mobile terminal excess character spacing that survived earlier font-remeasure fixes.
+  category: fix
+  dev: `TerminalModal`/`SessionTerminal` re-bake xterm's `DomRenderer` letter-spacing compensation AFTER `fitAddon.fit()` settles the post-fit column count (not just before it), since `handleResize()` never re-bakes spacing itself. See `docs/solutions/ui-bugs/xterm-options-noop-remeasure-after-font-settle.md` recurrence #4.
+- 71dfd3a: summary: Rename downloadable CLI release binaries to the fn-cli-<platform> base name.
+  category: internal
+  dev: `binaryNameForTarget` in `packages/cli/build.ts` and the `release.yml` / `test-release.yml` matrices now emit `fn-cli-<suffix>`; the local dev binary stays `fn`/`fn.exe`.
+- 9592e3a: summary: Manual plan approval no longer re-asks you to approve a plan you already approved when it hasn't changed.
+  category: fix
+  dev: FN-7569 — approving a plan records a fingerprint of the approved PROMPT.md (new nullable Task.approvedPlanFingerprint, migration 139). The manual plan-approval gate skips re-parking at awaiting-approval when a re-specification (replan, plan-review retry, self-healing rebound) produces the same plan; a changed plan or reject-plan still requires fresh approval. Release authorization, Workflow Plan Review, and auto-approve-all are unchanged.
+- c31f9ef: summary: Move the planner intervention timeline into the task Activity view dropdown.
+  category: feature
+  dev: Removes the inline `PlannerInterventionTimeline` mount from the FN-7517 oversight cluster in `TaskDetailModal.tsx` and adds a fourth `interventions` `ActivitySegment`, shown in the Activity dropdown only when planner oversight is active for the task; falls back to Live if oversight turns off while Interventions is selected.
+- ce9df29: summary: Expired Claude subscription logins now show disconnected with a re-login prompt; tokens auto-refresh before expiry.
+  category: fix
+  dev: Unifies OAuth expiry detection between OAuthExpiryMonitor and /api/auth/status, and adds an engine-side proactive OAuth refresh scheduler wired in project-engine (guarded by skipNotifier). No token material logged.
+- 196abb5: summary: Anthropic subscription reads now refresh the OAuth token automatically instead of silently failing when expired.
+  category: fix
+  dev: mergeAuthStorageReads getApiKey("anthropic-subscription") now delegates to the underlying engine authStorage.getApiKey (the only refresh-token HTTP round trip) instead of a local static expiry check; regression tests drive the wrapper directly. No token material logged.
+- 45e5a26: summary: Stop GitHub tracking-issue creation from linking new tasks to old/closed issues.
+  category: fix
+  dev: github-tracking dedup now only reuses OPEN issues and requires a File-Scope path overlap (keyword-only matches no longer link). Prevents mis-linking a fresh task to a stale/resolved tracking issue (FN-7579). Setting `githubTrackingDedupEnabled` unchanged.
+- a1a6b09: summary: Clarify the oversight "Nudge unavailable" guideline so it no longer reads as an overseer fault.
+  category: fix
+  dev: TaskDetailModal oversight controls — reworded taskDetail.oversight.nudgeDisabledTitle and added taskDetail.oversight.nudgeSuppressedTitle to differentiate periodic-observation vs. manual-control states. No enablement/engine logic changed.
+- cf3fe8b: summary: New tasks created under the Coding (Ideas) workflow now land in the Ideas column and wait for you to promote them.
+  category: fix
+  dev: Dashboard create surfaces (InlineCreateCard, QuickEntryBox, NewTaskModal, insight/todo → task) no longer hard-code column:"triage"; the store now resolves the selected/default workflow's intake column. InlineCreateCard forwards workflowId at create time instead of applying it post-create. Also fixed a glue-layer regression in `useTaskHandlers.ts` (`handleBoardQuickCreate`/`handleModalCreate`) that re-forced column:"triage" even after the UI surfaces stopped sending it.
+- 8b4e522: summary: Fix tasks vanishing from the board after being added to a workflow like Coding (Ideas).
+  category: fix
+  dev: Board.tsx forces a board-workflows refetch (deferred one tick, signature-guarded) whenever a rendered task is missing from the taskWorkflowIds map, so its real workflow and intake column resolve regardless of which create surface added it; the single-workflow grouping also re-homes a task whose column its workflow no longer declares into the intake lane instead of dropping it. Fixes the FN-7591 regression where intake-column cards (column "ideas") fell back to the default workflow, which has no such column, and were filtered out until a manual reload.
+- f30d55f: summary: Move the Before → After transformation summary to the top of generated task definitions.
+  category: fix
+  dev: Reorders the standard and fast triage `PROMPT.md` templates in packages/core/src/agent-prompts.ts so `## Before → After Transformation` is the first content section, ahead of `## Review Level` and `## Mission`, matching FN-7499's glance-verification intent.
+- 20379e8: summary: Task-detail Priority dropdown now matches the Oversight dropdown's size, border, and typography.
+  category: fix
+  dev: Removed the Priority-only forced select/option uppercase, added a neutral chip background scoped to `.detail-priority-chip.card-priority-badge--normal` for the untinted `normal` level, and reused the FN-7585 shared `--btn-border-width`/`--border`/`--detail-control-border-radius`/`--detail-priority-control-min-height` tokens so both dropdowns render as one control style across desktop and the mobile oversight-overflow surface.
+- e0f3d3d: summary: Default workflow boards now label the intake column "Planning" instead of "Triage".
+  category: fix
+  dev: Renamed the `name` of the `id: "triage"` intake column to "Planning" in builtin-coding, builtin-stepwise-coding, and builtin-pr workflow IRs (column id unchanged; linear built-ins inherit via canonicalBuiltinWorkflowColumns). COLUMN_LABELS.triage was already "Planning".
+- 5b193d2: summary: Fix the task-detail Nudge control staying disabled when the overseer is actively watching.
+  category: fix
+  dev: GET /api/tasks/:id now attaches the transient plannerOverseerState snapshot (mirrors the list route); TaskDetailModal reads the snapshot from workingTask so detail refetches no longer drop it.
+- 546ef16: summary: Honor mission branchStrategy when triage omits branchAssignment; skip validation for inactive missions.
+  category: fix
+  dev: resolveBranchAssignmentContext returns undefined for absent mode so triage falls back to mission.branchStrategy; processTaskOutcome gates on mission.status === "active" like recoverActiveMissions.
+- b173f76: summary: Planner overseer no longer marks healthy in-progress tasks as "recovering" or steers them.
+  category: fix
+  dev: `decidePlannerRecovery` now returns `none` for healthy (`progressing`/`complete`) and `awaiting-human` executor/workflow-gate signals instead of falling through to `inject_guidance`; only `stuck`/`blocked`/`failed` trigger autonomous steering. Also dedupes the `PlannerOverseerMonitor` activity-feed heartbeat so an unchanged `(stage, signal, reason)` observation is logged once per change, not every poll tick. Fixes the "overseer recovering" badge appearing on every autonomous card and the needless AI-consuming guidance injections (FN-7577).
+
 ## 0.55.0
 
 ### Minor Changes
diff --git a/packages/cli/package.json b/packages/cli/package.json
index 12b7620272..fd3058f086 100644
--- a/packages/cli/package.json
+++ b/packages/cli/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@runfusion/fusion",
-  "version": "0.55.0",
+  "version": "0.56.0",
   "license": "MIT",
   "description": "Fusion CLI: HTTP API server, daemon, dashboard launcher, and task tooling for the Fusion AI coding agent.",
   "homepage": "https://github.com/Runfusion/Fusion#readme",
diff --git a/packages/core/CHANGELOG.md b/packages/core/CHANGELOG.md
index 81a426217d..9dd821dbb1 100644
--- a/packages/core/CHANGELOG.md
+++ b/packages/core/CHANGELOG.md
@@ -1,5 +1,7 @@
 # @fusion/core
 
+## 0.56.0
+
 ## 0.55.0
 
 ## 0.54.0
diff --git a/packages/core/package.json b/packages/core/package.json
index 92b3a6d9c8..231c17ef04 100644
--- a/packages/core/package.json
+++ b/packages/core/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@fusion/core",
-  "version": "0.55.0",
+  "version": "0.56.0",
   "license": "MIT",
   "description": "Fusion core: task store, scheduler, settings, and shared domain types backing the Fusion AI coding agent.",
   "homepage": "https://github.com/Runfusion/Fusion#readme",
diff --git a/packages/dashboard/CHANGELOG.md b/packages/dashboard/CHANGELOG.md
index e8cf58ead6..2c24c505ba 100644
--- a/packages/dashboard/CHANGELOG.md
+++ b/packages/dashboard/CHANGELOG.md
@@ -1,5 +1,22 @@
 # @fusion/dashboard
 
+## 0.56.0
+
+### Patch Changes
+
+- @fusion/core@0.56.0
+- @fusion/engine@0.56.0
+- @fusion/i18n@0.39.20
+- @fusion-plugin-examples/cli-printing-press@0.1.37
+- @fusion-plugin-examples/compound-engineering@0.1.20
+- @fusion-plugin-examples/dependency-graph@0.1.51
+- @fusion-plugin-examples/roadmap@0.1.39
+- @fusion-plugin-examples/cursor-runtime@0.1.39
+- @fusion-plugin-examples/droid-runtime@0.1.46
+- @fusion-plugin-examples/hermes-runtime@0.2.70
+- @fusion-plugin-examples/openclaw-runtime@0.2.70
+- @fusion-plugin-examples/paperclip-runtime@0.2.70
+
 ## 0.55.0
 
 ### Patch Changes
diff --git a/packages/dashboard/package.json b/packages/dashboard/package.json
index a7cb0917aa..fd257dd688 100644
--- a/packages/dashboard/package.json
+++ b/packages/dashboard/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@fusion/dashboard",
-  "version": "0.55.0",
+  "version": "0.56.0",
   "license": "MIT",
   "description": "Fusion dashboard: React UI and HTTP API server for monitoring and controlling the Fusion AI coding agent.",
   "homepage": "https://github.com/Runfusion/Fusion#readme",
diff --git a/packages/desktop/CHANGELOG.md b/packages/desktop/CHANGELOG.md
index 25edae85ec..9cdc43a1f9 100644
--- a/packages/desktop/CHANGELOG.md
+++ b/packages/desktop/CHANGELOG.md
@@ -1,5 +1,13 @@
 # @fusion/desktop
 
+## 0.56.0
+
+### Patch Changes
+
+- @fusion/core@0.56.0
+- @fusion/dashboard@0.56.0
+- @fusion/engine@0.56.0
+
 ## 0.55.0
 
 ### Patch Changes
diff --git a/packages/desktop/package.json b/packages/desktop/package.json
index bcb0451adc..3ada770992 100644
--- a/packages/desktop/package.json
+++ b/packages/desktop/package.json
@@ -1,7 +1,7 @@
 {
   "name": "@fusion/desktop",
   "productName": "Fusion",
-  "version": "0.55.0",
+  "version": "0.56.0",
   "license": "MIT",
   "author": {
     "name": "Runfusion",
diff --git a/packages/droid-cli/CHANGELOG.md b/packages/droid-cli/CHANGELOG.md
index 7d0ba7fdf8..76ed864e1f 100644
--- a/packages/droid-cli/CHANGELOG.md
+++ b/packages/droid-cli/CHANGELOG.md
@@ -1,5 +1,11 @@
 # @fusion/droid-cli
 
+## 0.11.46
+
+### Patch Changes
+
+- @fusion-plugin-examples/droid-runtime@0.1.46
+
 ## 0.11.45
 
 ### Patch Changes
diff --git a/packages/droid-cli/package.json b/packages/droid-cli/package.json
index 3f4e3c0aca..b4f78e77ce 100644
--- a/packages/droid-cli/package.json
+++ b/packages/droid-cli/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@fusion/droid-cli",
-  "version": "0.11.45",
+  "version": "0.11.46",
   "description": "First-party Fusion pi extension that routes LLM calls through the Droid CLI subprocess.",
   "license": "MIT",
   "private": true,
diff --git a/packages/engine/CHANGELOG.md b/packages/engine/CHANGELOG.md
index 28d72ab991..9a2a0641c7 100644
--- a/packages/engine/CHANGELOG.md
+++ b/packages/engine/CHANGELOG.md
@@ -1,5 +1,12 @@
 # @fusion/engine
 
+## 0.56.0
+
+### Patch Changes
+
+- @fusion/core@0.56.0
+- @fusion/pi-claude-cli@0.56.0
+
 ## 0.55.0
 
 ### Patch Changes
diff --git a/packages/engine/package.json b/packages/engine/package.json
index 576d863dc6..c0dbe437f9 100644
--- a/packages/engine/package.json
+++ b/packages/engine/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@fusion/engine",
-  "version": "0.55.0",
+  "version": "0.56.0",
   "license": "MIT",
   "description": "Fusion engine: executor, merger, scheduler, and automation runtime for the Fusion AI coding agent.",
   "homepage": "https://github.com/Runfusion/Fusion#readme",
diff --git a/packages/i18n/CHANGELOG.md b/packages/i18n/CHANGELOG.md
index 192f39166e..6cca96c292 100644
--- a/packages/i18n/CHANGELOG.md
+++ b/packages/i18n/CHANGELOG.md
@@ -1,5 +1,11 @@
 # @fusion/i18n
 
+## 0.39.20
+
+### Patch Changes
+
+- @fusion/core@0.56.0
+
 ## 0.39.19
 
 ### Patch Changes
diff --git a/packages/i18n/package.json b/packages/i18n/package.json
index 16495becdf..1f72dffbb0 100644
--- a/packages/i18n/package.json
+++ b/packages/i18n/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@fusion/i18n",
-  "version": "0.39.19",
+  "version": "0.39.20",
   "license": "MIT",
   "description": "Fusion i18n: authored translation catalogs and shared i18next configuration for the Fusion dashboard and terminal UI.",
   "type": "module",
diff --git a/packages/mobile/CHANGELOG.md b/packages/mobile/CHANGELOG.md
index 049b06a582..eb259f5e2f 100644
--- a/packages/mobile/CHANGELOG.md
+++ b/packages/mobile/CHANGELOG.md
@@ -1,5 +1,7 @@
 # @fusion/mobile
 
+## 0.56.0
+
 ## 0.55.0
 
 ## 0.54.0
diff --git a/packages/mobile/package.json b/packages/mobile/package.json
index fe473d5575..9155721d9e 100644
--- a/packages/mobile/package.json
+++ b/packages/mobile/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@fusion/mobile",
-  "version": "0.55.0",
+  "version": "0.56.0",
   "license": "MIT",
   "description": "Fusion mobile: Capacitor wrapper around the Fusion dashboard for iOS and Android.",
   "homepage": "https://github.com/Runfusion/Fusion#readme",
diff --git a/packages/pi-claude-cli/CHANGELOG.md b/packages/pi-claude-cli/CHANGELOG.md
index 3283269e5e..33da4a620d 100644
--- a/packages/pi-claude-cli/CHANGELOG.md
+++ b/packages/pi-claude-cli/CHANGELOG.md
@@ -1,5 +1,7 @@
 # @fusion/pi-claude-cli
 
+## 0.56.0
+
 ## 0.55.0
 
 ## 0.54.0
diff --git a/packages/pi-claude-cli/package.json b/packages/pi-claude-cli/package.json
index 552068bcdb..5492de6a46 100644
--- a/packages/pi-claude-cli/package.json
+++ b/packages/pi-claude-cli/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@fusion/pi-claude-cli",
-  "version": "0.55.0",
+  "version": "0.56.0",
   "description": "Fusion vendored fork: pi coding-agent extension that routes LLM calls through the Claude Code CLI. Forked from rchern/pi-claude-cli (MIT). See UPSTREAM.md.",
   "license": "MIT",
   "private": true,
diff --git a/packages/plugin-sdk/CHANGELOG.md b/packages/plugin-sdk/CHANGELOG.md
index b0d8b656c2..7fae7b8544 100644
--- a/packages/plugin-sdk/CHANGELOG.md
+++ b/packages/plugin-sdk/CHANGELOG.md
@@ -1,5 +1,11 @@
 # @fusion/plugin-sdk
 
+## 0.56.0
+
+### Patch Changes
+
+- @fusion/core@0.56.0
+
 ## 0.55.0
 
 ### Patch Changes
diff --git a/packages/plugin-sdk/package.json b/packages/plugin-sdk/package.json
index 6babb155ea..521758e3da 100644
--- a/packages/plugin-sdk/package.json
+++ b/packages/plugin-sdk/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@fusion/plugin-sdk",
-  "version": "0.55.0",
+  "version": "0.56.0",
   "license": "MIT",
   "description": "Fusion plugin SDK: types and helpers for authoring third-party plugins that extend the Fusion dashboard and engine.",
   "homepage": "https://github.com/Runfusion/Fusion#readme",
diff --git a/plugins/examples/fusion-plugin-auto-label/CHANGELOG.md b/plugins/examples/fusion-plugin-auto-label/CHANGELOG.md
index bd78d1f52f..92123aac5b 100644
--- a/plugins/examples/fusion-plugin-auto-label/CHANGELOG.md
+++ b/plugins/examples/fusion-plugin-auto-label/CHANGELOG.md
@@ -1,5 +1,11 @@
 # @fusion-plugin-examples/auto-label
 
+## 0.2.70
+
+### Patch Changes
+
+- @fusion/plugin-sdk@0.56.0
+
 ## 0.2.69
 
 ### Patch Changes
diff --git a/plugins/examples/fusion-plugin-auto-label/package.json b/plugins/examples/fusion-plugin-auto-label/package.json
index 436cbc4f57..ac3934a24c 100644
--- a/plugins/examples/fusion-plugin-auto-label/package.json
+++ b/plugins/examples/fusion-plugin-auto-label/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@fusion-plugin-examples/auto-label",
-  "version": "0.2.69",
+  "version": "0.2.70",
   "type": "module",
   "description": "Automatically labels tasks based on description content",
   "keywords": [
diff --git a/plugins/examples/fusion-plugin-ci-status/CHANGELOG.md b/plugins/examples/fusion-plugin-ci-status/CHANGELOG.md
index bbedf030ab..b14c0e873b 100644
--- a/plugins/examples/fusion-plugin-ci-status/CHANGELOG.md
+++ b/plugins/examples/fusion-plugin-ci-status/CHANGELOG.md
@@ -1,5 +1,11 @@
 # @fusion-plugin-examples/ci-status
 
+## 0.2.70
+
+### Patch Changes
+
+- @fusion/plugin-sdk@0.56.0
+
 ## 0.2.69
 
 ### Patch Changes
diff --git a/plugins/examples/fusion-plugin-ci-status/package.json b/plugins/examples/fusion-plugin-ci-status/package.json
index 60874dc4be..8ac8d2e1d2 100644
--- a/plugins/examples/fusion-plugin-ci-status/package.json
+++ b/plugins/examples/fusion-plugin-ci-status/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@fusion-plugin-examples/ci-status",
-  "version": "0.2.69",
+  "version": "0.2.70",
   "type": "module",
   "description": "Polls CI status for branches and provides a custom API to query results",
   "keywords": [
diff --git a/plugins/examples/fusion-plugin-notification/CHANGELOG.md b/plugins/examples/fusion-plugin-notification/CHANGELOG.md
index 9a5153f7d2..7b693db1b3 100644
--- a/plugins/examples/fusion-plugin-notification/CHANGELOG.md
+++ b/plugins/examples/fusion-plugin-notification/CHANGELOG.md
@@ -1,5 +1,11 @@
 # @fusion-plugin-examples/notification
 
+## 0.2.70
+
+### Patch Changes
+
+- @fusion/plugin-sdk@0.56.0
+
 ## 0.2.69
 
 ### Patch Changes
diff --git a/plugins/examples/fusion-plugin-notification/package.json b/plugins/examples/fusion-plugin-notification/package.json
index de681e04cd..0bcc3dda54 100644
--- a/plugins/examples/fusion-plugin-notification/package.json
+++ b/plugins/examples/fusion-plugin-notification/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@fusion-plugin-examples/notification",
-  "version": "0.2.69",
+  "version": "0.2.70",
   "type": "module",
   "description": "Example Fusion plugin that sends webhook notifications on task lifecycle events",
   "keywords": [
diff --git a/plugins/examples/fusion-plugin-settings-demo/CHANGELOG.md b/plugins/examples/fusion-plugin-settings-demo/CHANGELOG.md
index b2151e7a23..bc00e600ca 100644
--- a/plugins/examples/fusion-plugin-settings-demo/CHANGELOG.md
+++ b/plugins/examples/fusion-plugin-settings-demo/CHANGELOG.md
@@ -1,5 +1,11 @@
 # @fusion-plugin-examples/settings-demo
 
+## 0.2.70
+
+### Patch Changes
+
+- @fusion/plugin-sdk@0.56.0
+
 ## 0.2.69
 
 ### Patch Changes
diff --git a/plugins/examples/fusion-plugin-settings-demo/package.json b/plugins/examples/fusion-plugin-settings-demo/package.json
index 1de0c8445f..c0fe1a7a18 100644
--- a/plugins/examples/fusion-plugin-settings-demo/package.json
+++ b/plugins/examples/fusion-plugin-settings-demo/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@fusion-plugin-examples/settings-demo",
-  "version": "0.2.69",
+  "version": "0.2.70",
   "type": "module",
   "description": "Example Fusion plugin demonstrating settings schema and runtime configuration",
   "keywords": [
diff --git a/plugins/fusion-plugin-acp-runtime/CHANGELOG.md b/plugins/fusion-plugin-acp-runtime/CHANGELOG.md
index 5f187fdcc1..3a345fbe25 100644
--- a/plugins/fusion-plugin-acp-runtime/CHANGELOG.md
+++ b/plugins/fusion-plugin-acp-runtime/CHANGELOG.md
@@ -1,5 +1,12 @@
 # @fusion-plugin-examples/acp-runtime
 
+## 0.1.20
+
+### Patch Changes
+
+- @fusion/core@0.56.0
+- @fusion/plugin-sdk@0.56.0
+
 ## 0.1.19
 
 ### Patch Changes
diff --git a/plugins/fusion-plugin-acp-runtime/package.json b/plugins/fusion-plugin-acp-runtime/package.json
index 40beacbe3c..74d51139c1 100644
--- a/plugins/fusion-plugin-acp-runtime/package.json
+++ b/plugins/fusion-plugin-acp-runtime/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@fusion-plugin-examples/acp-runtime",
-  "version": "0.1.19",
+  "version": "0.1.20",
   "type": "module",
   "description": "ACP (Agent Client Protocol) runtime plugin for Fusion — drives any ACP-compatible agent over JSON-RPC/stdio",
   "keywords": [
diff --git a/plugins/fusion-plugin-agent-browser/CHANGELOG.md b/plugins/fusion-plugin-agent-browser/CHANGELOG.md
index 465de46dfd..a505b9593b 100644
--- a/plugins/fusion-plugin-agent-browser/CHANGELOG.md
+++ b/plugins/fusion-plugin-agent-browser/CHANGELOG.md
@@ -1,5 +1,11 @@
 # @fusion-plugin-examples/agent-browser
 
+## 0.1.40
+
+### Patch Changes
+
+- @fusion/plugin-sdk@0.56.0
+
 ## 0.1.39
 
 ### Patch Changes
diff --git a/plugins/fusion-plugin-agent-browser/package.json b/plugins/fusion-plugin-agent-browser/package.json
index 09c90a3e70..ad16fb8759 100644
--- a/plugins/fusion-plugin-agent-browser/package.json
+++ b/plugins/fusion-plugin-agent-browser/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@fusion-plugin-examples/agent-browser",
-  "version": "0.1.39",
+  "version": "0.1.40",
   "type": "module",
   "description": "Agent Browser runtime and prompt/skill/workflow contributions for Fusion",
   "private": true,
diff --git a/plugins/fusion-plugin-cli-printing-press/CHANGELOG.md b/plugins/fusion-plugin-cli-printing-press/CHANGELOG.md
index e7e6907954..b36d1e51c8 100644
--- a/plugins/fusion-plugin-cli-printing-press/CHANGELOG.md
+++ b/plugins/fusion-plugin-cli-printing-press/CHANGELOG.md
@@ -1,5 +1,12 @@
 # @fusion-plugin-examples/cli-printing-press
 
+## 0.1.37
+
+### Patch Changes
+
+- @fusion/core@0.56.0
+- @fusion/plugin-sdk@0.56.0
+
 ## 0.1.36
 
 ### Patch Changes
diff --git a/plugins/fusion-plugin-cli-printing-press/package.json b/plugins/fusion-plugin-cli-printing-press/package.json
index 5402523845..67fb31e856 100644
--- a/plugins/fusion-plugin-cli-printing-press/package.json
+++ b/plugins/fusion-plugin-cli-printing-press/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@fusion-plugin-examples/cli-printing-press",
-  "version": "0.1.36",
+  "version": "0.1.37",
   "type": "module",
   "description": "CLI Printing Press plugin package for Fusion",
   "private": true,
diff --git a/plugins/fusion-plugin-compound-engineering/CHANGELOG.md b/plugins/fusion-plugin-compound-engineering/CHANGELOG.md
index 314fc4a286..d18283a8d3 100644
--- a/plugins/fusion-plugin-compound-engineering/CHANGELOG.md
+++ b/plugins/fusion-plugin-compound-engineering/CHANGELOG.md
@@ -1,5 +1,12 @@
 # @fusion-plugin-examples/compound-engineering
 
+## 0.1.20
+
+### Patch Changes
+
+- @fusion/core@0.56.0
+- @fusion/plugin-sdk@0.56.0
+
 ## 0.1.19
 
 ### Patch Changes
diff --git a/plugins/fusion-plugin-compound-engineering/package.json b/plugins/fusion-plugin-compound-engineering/package.json
index db69cc969d..6d77c79dd1 100644
--- a/plugins/fusion-plugin-compound-engineering/package.json
+++ b/plugins/fusion-plugin-compound-engineering/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@fusion-plugin-examples/compound-engineering",
-  "version": "0.1.19",
+  "version": "0.1.20",
   "type": "module",
   "description": "Compound Engineering plugin for Fusion",
   "private": true,
diff --git a/plugins/fusion-plugin-cursor-runtime/CHANGELOG.md b/plugins/fusion-plugin-cursor-runtime/CHANGELOG.md
index 298197aa82..f9549c047a 100644
--- a/plugins/fusion-plugin-cursor-runtime/CHANGELOG.md
+++ b/plugins/fusion-plugin-cursor-runtime/CHANGELOG.md
@@ -1,5 +1,11 @@
 # @fusion-plugin-examples/cursor-runtime
 
+## 0.1.39
+
+### Patch Changes
+
+- @fusion/plugin-sdk@0.56.0
+
 ## 0.1.38
 
 ### Patch Changes
diff --git a/plugins/fusion-plugin-cursor-runtime/package.json b/plugins/fusion-plugin-cursor-runtime/package.json
index 5fb1a19cac..2e70825d3a 100644
--- a/plugins/fusion-plugin-cursor-runtime/package.json
+++ b/plugins/fusion-plugin-cursor-runtime/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@fusion-plugin-examples/cursor-runtime",
-  "version": "0.1.38",
+  "version": "0.1.39",
   "type": "module",
   "description": "Cursor CLI runtime plugin for Fusion",
   "keywords": [
diff --git a/plugins/fusion-plugin-dependency-graph/CHANGELOG.md b/plugins/fusion-plugin-dependency-graph/CHANGELOG.md
index 8d45e99289..525a181f64 100644
--- a/plugins/fusion-plugin-dependency-graph/CHANGELOG.md
+++ b/plugins/fusion-plugin-dependency-graph/CHANGELOG.md
@@ -1,5 +1,12 @@
 # @fusion-plugin-examples/dependency-graph
 
+## 0.1.51
+
+### Patch Changes
+
+- @fusion/core@0.56.0
+- @fusion/plugin-sdk@0.56.0
+
 ## 0.1.50
 
 ### Patch Changes
diff --git a/plugins/fusion-plugin-dependency-graph/package.json b/plugins/fusion-plugin-dependency-graph/package.json
index ec099682a2..16222c5d22 100644
--- a/plugins/fusion-plugin-dependency-graph/package.json
+++ b/plugins/fusion-plugin-dependency-graph/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@fusion-plugin-examples/dependency-graph",
-  "version": "0.1.50",
+  "version": "0.1.51",
   "type": "module",
   "description": "Dependency graph dashboard view plugin for Fusion",
   "private": true,
diff --git a/plugins/fusion-plugin-droid-runtime/CHANGELOG.md b/plugins/fusion-plugin-droid-runtime/CHANGELOG.md
index 153b7b0df3..1b22afb3d5 100644
--- a/plugins/fusion-plugin-droid-runtime/CHANGELOG.md
+++ b/plugins/fusion-plugin-droid-runtime/CHANGELOG.md
@@ -1,5 +1,11 @@
 # Changelog
 
+## 0.1.46
+
+### Patch Changes
+
+- @fusion/plugin-sdk@0.56.0
+
 ## 0.1.45
 
 ### Patch Changes
diff --git a/plugins/fusion-plugin-droid-runtime/package.json b/plugins/fusion-plugin-droid-runtime/package.json
index fecaf23c7a..012e0f4c99 100644
--- a/plugins/fusion-plugin-droid-runtime/package.json
+++ b/plugins/fusion-plugin-droid-runtime/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@fusion-plugin-examples/droid-runtime",
-  "version": "0.1.45",
+  "version": "0.1.46",
   "type": "module",
   "description": "Droid runtime plugin for Fusion",
   "keywords": [
diff --git a/plugins/fusion-plugin-even-realities-glasses/CHANGELOG.md b/plugins/fusion-plugin-even-realities-glasses/CHANGELOG.md
index 88992c756d..79db7d7f80 100644
--- a/plugins/fusion-plugin-even-realities-glasses/CHANGELOG.md
+++ b/plugins/fusion-plugin-even-realities-glasses/CHANGELOG.md
@@ -1,5 +1,12 @@
 # @fusion-plugin-examples/even-realities-glasses
 
+## 0.1.39
+
+### Patch Changes
+
+- @fusion/core@0.56.0
+- @fusion/plugin-sdk@0.56.0
+
 ## 0.1.38
 
 ### Patch Changes
diff --git a/plugins/fusion-plugin-even-realities-glasses/package.json b/plugins/fusion-plugin-even-realities-glasses/package.json
index 1d68b89255..344be51f03 100644
--- a/plugins/fusion-plugin-even-realities-glasses/package.json
+++ b/plugins/fusion-plugin-even-realities-glasses/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@fusion-plugin-examples/even-realities-glasses",
-  "version": "0.1.38",
+  "version": "0.1.39",
   "type": "module",
   "description": "Canonical Even Realities Fusion plugin with board/task cards, actions, notifications, and webhook transport",
   "keywords": [
diff --git a/plugins/fusion-plugin-hermes-runtime/CHANGELOG.md b/plugins/fusion-plugin-hermes-runtime/CHANGELOG.md
index a32c1b620e..54429dbe28 100644
--- a/plugins/fusion-plugin-hermes-runtime/CHANGELOG.md
+++ b/plugins/fusion-plugin-hermes-runtime/CHANGELOG.md
@@ -1,5 +1,11 @@
 # @fusion-plugin-examples/hermes-runtime
 
+## 0.2.70
+
+### Patch Changes
+
+- @fusion/plugin-sdk@0.56.0
+
 ## 0.2.69
 
 ### Patch Changes
diff --git a/plugins/fusion-plugin-hermes-runtime/package.json b/plugins/fusion-plugin-hermes-runtime/package.json
index d40c24993b..af876dab32 100644
--- a/plugins/fusion-plugin-hermes-runtime/package.json
+++ b/plugins/fusion-plugin-hermes-runtime/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@fusion-plugin-examples/hermes-runtime",
-  "version": "0.2.69",
+  "version": "0.2.70",
   "type": "module",
   "description": "Hermes AI runtime plugin for Fusion - provides AI agent execution runtime",
   "keywords": [
diff --git a/plugins/fusion-plugin-linear-import/CHANGELOG.md b/plugins/fusion-plugin-linear-import/CHANGELOG.md
index d160b64733..1638eac78f 100644
--- a/plugins/fusion-plugin-linear-import/CHANGELOG.md
+++ b/plugins/fusion-plugin-linear-import/CHANGELOG.md
@@ -1,5 +1,12 @@
 # @fusion-plugin-examples/linear-import
 
+## 0.1.2
+
+### Patch Changes
+
+- @fusion/core@0.56.0
+- @fusion/plugin-sdk@0.56.0
+
 ## 0.1.1
 
 ### Patch Changes
diff --git a/plugins/fusion-plugin-linear-import/package.json b/plugins/fusion-plugin-linear-import/package.json
index c35942c056..f118732483 100644
--- a/plugins/fusion-plugin-linear-import/package.json
+++ b/plugins/fusion-plugin-linear-import/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@fusion-plugin-examples/linear-import",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "type": "module",
   "description": "Linear issue import plugin for Fusion",
   "private": true,
diff --git a/plugins/fusion-plugin-openclaw-runtime/CHANGELOG.md b/plugins/fusion-plugin-openclaw-runtime/CHANGELOG.md
index 71884eae8d..921a963f1f 100644
--- a/plugins/fusion-plugin-openclaw-runtime/CHANGELOG.md
+++ b/plugins/fusion-plugin-openclaw-runtime/CHANGELOG.md
@@ -1,5 +1,11 @@
 # @fusion-plugin-examples/openclaw-runtime
 
+## 0.2.70
+
+### Patch Changes
+
+- @fusion/plugin-sdk@0.56.0
+
 ## 0.2.69
 
 ### Patch Changes
diff --git a/plugins/fusion-plugin-openclaw-runtime/package.json b/plugins/fusion-plugin-openclaw-runtime/package.json
index 91da95e93d..3dfa0f20d1 100644
--- a/plugins/fusion-plugin-openclaw-runtime/package.json
+++ b/plugins/fusion-plugin-openclaw-runtime/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@fusion-plugin-examples/openclaw-runtime",
-  "version": "0.2.69",
+  "version": "0.2.70",
   "type": "module",
   "description": "Provides OpenClaw runtime for Fusion AI agents",
   "keywords": [
diff --git a/plugins/fusion-plugin-paperclip-runtime/CHANGELOG.md b/plugins/fusion-plugin-paperclip-runtime/CHANGELOG.md
index 559e620071..d44930ff61 100644
--- a/plugins/fusion-plugin-paperclip-runtime/CHANGELOG.md
+++ b/plugins/fusion-plugin-paperclip-runtime/CHANGELOG.md
@@ -1,5 +1,11 @@
 # @fusion-plugin-examples/paperclip-runtime
 
+## 0.2.70
+
+### Patch Changes
+
+- @fusion/plugin-sdk@0.56.0
+
 ## 0.2.69
 
 ### Patch Changes
diff --git a/plugins/fusion-plugin-paperclip-runtime/package.json b/plugins/fusion-plugin-paperclip-runtime/package.json
index acbc0c2281..cc413d9618 100644
--- a/plugins/fusion-plugin-paperclip-runtime/package.json
+++ b/plugins/fusion-plugin-paperclip-runtime/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@fusion-plugin-examples/paperclip-runtime",
-  "version": "0.2.69",
+  "version": "0.2.70",
   "type": "module",
   "description": "Paperclip runtime plugin for Fusion — provides AI agent web access capabilities",
   "keywords": [
diff --git a/plugins/fusion-plugin-reports/CHANGELOG.md b/plugins/fusion-plugin-reports/CHANGELOG.md
index 96cf568a8f..bf9e6f7188 100644
--- a/plugins/fusion-plugin-reports/CHANGELOG.md
+++ b/plugins/fusion-plugin-reports/CHANGELOG.md
@@ -1,5 +1,13 @@
 # @fusion-plugin-examples/reports
 
+## 0.1.39
+
+### Patch Changes
+
+- @fusion/core@0.56.0
+- @fusion/dashboard@0.56.0
+- @fusion/plugin-sdk@0.56.0
+
 ## 0.1.38
 
 ### Patch Changes
diff --git a/plugins/fusion-plugin-reports/package.json b/plugins/fusion-plugin-reports/package.json
index c4441930a7..fc187bba8c 100644
--- a/plugins/fusion-plugin-reports/package.json
+++ b/plugins/fusion-plugin-reports/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@fusion-plugin-examples/reports",
-  "version": "0.1.38",
+  "version": "0.1.39",
   "type": "module",
   "description": "Reports plugin for Fusion",
   "private": true,
diff --git a/plugins/fusion-plugin-roadmap/CHANGELOG.md b/plugins/fusion-plugin-roadmap/CHANGELOG.md
index ba5c8679a2..f55491f4e1 100644
--- a/plugins/fusion-plugin-roadmap/CHANGELOG.md
+++ b/plugins/fusion-plugin-roadmap/CHANGELOG.md
@@ -1,5 +1,12 @@
 # @fusion-plugin-examples/roadmap
 
+## 0.1.39
+
+### Patch Changes
+
+- @fusion/core@0.56.0
+- @fusion/plugin-sdk@0.56.0
+
 ## 0.1.38
 
 ### Patch Changes
diff --git a/plugins/fusion-plugin-roadmap/package.json b/plugins/fusion-plugin-roadmap/package.json
index ed4eb23b05..6bf65b5af6 100644
--- a/plugins/fusion-plugin-roadmap/package.json
+++ b/plugins/fusion-plugin-roadmap/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@fusion-plugin-examples/roadmap",
-  "version": "0.1.38",
+  "version": "0.1.39",
   "type": "module",
   "description": "Roadmap plugin package for Fusion",
   "private": true,
diff --git a/plugins/fusion-plugin-whatsapp-chat/CHANGELOG.md b/plugins/fusion-plugin-whatsapp-chat/CHANGELOG.md
index 41291b02cd..3afe98696f 100644
--- a/plugins/fusion-plugin-whatsapp-chat/CHANGELOG.md
+++ b/plugins/fusion-plugin-whatsapp-chat/CHANGELOG.md
@@ -1,5 +1,11 @@
 # @fusion-plugin-examples/whatsapp-chat
 
+## 0.1.39
+
+### Patch Changes
+
+- @fusion/plugin-sdk@0.56.0
+
 ## 0.1.38
 
 ### Patch Changes
diff --git a/plugins/fusion-plugin-whatsapp-chat/package.json b/plugins/fusion-plugin-whatsapp-chat/package.json
index 210ab07cf3..b66806fbb3 100644
--- a/plugins/fusion-plugin-whatsapp-chat/package.json
+++ b/plugins/fusion-plugin-whatsapp-chat/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@fusion-plugin-examples/whatsapp-chat",
-  "version": "0.1.38",
+  "version": "0.1.39",
   "type": "module",
   "description": "WhatsApp Web (Baileys) chat bridge for Fusion agents",
   "keywords": [

From 8d6c92ac2efd73e42b69700047e90bdf96b0fea7 Mon Sep 17 00:00:00 2001
From: Phil Larson <hello@phillarson.xyz>
Date: Sun, 5 Jul 2026 17:46:58 -0700
Subject: [PATCH 54/65] fix: preserve Hermes runtime chat session state

---
 .../dashboard/src/routes/register-chat-routes.ts  |  4 +++-
 packages/engine/src/project-engine.ts             |  5 +++++
 .../engine/src/runtimes/in-process-runtime.ts     |  9 +++++++++
 .../src/__tests__/cli-spawn.test.ts               |  6 ++++++
 .../fusion-plugin-hermes-runtime/src/cli-spawn.ts | 15 ++++++++-------
 .../src/runtime-adapter.ts                        |  6 +++++-
 plugins/fusion-plugin-hermes-runtime/src/types.ts |  4 ++++
 7 files changed, 40 insertions(+), 9 deletions(-)

diff --git a/packages/dashboard/src/routes/register-chat-routes.ts b/packages/dashboard/src/routes/register-chat-routes.ts
index 6fb09ce88e..8c1f7c0219 100644
--- a/packages/dashboard/src/routes/register-chat-routes.ts
+++ b/packages/dashboard/src/routes/register-chat-routes.ts
@@ -115,7 +115,9 @@ export function registerChatRoutes(ctx: ApiRoutesContext, deps: ChatRouteDeps):
     }
     const projectStore = await getOrCreateProjectStore(projectId);
     const chatStore = getOrCreateScopedChatStore(projectStore);
-    return getOrCreateScopedChatManager(projectStore, chatStore, options?.pluginRunner);
+    const engine = options?.engineManager?.getEngine(projectId);
+    const pluginRunner = engine?.getPluginRunner?.() ?? options?.pluginRunner;
+    return getOrCreateScopedChatManager(projectStore, chatStore, pluginRunner);
   }
   function validateModelPair(modelProvider: unknown, modelId: unknown): { modelProvider?: string; modelId?: string } {
     let normalizedProvider: string | undefined;
diff --git a/packages/engine/src/project-engine.ts b/packages/engine/src/project-engine.ts
index 6e87f913c9..b741227e4d 100644
--- a/packages/engine/src/project-engine.ts
+++ b/packages/engine/src/project-engine.ts
@@ -1042,6 +1042,11 @@ export class ProjectEngine {
     return this.runtime.getChatStore();
   }
 
+  /** Get the project-scoped PluginRunner (if initialized). */
+  getPluginRunner() {
+    return this.runtime.getPluginRunner();
+  }
+
   attachChatStore(chatStore: NotificationChatStore): void {
     this.notificationService?.attachChatStore(chatStore);
   }
diff --git a/packages/engine/src/runtimes/in-process-runtime.ts b/packages/engine/src/runtimes/in-process-runtime.ts
index 92344fcf35..ecd66d01c9 100644
--- a/packages/engine/src/runtimes/in-process-runtime.ts
+++ b/packages/engine/src/runtimes/in-process-runtime.ts
@@ -1368,6 +1368,15 @@ export class InProcessRuntime
     return this.chatStore;
   }
 
+  /**
+   * Get the project-scoped PluginRunner (if initialized).
+   * Dashboard chat needs this runner, not the top-level PluginLoader, so
+   * runtime hints such as `hermes` can resolve plugin runtimes correctly.
+   */
+  getPluginRunner(): PluginRunner | undefined {
+    return this.pluginRunner;
+  }
+
   /**
    * Get the project's Scheduler instance.
    * @throws Error if runtime has not been started
diff --git a/plugins/fusion-plugin-hermes-runtime/src/__tests__/cli-spawn.test.ts b/plugins/fusion-plugin-hermes-runtime/src/__tests__/cli-spawn.test.ts
index d06d39e546..ff4c250d3b 100644
--- a/plugins/fusion-plugin-hermes-runtime/src/__tests__/cli-spawn.test.ts
+++ b/plugins/fusion-plugin-hermes-runtime/src/__tests__/cli-spawn.test.ts
@@ -224,6 +224,12 @@ describe("parseHermesOutput", () => {
     expect(result.body).toBe("line1\nline2");
   });
 
+  it("accepts session_id emitted on stderr while keeping stderr out of the body", () => {
+    const result = parseHermesOutput("OK\n", "session_id: 20260427_120000_abcd12\n");
+    expect(result.sessionId).toBe("20260427_120000_abcd12");
+    expect(result.body).toBe("OK");
+  });
+
   it("throws when session_id line is missing", () => {
     expect(() => parseHermesOutput("some output without id", "stderr text")).toThrow(
       /missing session_id/,
diff --git a/plugins/fusion-plugin-hermes-runtime/src/cli-spawn.ts b/plugins/fusion-plugin-hermes-runtime/src/cli-spawn.ts
index b458dd9cd4..007ba5a592 100644
--- a/plugins/fusion-plugin-hermes-runtime/src/cli-spawn.ts
+++ b/plugins/fusion-plugin-hermes-runtime/src/cli-spawn.ts
@@ -309,18 +309,19 @@ function stripChrome(text: string): string {
  * Returns `{ body, sessionId }` on success or throws with a descriptive error.
  */
 export function parseHermesOutput(rawStdout: string, rawStderr: string): HermesCliResult {
-  const cleaned = cleanText(rawStdout);
-  const match = SESSION_ID_RE.exec(cleaned);
+  const cleanedStdout = cleanText(rawStdout);
+  const cleanedCombined = cleanText([rawStdout, rawStderr].filter(Boolean).join("\n"));
+  const match = SESSION_ID_RE.exec(cleanedStdout) ?? SESSION_ID_RE.exec(cleanedCombined);
 
   if (!match) {
-    const combined = [rawStdout, rawStderr].filter(Boolean).join("\n");
-    throw new Error(`hermes: missing session_id in output.\n${combined}`);
+    throw new Error(`hermes: missing session_id in output.\n${cleanedCombined}`);
   }
 
   const sessionId = match[1]!;
-  // Body is everything before the session_id line.
-  const sessionIdLineStart = cleaned.lastIndexOf("\nsession_id:");
-  const bodyRaw = sessionIdLineStart >= 0 ? cleaned.slice(0, sessionIdLineStart) : cleaned;
+  // Body is stdout before the session_id line. Recent Hermes builds can emit
+  // the session_id marker on stderr, so do not treat stderr as assistant text.
+  const sessionIdLineStart = cleanedStdout.lastIndexOf("\nsession_id:");
+  const bodyRaw = sessionIdLineStart >= 0 ? cleanedStdout.slice(0, sessionIdLineStart) : cleanedStdout;
   const body = stripChrome(bodyRaw);
 
   return { body, sessionId };
diff --git a/plugins/fusion-plugin-hermes-runtime/src/runtime-adapter.ts b/plugins/fusion-plugin-hermes-runtime/src/runtime-adapter.ts
index 550a94fc03..472de4390e 100644
--- a/plugins/fusion-plugin-hermes-runtime/src/runtime-adapter.ts
+++ b/plugins/fusion-plugin-hermes-runtime/src/runtime-adapter.ts
@@ -51,10 +51,12 @@ export class HermesRuntimeAdapter implements AgentRuntime {
   }
 
   async createSession(options: AgentRuntimeOptions): Promise<AgentSessionResult> {
+    const messages: unknown[] = [];
     const session: HermesStreamSession = {
       model: undefined,
       systemPrompt: options.systemPrompt,
-      messages: [],
+      messages,
+      state: { messages },
       apiKey: undefined,
       thinkingLevel: undefined,
       sessionId: "",
@@ -82,12 +84,14 @@ export class HermesRuntimeAdapter implements AgentRuntime {
     const promptWithContext = resumeId
       ? prompt
       : `${session.fusedSystemPrompt}\n\nUser request:\n${prompt}`;
+    session.messages.push({ role: "user", content: prompt });
     const result = await invokeHermesCli(promptWithContext, this.settings, resumeId);
 
     session.sessionId = result.sessionId;
     session.lastModelDescription = this.describeFromSettings();
 
     if (result.body) {
+      session.messages.push({ role: "assistant", content: result.body });
       session.callbacks.onText?.(result.body);
     }
   }
diff --git a/plugins/fusion-plugin-hermes-runtime/src/types.ts b/plugins/fusion-plugin-hermes-runtime/src/types.ts
index 55dabe2e4f..1b44d706b2 100644
--- a/plugins/fusion-plugin-hermes-runtime/src/types.ts
+++ b/plugins/fusion-plugin-hermes-runtime/src/types.ts
@@ -23,6 +23,10 @@ export interface HermesStreamSession {
   model: unknown;
   systemPrompt: string;
   messages: unknown[];
+  state: {
+    messages: unknown[];
+    errorMessage?: string;
+  };
   apiKey: string | undefined;
   thinkingLevel: string | undefined;
   sessionId: string;

From a734d9f0b93fed31a1f1bab7c92aa96adb5575ee Mon Sep 17 00:00:00 2001
From: Phil Larson <hello@phillarson.xyz>
Date: Sun, 5 Jul 2026 18:13:47 -0700
Subject: [PATCH 55/65] fix: address Hermes runtime PR review feedback

---
 .changeset/proud-horses-chat.md                   |  7 +++++++
 packages/dashboard/src/chat-project-services.ts   |  8 +++++++-
 packages/dashboard/src/chat.ts                    |  8 ++++++++
 .../dashboard/src/routes/register-chat-routes.ts  |  5 +++--
 .../src/__tests__/cli-spawn.test.ts               |  6 ++++++
 .../src/__tests__/runtime-adapter.test.ts         | 13 +++++++++++++
 .../fusion-plugin-hermes-runtime/src/cli-spawn.ts |  6 +++---
 .../src/runtime-adapter.ts                        | 15 ++++++++++++---
 8 files changed, 59 insertions(+), 9 deletions(-)
 create mode 100644 .changeset/proud-horses-chat.md

diff --git a/.changeset/proud-horses-chat.md b/.changeset/proud-horses-chat.md
new file mode 100644
index 0000000000..f27ce913a5
--- /dev/null
+++ b/.changeset/proud-horses-chat.md
@@ -0,0 +1,7 @@
+---
+"@runfusion/fusion": patch
+---
+
+summary: Preserve Hermes chat session state and project runtime routing more reliably.
+category: fix
+dev: Refreshes cached project chat plugin runners and hardens Hermes CLI session/error handling.
diff --git a/packages/dashboard/src/chat-project-services.ts b/packages/dashboard/src/chat-project-services.ts
index 1b5dd19cfe..20bfe0642a 100644
--- a/packages/dashboard/src/chat-project-services.ts
+++ b/packages/dashboard/src/chat-project-services.ts
@@ -90,10 +90,16 @@ export function getOrCreateScopedChatManager(
   store: TaskStore,
   chatStore: ChatStore,
   pluginRunner?: ConstructorParameters<typeof ChatManager>[3],
+  refreshPluginRunner = false,
 ): ChatManager {
   const key = store.getFusionDir();
   const cached = scopedChatManagerCache.get(key);
-  if (cached) return cached;
+  if (cached) {
+    if (refreshPluginRunner && pluginRunner) {
+      cached.setPluginRunner(pluginRunner);
+    }
+    return cached;
+  }
   const agentStore = new AgentStore({ rootDir: store.getFusionDir() });
   const manager = new ChatManager(
     chatStore,
diff --git a/packages/dashboard/src/chat.ts b/packages/dashboard/src/chat.ts
index cb5a781c20..ec5ece0339 100644
--- a/packages/dashboard/src/chat.ts
+++ b/packages/dashboard/src/chat.ts
@@ -1075,6 +1075,14 @@ export class ChatManager {
     private taskStore?: TaskStore,
   ) {}
 
+  /**
+   * FNXC:ProjectChatRuntime 2026-07-05-18:10:
+   * Project chat managers can be created before a project engine finishes booting. Refreshing the plugin runner after construction prevents early requests from permanently binding Hermes/runtime hints to the global fallback runner; callers must only refresh from a confirmed project runner so transient engine unavailability cannot downgrade a scoped manager.
+   */
+  setPluginRunner(pluginRunner: ChatManager["pluginRunner"] | undefined): void {
+    this.pluginRunner = pluginRunner;
+  }
+
   private getPluginRunnerForSkillSelection(): Parameters<typeof buildSessionSkillContextSync>[3] {
     return this.pluginRunner?.getPluginSkills
       ? (this.pluginRunner as unknown as Parameters<typeof buildSessionSkillContextSync>[3])
diff --git a/packages/dashboard/src/routes/register-chat-routes.ts b/packages/dashboard/src/routes/register-chat-routes.ts
index 8c1f7c0219..8499558f2e 100644
--- a/packages/dashboard/src/routes/register-chat-routes.ts
+++ b/packages/dashboard/src/routes/register-chat-routes.ts
@@ -116,8 +116,9 @@ export function registerChatRoutes(ctx: ApiRoutesContext, deps: ChatRouteDeps):
     const projectStore = await getOrCreateProjectStore(projectId);
     const chatStore = getOrCreateScopedChatStore(projectStore);
     const engine = options?.engineManager?.getEngine(projectId);
-    const pluginRunner = engine?.getPluginRunner?.() ?? options?.pluginRunner;
-    return getOrCreateScopedChatManager(projectStore, chatStore, pluginRunner);
+    const projectPluginRunner = engine?.getPluginRunner?.();
+    const pluginRunner = projectPluginRunner ?? options?.pluginRunner;
+    return getOrCreateScopedChatManager(projectStore, chatStore, pluginRunner, Boolean(projectPluginRunner));
   }
   function validateModelPair(modelProvider: unknown, modelId: unknown): { modelProvider?: string; modelId?: string } {
     let normalizedProvider: string | undefined;
diff --git a/plugins/fusion-plugin-hermes-runtime/src/__tests__/cli-spawn.test.ts b/plugins/fusion-plugin-hermes-runtime/src/__tests__/cli-spawn.test.ts
index ff4c250d3b..b3bbccfa23 100644
--- a/plugins/fusion-plugin-hermes-runtime/src/__tests__/cli-spawn.test.ts
+++ b/plugins/fusion-plugin-hermes-runtime/src/__tests__/cli-spawn.test.ts
@@ -230,6 +230,12 @@ describe("parseHermesOutput", () => {
     expect(result.body).toBe("OK");
   });
 
+  it("strips a leading stdout session_id marker from an empty assistant body", () => {
+    const result = parseHermesOutput("session_id: 20260427_120000_abcd12\n", "");
+    expect(result.sessionId).toBe("20260427_120000_abcd12");
+    expect(result.body).toBe("");
+  });
+
   it("throws when session_id line is missing", () => {
     expect(() => parseHermesOutput("some output without id", "stderr text")).toThrow(
       /missing session_id/,
diff --git a/plugins/fusion-plugin-hermes-runtime/src/__tests__/runtime-adapter.test.ts b/plugins/fusion-plugin-hermes-runtime/src/__tests__/runtime-adapter.test.ts
index e0df7e89d3..aeeb155cb5 100644
--- a/plugins/fusion-plugin-hermes-runtime/src/__tests__/runtime-adapter.test.ts
+++ b/plugins/fusion-plugin-hermes-runtime/src/__tests__/runtime-adapter.test.ts
@@ -68,6 +68,12 @@ describe("HermesRuntimeAdapter — promptWithFallback", () => {
     expect(onText).toHaveBeenCalledWith("hello from hermes");
     // Session id is captured for next call
     expect(session.sessionId).toBe("20260427_120000_abc123");
+    expect(session.messages).toEqual([
+      { role: "user", content: "first prompt" },
+      { role: "assistant", content: "hello from hermes" },
+    ]);
+    expect(session.state.messages).toBe(session.messages);
+    expect(session.state.errorMessage).toBeUndefined();
   });
 
   it("passes captured session id as --resume on subsequent calls", async () => {
@@ -94,6 +100,8 @@ describe("HermesRuntimeAdapter — promptWithFallback", () => {
     await expect(adapter.promptWithFallback(session, "p")).rejects.toThrow(
       /missing session_id/,
     );
+    expect(session.messages).toEqual([]);
+    expect(session.state.errorMessage).toBe("hermes: missing session_id");
   });
 
   it("does NOT call onText when body is empty", async () => {
@@ -110,6 +118,11 @@ describe("HermesRuntimeAdapter — promptWithFallback", () => {
     });
     await adapter.promptWithFallback(session, "p");
     expect(onText).not.toHaveBeenCalled();
+    expect(session.messages).toEqual([
+      { role: "user", content: "p" },
+      { role: "assistant", content: "" },
+    ]);
+    expect(session.state.errorMessage).toBeUndefined();
   });
 });
 
diff --git a/plugins/fusion-plugin-hermes-runtime/src/cli-spawn.ts b/plugins/fusion-plugin-hermes-runtime/src/cli-spawn.ts
index 007ba5a592..20be6950c9 100644
--- a/plugins/fusion-plugin-hermes-runtime/src/cli-spawn.ts
+++ b/plugins/fusion-plugin-hermes-runtime/src/cli-spawn.ts
@@ -311,7 +311,8 @@ function stripChrome(text: string): string {
 export function parseHermesOutput(rawStdout: string, rawStderr: string): HermesCliResult {
   const cleanedStdout = cleanText(rawStdout);
   const cleanedCombined = cleanText([rawStdout, rawStderr].filter(Boolean).join("\n"));
-  const match = SESSION_ID_RE.exec(cleanedStdout) ?? SESSION_ID_RE.exec(cleanedCombined);
+  const stdoutMatch = SESSION_ID_RE.exec(cleanedStdout);
+  const match = stdoutMatch ?? SESSION_ID_RE.exec(cleanedCombined);
 
   if (!match) {
     throw new Error(`hermes: missing session_id in output.\n${cleanedCombined}`);
@@ -320,8 +321,7 @@ export function parseHermesOutput(rawStdout: string, rawStderr: string): HermesC
   const sessionId = match[1]!;
   // Body is stdout before the session_id line. Recent Hermes builds can emit
   // the session_id marker on stderr, so do not treat stderr as assistant text.
-  const sessionIdLineStart = cleanedStdout.lastIndexOf("\nsession_id:");
-  const bodyRaw = sessionIdLineStart >= 0 ? cleanedStdout.slice(0, sessionIdLineStart) : cleanedStdout;
+  const bodyRaw = stdoutMatch ? cleanedStdout.slice(0, stdoutMatch.index) : cleanedStdout;
   const body = stripChrome(bodyRaw);
 
   return { body, sessionId };
diff --git a/plugins/fusion-plugin-hermes-runtime/src/runtime-adapter.ts b/plugins/fusion-plugin-hermes-runtime/src/runtime-adapter.ts
index 472de4390e..5643d066af 100644
--- a/plugins/fusion-plugin-hermes-runtime/src/runtime-adapter.ts
+++ b/plugins/fusion-plugin-hermes-runtime/src/runtime-adapter.ts
@@ -84,14 +84,23 @@ export class HermesRuntimeAdapter implements AgentRuntime {
     const promptWithContext = resumeId
       ? prompt
       : `${session.fusedSystemPrompt}\n\nUser request:\n${prompt}`;
-    session.messages.push({ role: "user", content: prompt });
-    const result = await invokeHermesCli(promptWithContext, this.settings, resumeId);
+    const userMessage = { role: "user", content: prompt };
+    session.messages.push(userMessage);
+    let result: Awaited<ReturnType<typeof invokeHermesCli>>;
+    try {
+      result = await invokeHermesCli(promptWithContext, this.settings, resumeId);
+      session.state.errorMessage = undefined;
+    } catch (err) {
+      session.messages.pop();
+      session.state.errorMessage = err instanceof Error ? err.message : String(err);
+      throw err;
+    }
 
     session.sessionId = result.sessionId;
     session.lastModelDescription = this.describeFromSettings();
 
+    session.messages.push({ role: "assistant", content: result.body });
     if (result.body) {
-      session.messages.push({ role: "assistant", content: result.body });
       session.callbacks.onText?.(result.body);
     }
   }

From ed823c794caba762087a716a3e759bd2b7ffe6a0 Mon Sep 17 00:00:00 2001
From: gsxdsm <gsxdsm@users.noreply.github.com>
Date: Sun, 5 Jul 2026 18:47:40 -0700
Subject: [PATCH 56/65] fix: preserve Claude OAuth scopes on token refresh so
 inference keeps working
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The Anthropic OAuth refresh request sent `scope: user:profile`, which under
RFC 6749 §6 re-issues the access token with exactly that scope — stripping
`user:inference` and 403-ing every model call while the account still read
as "logged in via OAuth". Stop sending `scope` on refresh (Anthropic then
preserves the originally-granted scopes, matching pi-ai), and widen
ANTHROPIC_DEFAULT_SCOPES to mirror pi-ai's full granted Claude Code scope
set so any fallback describes a usable token.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 .../anthropic-oauth-refresh-preserve-scopes.md |  7 +++++++
 .changeset/anthropic-oauth-refresh-scope.md    |  7 +++++++
 .../engine/src/__tests__/auth-storage.test.ts  | 11 +++++++++--
 packages/engine/src/auth-storage.ts            | 18 ++++++++++++++++--
 4 files changed, 39 insertions(+), 4 deletions(-)
 create mode 100644 .changeset/anthropic-oauth-refresh-preserve-scopes.md
 create mode 100644 .changeset/anthropic-oauth-refresh-scope.md

diff --git a/.changeset/anthropic-oauth-refresh-preserve-scopes.md b/.changeset/anthropic-oauth-refresh-preserve-scopes.md
new file mode 100644
index 0000000000..796fdd5d7f
--- /dev/null
+++ b/.changeset/anthropic-oauth-refresh-preserve-scopes.md
@@ -0,0 +1,7 @@
+---
+"@runfusion/fusion": patch
+---
+
+summary: Fix Claude subscription login so model calls stop 403-ing after an OAuth token refresh.
+category: fix
+dev: `refreshAnthropicOAuthCredential` no longer sends `scope` on the refresh request (RFC 6749 §6 re-issues the token with exactly that scope, which stripped `user:inference` and narrowed refreshed tokens to `user:profile`). `ANTHROPIC_DEFAULT_SCOPES` now mirrors pi-ai's full granted Claude Code scope set so any fallback describes a usable token.
diff --git a/.changeset/anthropic-oauth-refresh-scope.md b/.changeset/anthropic-oauth-refresh-scope.md
new file mode 100644
index 0000000000..31c262f722
--- /dev/null
+++ b/.changeset/anthropic-oauth-refresh-scope.md
@@ -0,0 +1,7 @@
+---
+"@runfusion/fusion": patch
+---
+
+summary: Fix Anthropic subscription showing "logged in" while all model calls fail.
+category: fix
+dev: OAuth token refresh in `packages/engine/src/auth-storage.ts` sent a `scope` param (defaulting to `user:profile`), which per RFC 6749 §6 re-issued the access token narrowed to that scope and stripped `user:inference` — so refreshed tokens 403'd on every model call. Refresh now omits `scope` (preserving the originally-granted scopes, matching pi-ai's own refresh), and `ANTHROPIC_DEFAULT_SCOPES` mirrors the full Claude Code scope set. Existing narrowed tokens need one re-login to obtain a fresh broad grant.
diff --git a/packages/engine/src/__tests__/auth-storage.test.ts b/packages/engine/src/__tests__/auth-storage.test.ts
index bbbfd3ac19..bcb56fa352 100644
--- a/packages/engine/src/__tests__/auth-storage.test.ts
+++ b/packages/engine/src/__tests__/auth-storage.test.ts
@@ -415,11 +415,16 @@ describe("createFusionAuthStorage", () => {
       // subscription id only — the raw `anthropic` slot stays empty.
       expect(await authStorage.getApiKey("anthropic")).toBe("refreshed-subscription-access-token");
       expect(await authStorage.getApiKey("anthropic-subscription")).toBe("refreshed-subscription-access-token");
+      // FNXC:ClaudeOAuth 2026-07-05-18:52: the refresh request MUST NOT send `scope`.
+      // Per RFC 6749 §6 an included scope re-issues the token with exactly that scope
+      // (never broader), which previously narrowed refreshed tokens to profile-only and
+      // stripped `user:inference` — leaving the account "logged in" yet 403ing on every
+      // model call. Omitting scope makes Anthropic preserve the originally-granted scopes.
       expect(fetchMock).toHaveBeenCalledWith(
         "https://platform.claude.com/v1/oauth/token",
         expect.objectContaining({
           method: "POST",
-          body: expect.stringContaining("\"scope\":\"user:profile org:create_api_key\""),
+          body: expect.not.stringContaining("\"scope\""),
         }),
       );
       expect(authStorage.get("anthropic-subscription")).toEqual({
@@ -739,11 +744,13 @@ describe("createFusionAuthStorage", () => {
     const authStorage = createFusionAuthStorage();
 
     expect(await authStorage.getApiKey("anthropic")).toBe("refreshed-claude-access-token");
+    // FNXC:ClaudeOAuth 2026-07-05-18:52: refresh must omit `scope` so Anthropic preserves
+    // the original grant (RFC 6749 §6); sending it previously stripped `user:inference`.
     expect(fetchMock).toHaveBeenCalledWith(
       "https://platform.claude.com/v1/oauth/token",
       expect.objectContaining({
         method: "POST",
-        body: expect.stringContaining("\"scope\":\"user:profile org:create_api_key\""),
+        body: expect.not.stringContaining("\"scope\""),
       }),
     );
     expect(authStorage.get("anthropic")).toEqual({
diff --git a/packages/engine/src/auth-storage.ts b/packages/engine/src/auth-storage.ts
index da3fb15595..2a830942b1 100644
--- a/packages/engine/src/auth-storage.ts
+++ b/packages/engine/src/auth-storage.ts
@@ -33,7 +33,18 @@ const ANTHROPIC_PROVIDER_ID = "anthropic";
 const ANTHROPIC_SUBSCRIPTION_PROVIDER_ID = "anthropic-subscription";
 const ANTHROPIC_TOKEN_ENDPOINT = "https://platform.claude.com/v1/oauth/token";
 const ANTHROPIC_OAUTH_CLIENT_ID = "9d1c250a-e61b-44d9-88ed-5944d1962f5e";
-const ANTHROPIC_DEFAULT_SCOPES = ["user:profile"];
+/*
+FNXC:ClaudeOAuth 2026-07-05-18:52:
+Anthropic subscription login (delegated to pi-ai) grants the full Claude Code scope set — `user:inference` is what authorizes model calls. Earlier this constant was `["user:profile"]`, which was WRONG twice over: (1) it under-describes the token pi-ai actually obtains, and (2) it was fed into the refresh request's `scope` param, which under RFC 6749 §6 NARROWS the refreshed access token to profile-only and strips `user:inference`. The symptom: the account reads "logged in via OAuth" (token present + unexpired) yet every model call 403s with "OAuth token does not meet scope requirement any_of(user:inference, ...)". The default must mirror pi-ai's granted scopes so any fallback describes a usable token, and the refresh path (below) must NOT send it as a narrowing scope.
+*/
+const ANTHROPIC_DEFAULT_SCOPES = [
+  "org:create_api_key",
+  "user:profile",
+  "user:inference",
+  "user:sessions:claude_code",
+  "user:mcp_servers",
+  "user:file_upload",
+];
 const OAUTH_REFRESH_TIMEOUT_MS = 10_000;
 const OAUTH_REFRESH_FAILURE_COOLDOWN_MS = 30_000;
 
@@ -212,6 +223,10 @@ async function refreshAnthropicOAuthCredential(credential: StoredCredential): Pr
     Fusion must renew expired Claude OAuth credentials with the stored refresh token so users are not forced through repeated manual Claude re-login when the access token expires.
     Persist the rotated access token in Fusion auth storage because model execution and dashboard usage resolve credentials through different runtime paths.
     */
+    /*
+    FNXC:ClaudeOAuth 2026-07-05-18:52:
+    Do NOT send `scope` on refresh. RFC 6749 §6: a refresh request that includes `scope` re-issues the access token with EXACTLY that scope (never broader), so sending our stored/derived scope list can only strip capabilities — and did: it narrowed refreshed tokens to `user:profile` and broke inference. Omitting `scope` makes Anthropic preserve the originally-granted scopes (this is what pi-ai's own `refreshAnthropicToken` does). `scopes` is still resolved above and used only as the parseScopes fallback for the persisted credential record.
+    */
     const response = await fetch(ANTHROPIC_TOKEN_ENDPOINT, {
       method: "POST",
       headers: {
@@ -222,7 +237,6 @@ async function refreshAnthropicOAuthCredential(credential: StoredCredential): Pr
         grant_type: "refresh_token",
         refresh_token: refresh,
         client_id: ANTHROPIC_OAUTH_CLIENT_ID,
-        scope: scopes.join(" "),
       }),
       signal: controller.signal,
     });

From 670c41345b453f90b57e0aed1c7548f084e25b4f Mon Sep 17 00:00:00 2001
From: gsxdsm <gsxdsm@users.noreply.github.com>
Date: Sun, 5 Jul 2026 18:50:37 -0700
Subject: [PATCH 57/65] chore: drop duplicate changeset for the OAuth refresh
 scope fix

Both changesets in ed823c794 describe the same fix; keep the more complete one.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 .changeset/anthropic-oauth-refresh-preserve-scopes.md | 7 -------
 1 file changed, 7 deletions(-)
 delete mode 100644 .changeset/anthropic-oauth-refresh-preserve-scopes.md

diff --git a/.changeset/anthropic-oauth-refresh-preserve-scopes.md b/.changeset/anthropic-oauth-refresh-preserve-scopes.md
deleted file mode 100644
index 796fdd5d7f..0000000000
--- a/.changeset/anthropic-oauth-refresh-preserve-scopes.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": patch
----
-
-summary: Fix Claude subscription login so model calls stop 403-ing after an OAuth token refresh.
-category: fix
-dev: `refreshAnthropicOAuthCredential` no longer sends `scope` on the refresh request (RFC 6749 §6 re-issues the token with exactly that scope, which stripped `user:inference` and narrowed refreshed tokens to `user:profile`). `ANTHROPIC_DEFAULT_SCOPES` now mirrors pi-ai's full granted Claude Code scope set so any fallback describes a usable token.

From b9d60b3c39606a302719a08b15457aae37a028cf Mon Sep 17 00:00:00 2001
From: gsxdsm <gsxdsm@users.noreply.github.com>
Date: Sun, 5 Jul 2026 18:56:24 -0700
Subject: [PATCH 58/65] FN-7602: fix Record/Clear button overlap in Keyboard
 Shortcuts rows

Fixes overlapping Record and Clear buttons on the Keyboard Shortcuts settings rows by replacing the icon-only button class with a text button class and locking layout with flex-shrink.

- Swap ShortcutCaptureInput Record/Clear buttons off the icon-only `btn-icon` class (which forced line-height:0 and a 36px mobile square, clipping labels) onto a text-button class
- Add `.shortcut-capture` row CSS with `flex-shrink:0` on controls so the input and buttons never overlap and stack cleanly on mobile
- Add regression tests covering the Keyboard Shortcuts section layout
- Add changeset documenting the fix

Files changed:
 .changeset/fn-7602-shortcut-row-layout.md          |  7 ++
 .../dashboard/app/components/SettingsModal.css     | 17 ++++
 .../settings/sections/ShortcutCaptureInput.tsx     | 14 +++-
 .../__tests__/KeyboardShortcutsSection.test.tsx    | 95 ++++++++++++++++++++++
 4 files changed, 131 insertions(+), 2 deletions(-)

Fusion-Task-Id: FN-7602

Fusion-Task-Lineage: 50cf6975-f0fb-42dd-87b0-50578977a0f4

Co-authored-by: Fusion (runfusion.ai) <noreply@runfusion.ai>
---
 .changeset/fn-7602-shortcut-row-layout.md     |  7 ++
 .../app/components/SettingsModal.css          | 17 ++++
 .../sections/ShortcutCaptureInput.tsx         | 14 ++-
 .../KeyboardShortcutsSection.test.tsx         | 95 +++++++++++++++++++
 4 files changed, 131 insertions(+), 2 deletions(-)
 create mode 100644 .changeset/fn-7602-shortcut-row-layout.md

diff --git a/.changeset/fn-7602-shortcut-row-layout.md b/.changeset/fn-7602-shortcut-row-layout.md
new file mode 100644
index 0000000000..908fbba219
--- /dev/null
+++ b/.changeset/fn-7602-shortcut-row-layout.md
@@ -0,0 +1,7 @@
+---
+"@runfusion/fusion": patch
+---
+
+summary: Fix overlapping Record and Clear buttons in the Keyboard Shortcuts settings rows on desktop and mobile.
+category: fix
+dev: The shortcut-capture Record/Clear buttons no longer use the icon-only `btn-icon` class (which set `line-height:0` and a mobile 36px square, clipping/overlapping the text labels); they use a text-button class and the `.shortcut-capture` row locks buttons with `flex-shrink:0` so the input and controls never overlap, stacking cleanly on mobile.
diff --git a/packages/dashboard/app/components/SettingsModal.css b/packages/dashboard/app/components/SettingsModal.css
index dbc288c1b0..21c5122a70 100644
--- a/packages/dashboard/app/components/SettingsModal.css
+++ b/packages/dashboard/app/components/SettingsModal.css
@@ -2550,6 +2550,17 @@ FN-7553's dedicated Keyboard Shortcuts section groups every action under a categ
   border-bottom: 0;
 }
 
+/*
+FNXC:DashboardShortcuts 2026-07-05-00:00:
+FN-7602 fixes an overlap bug: Record/Clear previously used the icon-only `btn-icon` class
+(line-height:0 + mobile 36px square), which clipped/overlapped their text labels
+("Record"/"Recording…"/"Clear") against the input and each other (IMG_1305). The input
+keeps `flex: 1 1 auto; min-width: 0;` so it shrinks first, while the buttons get
+`flex-shrink: 0; white-space: nowrap;` so their content-sized width (including the longer
+"Recording…" label) is never crushed or allowed to overlap a neighbor on desktop. Below
+768px the row stacks to a column so the buttons sit on their own row under the full-width
+input, still non-overlapping.
+*/
 .shortcut-capture {
   display: flex;
   align-items: center;
@@ -2566,6 +2577,12 @@ FN-7553's dedicated Keyboard Shortcuts section groups every action under a categ
   border-color: var(--color-error);
 }
 
+.shortcut-capture__record,
+.shortcut-capture__clear {
+  flex-shrink: 0;
+  white-space: nowrap;
+}
+
 .shortcut-capture__record--active {
   color: var(--color-warning);
 }
diff --git a/packages/dashboard/app/components/settings/sections/ShortcutCaptureInput.tsx b/packages/dashboard/app/components/settings/sections/ShortcutCaptureInput.tsx
index 94ea657ee5..1e77ccbb25 100644
--- a/packages/dashboard/app/components/settings/sections/ShortcutCaptureInput.tsx
+++ b/packages/dashboard/app/components/settings/sections/ShortcutCaptureInput.tsx
@@ -91,9 +91,19 @@ export function ShortcutCaptureInput({ id, value, defaultValue, invalid, describ
         }}
         onChange={(event) => onChange(event.target.value)}
       />
+      {/*
+      FNXC:DashboardShortcuts 2026-07-05-00:00:
+      Record/Clear are TEXT-labeled buttons ("Record"/"Recording…"/"Clear"), not icon-only
+      controls. `btn-icon` sets `line-height: 0` and a mobile 36px square meant for SVG-only
+      buttons — applying it here clipped the label's line box and, at mobile widths, forced
+      "Recording…" to overflow the fixed square and overlap the Clear button/input
+      (reported via screenshot IMG_1305). Use `btn-sm` instead so labels render on a normal
+      line-height with content-sized width; `.shortcut-capture` locks these buttons with
+      `flex-shrink: 0` so they never collide with the input or each other.
+      */}
       <button
         type="button"
-        className={`btn btn-icon shortcut-capture__record${recording ? " shortcut-capture__record--active" : ""}`}
+        className={`btn btn-sm shortcut-capture__record${recording ? " shortcut-capture__record--active" : ""}`}
         aria-pressed={recording}
         title={recording ? t("settings.keyboardShortcuts.recordingTitle", "Recording… press Escape to cancel") : t("settings.keyboardShortcuts.recordTitle", "Record a new shortcut")}
         onClick={() => (recording ? stopRecording() : startRecording())}
@@ -102,7 +112,7 @@ export function ShortcutCaptureInput({ id, value, defaultValue, invalid, describ
       </button>
       <button
         type="button"
-        className="btn btn-icon shortcut-capture__clear"
+        className="btn btn-sm shortcut-capture__clear"
         title={t("settings.keyboardShortcuts.clearTitle", "Disable this shortcut")}
         onClick={() => {
           if (recording) stopRecording();
diff --git a/packages/dashboard/app/components/settings/sections/__tests__/KeyboardShortcutsSection.test.tsx b/packages/dashboard/app/components/settings/sections/__tests__/KeyboardShortcutsSection.test.tsx
index 1b409a6899..0afb56f494 100644
--- a/packages/dashboard/app/components/settings/sections/__tests__/KeyboardShortcutsSection.test.tsx
+++ b/packages/dashboard/app/components/settings/sections/__tests__/KeyboardShortcutsSection.test.tsx
@@ -1,7 +1,10 @@
+import { readFileSync } from "node:fs";
 import { fireEvent, render, screen } from "@testing-library/react";
 import { describe, expect, it, vi } from "vitest";
 import { ShortcutCaptureInput } from "../ShortcutCaptureInput";
 
+const settingsModalCss = readFileSync("app/components/SettingsModal.css", "utf8");
+
 /*
 FNXC:DashboardShortcuts 2026-07-04-00:00:
 FN-7553 covers the press-to-record capture control in isolation before the
@@ -110,4 +113,96 @@ describe("ShortcutCaptureInput", () => {
     );
     expect(container.querySelector('[data-shortcuts-ignore="true"]')).toBeTruthy();
   });
+
+  /*
+  FNXC:DashboardShortcuts 2026-07-05-00:00:
+  Regression for FN-7602 (IMG_1305): Record/Clear previously carried the
+  icon-only `btn-icon` class (line-height:0 + mobile 36px square), which
+  clipped/overlapped the text labels against the input and each other. These
+  tests assert the buttons use a text-appropriate class across idle,
+  recording, invalid, and cleared/disabled states, and that the
+  `.shortcut-capture` CSS locks a non-overlapping desktop row / mobile stack.
+  */
+  describe("row layout (FN-7602 no-overlap regression)", () => {
+    it("never applies the icon-only btn-icon class to the Record or Clear buttons, idle", () => {
+      render(
+        <ShortcutCaptureInput id="test-shortcut" value="Ctrl+E" defaultValue="Ctrl+E" invalid={false} describedById="test-hint" onChange={vi.fn()} />,
+      );
+      const recordBtn = screen.getByRole("button", { name: /^record$/i });
+      const clearBtn = screen.getByRole("button", { name: /clear/i });
+
+      for (const btn of [recordBtn, clearBtn]) {
+        expect(btn.className.split(/\s+/)).not.toContain("btn-icon");
+        expect(btn.className.split(/\s+/)).toContain("btn");
+        expect(btn.className).toMatch(/\bbtn-sm\b|\bbtn--sm\b/);
+      }
+    });
+
+    it("keeps the Record button text-classed and readable while recording (longer label)", () => {
+      render(
+        <ShortcutCaptureInput id="test-shortcut" value="Ctrl+E" defaultValue="Ctrl+E" invalid={false} describedById="test-hint" onChange={vi.fn()} />,
+      );
+      fireEvent.click(screen.getByRole("button", { name: /^record$/i }));
+
+      const recordingBtn = screen.getByRole("button", { name: /recording/i });
+      expect(recordingBtn.className.split(/\s+/)).not.toContain("btn-icon");
+      expect(recordingBtn.className).toContain("shortcut-capture__record--active");
+      expect(recordingBtn).toHaveAttribute("aria-pressed", "true");
+      // Only a single Record/Recording control exists — no duplicate/overlapping control.
+      expect(screen.getAllByRole("button", { name: /record/i })).toHaveLength(1);
+
+      fireEvent.keyDown(document, { key: "Escape" });
+    });
+
+    it("keeps the invalid-binding style and buttons off btn-icon while invalid", () => {
+      render(
+        <ShortcutCaptureInput id="test-shortcut" value="Bogus" defaultValue="Ctrl+E" invalid={true} describedById="test-hint" onChange={vi.fn()} />,
+      );
+      expect(screen.getByRole("textbox").className).toContain("shortcut-capture__input--invalid");
+      for (const btn of [screen.getByRole("button", { name: /^record$/i }), screen.getByRole("button", { name: /clear/i })]) {
+        expect(btn.className.split(/\s+/)).not.toContain("btn-icon");
+      }
+    });
+
+    it("still clears a bound value without btn-icon interfering", () => {
+      const onChange = vi.fn();
+      render(
+        <ShortcutCaptureInput id="test-shortcut" value="Ctrl+E" defaultValue="Ctrl+E" invalid={false} describedById="test-hint" onChange={onChange} />,
+      );
+      fireEvent.click(screen.getByRole("button", { name: /clear/i }));
+      expect(onChange).toHaveBeenCalledWith("");
+    });
+
+    it("locks the desktop .shortcut-capture row so the input shrinks and buttons never overlap", () => {
+      const rowRule = settingsModalCss.match(/(?<!__record--active|__input--invalid)\.shortcut-capture\s*\{([^}]*)\}/)?.[1] ?? "";
+      const inputRule = settingsModalCss.match(/\.shortcut-capture__input\s*\{([^}]*)\}/)?.[1] ?? "";
+      const buttonRule = settingsModalCss.match(/\.shortcut-capture__record,\s*\n?\s*\.shortcut-capture__clear\s*\{([^}]*)\}/)?.[1] ?? "";
+
+      expect(rowRule).toContain("display: flex;");
+      expect(inputRule).toContain("flex: 1 1 auto;");
+      expect(inputRule).toContain("min-width: 0;");
+      expect(buttonRule).toContain("flex-shrink: 0;");
+      expect(buttonRule).toContain("white-space: nowrap;");
+    });
+
+    it("stacks .shortcut-capture on mobile with a full-width input and no overlapping buttons", () => {
+      // Anchor to the specific shortcut-capture mobile media block (the one
+      // immediately following `.shortcut-conflict-banner`) rather than a
+      // lazily-scoped regex, since the stylesheet has several unrelated
+      // `@media (max-width: 768px)` blocks earlier in the file that a naive
+      // lazy `[\s\S]*?` could otherwise bleed across.
+      const shortcutMediaStart = settingsModalCss.indexOf(".shortcut-conflict-banner");
+      const shortcutMediaBlock = settingsModalCss.slice(shortcutMediaStart).match(/@media \(max-width: 768px\) \{([\s\S]*?)\n\}/)?.[1] ?? "";
+      const mobileRowRule = shortcutMediaBlock.match(/\.shortcut-capture\s*\{([^}]*)\}/)?.[1] ?? "";
+      const mobileInputRule = shortcutMediaBlock.match(/\.shortcut-capture__input\s*\{([^}]*)\}/)?.[1] ?? "";
+
+      expect(mobileRowRule).toContain("flex-direction: column;");
+      expect(mobileInputRule).toContain("width: 100%;");
+
+      // The buttons' flex-shrink/nowrap rule is declared once (not overridden away)
+      // and still applies at mobile widths, so "Recording…" cannot overflow its box.
+      const buttonRule = settingsModalCss.match(/\.shortcut-capture__record,\s*\n?\s*\.shortcut-capture__clear\s*\{([^}]*)\}/)?.[1] ?? "";
+      expect(buttonRule).toContain("flex-shrink: 0;");
+    });
+  });
 });

From c2eb89b8d4b12bef9419f7431d7bcccd1dcfef34 Mon Sep 17 00:00:00 2001
From: gsxdsm <gsxdsm@users.noreply.github.com>
Date: Sun, 5 Jul 2026 18:57:08 -0700
Subject: [PATCH 59/65] fix: report scope-incapable Anthropic OAuth as
 not-connected in /auth/status

A present, unexpired Anthropic subscription OAuth token that lacks an
inference scope (e.g. a profile-only grant) authenticates identity but
403s on every model call. /auth/status previously validated only token
presence + expiry, so it reported such a token as connected while all
inference failed. It now treats an inference-incapable Anthropic OAuth
token as not-connected (authenticated:false, expired:true so the
re-login banner fires) with a scope-specific loginError. Gated to
Anthropic providers only; tokens with no recorded scopes are treated as
usable to avoid false negatives on fresh logins.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 .changeset/anthropic-oauth-refresh-scope.md   |  2 +-
 .../src/__tests__/routes-auth.test.ts         | 74 +++++++++++++++++++
 .../src/routes/register-auth-routes.ts        | 57 +++++++++++++-
 3 files changed, 129 insertions(+), 4 deletions(-)

diff --git a/.changeset/anthropic-oauth-refresh-scope.md b/.changeset/anthropic-oauth-refresh-scope.md
index 31c262f722..6dbb6e0632 100644
--- a/.changeset/anthropic-oauth-refresh-scope.md
+++ b/.changeset/anthropic-oauth-refresh-scope.md
@@ -4,4 +4,4 @@
 
 summary: Fix Anthropic subscription showing "logged in" while all model calls fail.
 category: fix
-dev: OAuth token refresh in `packages/engine/src/auth-storage.ts` sent a `scope` param (defaulting to `user:profile`), which per RFC 6749 §6 re-issued the access token narrowed to that scope and stripped `user:inference` — so refreshed tokens 403'd on every model call. Refresh now omits `scope` (preserving the originally-granted scopes, matching pi-ai's own refresh), and `ANTHROPIC_DEFAULT_SCOPES` mirrors the full Claude Code scope set. Existing narrowed tokens need one re-login to obtain a fresh broad grant.
+dev: Two-part fix. (1) OAuth token refresh in `packages/engine/src/auth-storage.ts` sent a `scope` param (defaulting to `user:profile`), which per RFC 6749 §6 re-issued the access token narrowed to that scope and stripped `user:inference` — so refreshed tokens 403'd on every model call. Refresh now omits `scope` (preserving the originally-granted scopes, matching pi-ai's own refresh), and `ANTHROPIC_DEFAULT_SCOPES` mirrors the full Claude Code scope set. (2) `/auth/status` now reports an unexpired Anthropic OAuth token that lacks an inference scope as not-connected (authenticated:false, expired:true so the re-login banner fires) with a scope-specific loginError, instead of falsely claiming a live session. Existing narrowed tokens need one re-login to obtain a fresh broad grant.
diff --git a/packages/dashboard/src/__tests__/routes-auth.test.ts b/packages/dashboard/src/__tests__/routes-auth.test.ts
index a0de003484..52f8a86e62 100644
--- a/packages/dashboard/src/__tests__/routes-auth.test.ts
+++ b/packages/dashboard/src/__tests__/routes-auth.test.ts
@@ -1184,6 +1184,80 @@ describe("GET /auth/status", () => {
     expect(anthropic).toMatchObject({ authenticated: false, expired: true });
   });
 
+  /*
+  FNXC:ClaudeOAuth 2026-07-05-19:10:
+  A present, unexpired Anthropic subscription OAuth token whose scopes lack an inference
+  capability (e.g. profile-only grant, or one a buggy refresh narrowed to user:profile)
+  authenticates identity but 403s every model call. /auth/status must report it as
+  not-connected (authenticated:false, expired:true so the re-login banner fires) with a
+  scope-specific loginError — not as a healthy session. The complementary test below
+  guards against a false negative: a token that DOES carry user:inference stays connected.
+  */
+  it("reports an unexpired Anthropic subscription OAuth token that lacks the inference scope as not-connected", async () => {
+    const now = Date.now();
+    (authStorage.getOAuthProviders as ReturnType<typeof vi.fn>).mockReturnValue([
+      { id: "anthropic", name: "Anthropic" },
+    ]);
+    (authStorage.hasAuth as ReturnType<typeof vi.fn>).mockImplementation((provider: string) => provider === "anthropic-subscription");
+    (authStorage.get as ReturnType<typeof vi.fn>).mockImplementation((provider: string) => provider === "anthropic-subscription" ? ({
+      type: "oauth",
+      access: "profile-only-token",
+      refresh: "refresh",
+      expires: now + 3_600_000,
+      scopes: ["user:profile"],
+    }) : undefined);
+
+    const res = await GET(app, "/api/auth/status");
+
+    expect(res.status).toBe(200);
+    const anthropic = res.body.providers.find((p: any) => p.id === "anthropic-subscription");
+    expect(anthropic).toMatchObject({ authenticated: false, expired: true });
+    expect(anthropic.loginError).toMatch(/inference/i);
+  });
+
+  it("keeps an unexpired Anthropic subscription OAuth token that carries user:inference connected", async () => {
+    const now = Date.now();
+    (authStorage.getOAuthProviders as ReturnType<typeof vi.fn>).mockReturnValue([
+      { id: "anthropic", name: "Anthropic" },
+    ]);
+    (authStorage.hasAuth as ReturnType<typeof vi.fn>).mockImplementation((provider: string) => provider === "anthropic-subscription");
+    (authStorage.get as ReturnType<typeof vi.fn>).mockImplementation((provider: string) => provider === "anthropic-subscription" ? ({
+      type: "oauth",
+      access: "inference-capable-token",
+      refresh: "refresh",
+      expires: now + 3_600_000,
+      scopes: ["user:profile", "user:inference"],
+    }) : undefined);
+
+    const res = await GET(app, "/api/auth/status");
+
+    expect(res.status).toBe(200);
+    const anthropic = res.body.providers.find((p: any) => p.id === "anthropic-subscription");
+    expect(anthropic).toMatchObject({ authenticated: true, expired: false });
+    expect(anthropic.loginError).toBeUndefined();
+  });
+
+  it("does not penalize an unexpired Anthropic subscription OAuth token that records no scopes", async () => {
+    const now = Date.now();
+    (authStorage.getOAuthProviders as ReturnType<typeof vi.fn>).mockReturnValue([
+      { id: "anthropic", name: "Anthropic" },
+    ]);
+    (authStorage.hasAuth as ReturnType<typeof vi.fn>).mockImplementation((provider: string) => provider === "anthropic-subscription");
+    (authStorage.get as ReturnType<typeof vi.fn>).mockImplementation((provider: string) => provider === "anthropic-subscription" ? ({
+      type: "oauth",
+      access: "fresh-login-token",
+      refresh: "refresh",
+      expires: now + 3_600_000,
+      // Fresh pi-ai login persists no `scopes` field — must be treated as usable.
+    }) : undefined);
+
+    const res = await GET(app, "/api/auth/status");
+
+    expect(res.status).toBe(200);
+    const anthropic = res.body.providers.find((p: any) => p.id === "anthropic-subscription");
+    expect(anthropic).toMatchObject({ authenticated: true, expired: false });
+  });
+
   /*
   FNXC:ProviderAuth 2026-07-05-00:00:
   FN-7574 symptom verification: an expired, unrefreshable Anthropic Subscription OAuth
diff --git a/packages/dashboard/src/routes/register-auth-routes.ts b/packages/dashboard/src/routes/register-auth-routes.ts
index dd72663774..cf38503980 100644
--- a/packages/dashboard/src/routes/register-auth-routes.ts
+++ b/packages/dashboard/src/routes/register-auth-routes.ts
@@ -114,6 +114,47 @@ export const registerAuthRoutes: ApiRouteRegistrar = (ctx) => {
     return Date.now() >= credential.expires;
   }
 
+  /*
+  FNXC:ClaudeOAuth 2026-07-05-19:10:
+  An Anthropic subscription OAuth token can be present AND unexpired yet still be unable to run models — e.g. a profile-only grant, or a token that a buggy refresh narrowed to `user:profile` (root cause fixed in packages/engine/src/auth-storage.ts). Such a token proves identity but 403s on every model call ("OAuth token does not meet scope requirement any_of(user:inference, ...)"), which is exactly how the status card came to claim "logged in" while all inference failed. So /auth/status must treat an inference-incapable token as not-connected, not authenticated.
+  Mirror the API's any_of inference set. Only penalize when scopes ARE recorded and none is inference-capable: a fresh pi-ai login persists NO `scopes` field, so absent/empty scopes are treated as unknown-but-usable to avoid falsely reporting a good login as disconnected.
+  */
+  const ANTHROPIC_INFERENCE_SCOPES = new Set([
+    "user:inference",
+    "user:developer",
+    "user:ccr_inference",
+    "user:voice",
+    "org:service_key_inference",
+    "workspace:developer",
+    "workspace:inference",
+  ]);
+
+  function isAnthropicOauthProviderId(providerId: string): boolean {
+    return providerId === ANTHROPIC_OAUTH_PROVIDER_ID || providerId === ANTHROPIC_SUBSCRIPTION_PROVIDER_ID;
+  }
+
+  function isInferenceIncapableAnthropicOauth(providerId: string, storage: AuthStorageLike): boolean {
+    // Scope semantics are Anthropic-specific — never apply this to github-copilot,
+    // openai-codex, or other OAuth providers whose scope sets are unrelated.
+    if (!isAnthropicOauthProviderId(providerId)) {
+      return false;
+    }
+    const credential = getOauthStatusCredential(providerId, storage);
+    if (!credential) {
+      return false;
+    }
+    const rawScopes = (credential as { scopes?: unknown }).scopes;
+    if (!Array.isArray(rawScopes)) {
+      return false;
+    }
+    const scopes = rawScopes.filter((scope): scope is string => typeof scope === "string" && scope.trim().length > 0);
+    if (scopes.length === 0) {
+      // Unknown scopes (e.g. fresh login that records none) — assume usable.
+      return false;
+    }
+    return !scopes.some((scope) => ANTHROPIC_INFERENCE_SCOPES.has(scope));
+  }
+
   type ManualCodeConfig = {
     prompt: string;
     placeholder?: string;
@@ -501,15 +542,25 @@ export const registerAuthRoutes: ApiRouteRegistrar = (ctx) => {
           hasAuth = storage.hasAuth(storageProviderId);
           expired = hasAuth && isExpiredOauthCredential(storageProviderId, storage);
         }
+        /*
+        FNXC:ClaudeOAuth 2026-07-05-19:10:
+        A present, unexpired Anthropic OAuth token that lacks an inference scope cannot run models, so it must report as not-connected with the same remediation as an expired session (re-login). Fold it into `expired` so the existing OAuthReloginBanner (which keys on `expired===true`) prompts re-authentication, and set a specific `loginError` so SettingsModal explains the cause rather than showing a bare "expired". Evaluated only when the token is otherwise live (has auth and not already expired) to avoid redundant messaging.
+        */
+        const missingInferenceScope = hasAuth
+          && !expired
+          && isInferenceIncapableAnthropicOauth(storageProviderId, storage);
+        const scopeLoginError = missingInferenceScope
+          ? "This Anthropic login is missing the model-access (inference) scope, so model calls will fail. Re-login to grant full access."
+          : undefined;
         return {
           id: statusProvider.id,
           name: statusProvider.name,
-          authenticated: hasAuth && !expired,
+          authenticated: hasAuth && !expired && !missingInferenceScope,
           type: "oauth" as const,
-          expired,
+          expired: expired || missingInferenceScope,
           loginInProgress: loginInProgress.has(statusProvider.id),
           requiresManualCode: getManualCodeConfig(toOauthLoginProviderId(statusProvider.id), origin) !== undefined || undefined,
-          loginError: lastLoginError.get(statusProvider.id),
+          loginError: lastLoginError.get(statusProvider.id) ?? scopeLoginError,
         };
       }));
 

From dc447304a91cba886fe425e2e0441ea4884cb676 Mon Sep 17 00:00:00 2001
From: gsxdsm <gsxdsm@users.noreply.github.com>
Date: Sun, 5 Jul 2026 19:06:32 -0700
Subject: [PATCH 60/65] fix(FN-7591): allow moving tasks out of custom workflow
 columns (Coding (Ideas))
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Moving a card out of a non-legacy workflow column — e.g. Coding (Ideas)
"ideas" → "todo" — was rejected with "Invalid transition: 'ideas' → 'todo'.
Valid targets: none".

Workflow columns graduated to always-on but moveTaskInternal's compat-flag
legacy branch (the default path, since no experimental flag is emitted)
validated every move against the legacy VALID_TRANSITIONS table, which is
keyed only by the built-in column ids. Default-workflow moves survived by
coincidence (its ids ARE the legacy ids); a task in a custom column had no
key so every move was rejected.

The legacy branch now resolves a non-legacy source column's targets from the
task's own workflow adjacency (resolveAllowedColumns), while keeping the
legacy bare-Error contract intact for legacy columns (transition-parity /
characterization suites unchanged). Adds a regression test covering the
ideas -> todo -> in-progress -> in-review chain and non-adjacent rejection.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 .changeset/coding-ideas-custom-column-move.md |  7 +++
 .../src/__tests__/coding-ideas-move.test.ts   | 59 +++++++++++++++++++
 packages/core/src/store.ts                    | 21 +++++--
 3 files changed, 82 insertions(+), 5 deletions(-)
 create mode 100644 .changeset/coding-ideas-custom-column-move.md
 create mode 100644 packages/core/src/__tests__/coding-ideas-move.test.ts

diff --git a/.changeset/coding-ideas-custom-column-move.md b/.changeset/coding-ideas-custom-column-move.md
new file mode 100644
index 0000000000..b0fcc920fb
--- /dev/null
+++ b/.changeset/coding-ideas-custom-column-move.md
@@ -0,0 +1,7 @@
+---
+"@runfusion/fusion": patch
+---
+
+summary: Fix "Invalid transition" error when moving cards out of a custom workflow column like Coding (Ideas) → Ideas.
+category: fix
+dev: moveTaskInternal's compat-flag legacy path validated moves against the legacy VALID_TRANSITIONS table, which is keyed only by the built-in column ids; a task in a non-legacy workflow column (e.g. "ideas") had no key and every move was rejected. The legacy branch now resolves a non-legacy source column's targets from the task's own workflow adjacency (resolveAllowedColumns) while preserving the legacy bare-Error contract for legacy columns.
diff --git a/packages/core/src/__tests__/coding-ideas-move.test.ts b/packages/core/src/__tests__/coding-ideas-move.test.ts
new file mode 100644
index 0000000000..d8232b41a6
--- /dev/null
+++ b/packages/core/src/__tests__/coding-ideas-move.test.ts
@@ -0,0 +1,59 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { createTaskStoreTestHarness } from "./store-test-helpers.js";
+
+/*
+FNXC:WorkflowColumns 2026-07-05-19:10:
+Regression for the disappearing move on custom workflow columns. Workflow columns graduated to
+always-on (no experimental flag emitted), but moveTaskInternal still gated its workflow path on the
+retired strict compatibility flag, so it fell back to the legacy VALID_TRANSITIONS table — which is
+keyed only by the legacy column ids. A task in a non-legacy column (Coding (Ideas) → "ideas") could
+not move: "Invalid transition: 'ideas' → 'todo'. Valid targets: none".
+
+Surface enumeration (invariant: a move is validated by the task's WORKFLOW adjacency, not the legacy
+table, on a default project with NO experimental flag set):
+ - Custom intake column forward move: ideas → todo is allowed.
+ - Full custom-column chain onward: todo → in-progress → in-review all succeed (→ done is gated by the
+   workflow's own merge trait, which is orthogonal to transition adjacency and excluded here).
+ - Non-adjacent move still rejects with the workflow's targets (ideas → in-progress).
+ - Holds for both user- and engine-sourced moves.
+ - Default workflow (legacy column ids) is unchanged (parity), verified in move-task-characterization.
+*/
+describe("Coding (Ideas) custom-column moves (workflow-columns graduation)", () => {
+  const harness = createTaskStoreTestHarness();
+  beforeEach(harness.beforeEach);
+  afterEach(harness.afterEach);
+
+  it("moves an ideas-workflow task from the ideas intake column to todo", async () => {
+    const store = harness.store();
+    const task = await store.createTask({ description: "idea", workflowId: "builtin:coding-ideas" });
+    expect(task.column).toBe("ideas");
+
+    const moved = await store.moveTask(task.id, "todo", { moveSource: "user" });
+    expect(moved.column).toBe("todo");
+  });
+
+  it("advances an ideas task along the Coding (Ideas) custom-column chain", async () => {
+    const store = harness.store();
+    const task = await store.createTask({ description: "idea", workflowId: "builtin:coding-ideas" });
+
+    await store.moveTask(task.id, "todo", { moveSource: "user" });
+    await store.moveTask(task.id, "in-progress", { moveSource: "user" });
+    const inReview = await store.moveTask(task.id, "in-review", { moveSource: "user", allowDirectInReviewMove: true });
+    expect(inReview.column).toBe("in-review");
+  });
+
+  it("still rejects a non-adjacent move out of the ideas column", async () => {
+    const store = harness.store();
+    const task = await store.createTask({ description: "idea", workflowId: "builtin:coding-ideas" });
+    await expect(
+      store.moveTask(task.id, "in-progress", { moveSource: "user" }),
+    ).rejects.toThrow(/Invalid transition: 'ideas' → 'in-progress'/);
+  });
+
+  it("allows the ideas → todo move from an engine source too", async () => {
+    const store = harness.store();
+    const task = await store.createTask({ description: "idea", workflowId: "builtin:coding-ideas" });
+    const moved = await store.moveTask(task.id, "todo", { moveSource: "engine" });
+    expect(moved.column).toBe("todo");
+  });
+});
diff --git a/packages/core/src/store.ts b/packages/core/src/store.ts
index 12e638163b..2958360fb8 100644
--- a/packages/core/src/store.ts
+++ b/packages/core/src/store.ts
@@ -7676,11 +7676,22 @@ ${TASK_UPSERT_SQL_ASSIGNMENTS}
         !sourceIsLegacy &&
         (COLUMNS as readonly string[]).includes(toColumn);
       if (!isEvacuation) {
-        // Legacy flag-OFF branch (useWorkflow === false): both columns are
-        // guaranteed legacy ids here — a non-legacy `toColumn` returns `?? []`
-        // and rejects below, and flag-OFF tasks never hold custom column ids.
-        // The `as Column` is provably safe within this branch (#1403).
-        const validTargets = VALID_TRANSITIONS[task.column as Column] ?? [];
+        /*
+        FNXC:WorkflowColumns 2026-07-05-19:30:
+        Workflow columns graduated to always-on (no experimental flag emitted), so this "flag-OFF"
+        branch is the DEFAULT move path for nearly every project — the strict compat flag reads false
+        because nothing sets it. Legacy columns (triage/todo/in-progress/in-review/done/archived) are
+        validated verbatim by VALID_TRANSITIONS, preserving the legacy bare-Error contract. But a task
+        can legitimately sit in a NON-legacy workflow column now (e.g. Coding (Ideas) → "ideas"), which
+        VALID_TRANSITIONS cannot key — the old code returned `?? []` and rejected EVERY move out of it
+        ("Invalid transition: 'ideas' → 'todo'. Valid targets: none"). Resolve a non-legacy source
+        column's targets from the task's own workflow adjacency instead, still throwing the same
+        legacy-style bare Error (not TransitionRejectionError) so the flag-OFF characterization contract
+        holds for legacy columns.
+        */
+        const validTargets = sourceIsLegacy
+          ? (VALID_TRANSITIONS[task.column as Column] ?? [])
+          : resolveAllowedColumns(this.resolveTaskWorkflowIrSync(id), task.column);
         if (!validTargets.includes(toColumn as Column)) {
           throw new Error(
             `Invalid transition: '${task.column}' → '${toColumn}'. ` +

From 8fb7d51ae92d78800db485a72a2ea08eb7e85e0a Mon Sep 17 00:00:00 2001
From: gsxdsm <gsxdsm@users.noreply.github.com>
Date: Sun, 5 Jul 2026 19:09:14 -0700
Subject: [PATCH 61/65] FN-7601: distinguish task-detail priority chip colors
 by level

Give the TaskDetailModal priority chip distinct tinted borders/backgrounds per level so low/high/urgent/normal are visually distinguishable at a glance.

- Add per-level border-color and stronger background overrides for .detail-priority-chip.card-priority-badge--{low,high,urgent}, using the matching semantic color token (info/warning/error) with higher specificity than the shared base rule.
- Leave the FN-7585 shared base chip rule and FN-7597 neutral 'normal' treatment untouched; scope changes strictly to .detail-priority-chip so read-only TaskCard badge tints are unaffected.
- Add a regression test asserting each level has distinct, non-var(--border) border-colors and backgrounds, mutually distinct across levels, while the read-only TaskCard badge selectors remain unchanged.

Files changed:
 .../dashboard/app/components/TaskDetailModal.css   | 33 ++++++++++
 ...etailModal.responsive-and-dependencies.test.tsx | 71 ++++++++++++++++++++++
 2 files changed, 104 insertions(+)

Fusion-Task-Id: FN-7601

Fusion-Task-Lineage: 1e2fc574-835c-43b0-8689-02884ad5c2d6

Co-authored-by: Fusion (runfusion.ai) <noreply@runfusion.ai>
---
 .../app/components/TaskDetailModal.css        | 33 +++++++++
 ...Modal.responsive-and-dependencies.test.tsx | 71 +++++++++++++++++++
 2 files changed, 104 insertions(+)

diff --git a/packages/dashboard/app/components/TaskDetailModal.css b/packages/dashboard/app/components/TaskDetailModal.css
index 93f0b22277..2819c055a5 100644
--- a/packages/dashboard/app/components/TaskDetailModal.css
+++ b/packages/dashboard/app/components/TaskDetailModal.css
@@ -431,6 +431,39 @@ read-only TaskCard priority badge (out of scope) is untouched.
   color: var(--text-muted);
 }
 
+/*
+FNXC:TaskDetail 2026-07-05-13:30:
+FN-7601 — the FN-7585 base `.detail-priority-chip` rule pins `border-color:
+var(--border)` for every level, so once the chip shrank to a compact 30px box
+the only remaining differentiator (the ~15-18% tint backgrounds inherited
+from `.card-priority-badge--{low,high,urgent}`) reads as the same washed-out
+box for low vs high. Give each non-neutral level its own tinted border AND a
+stronger background on top of the shared base/normal rules above (higher
+specificity via the `.detail-priority-chip.card-priority-badge--X` compound
+selector) so low/high/urgent are unmistakably distinct colors at a glance,
+while normal keeps the FN-7597 neutral treatment and the FN-7585 shared
+border-width/radius/min-height stay untouched. Scoped to `.detail-priority-chip`
+so the read-only `.card-priority-badge--{low,high,urgent}` tints in
+TaskCard.css (out of scope) are unaffected.
+*/
+.detail-priority-chip.card-priority-badge--low {
+  background: color-mix(in srgb, var(--color-info) 22%, transparent);
+  border-color: color-mix(in srgb, var(--color-info) 65%, var(--border));
+  color: var(--color-info);
+}
+
+.detail-priority-chip.card-priority-badge--high {
+  background: color-mix(in srgb, var(--color-warning) 28%, transparent);
+  border-color: color-mix(in srgb, var(--color-warning) 65%, var(--border));
+  color: var(--color-warning);
+}
+
+.detail-priority-chip.card-priority-badge--urgent {
+  background: color-mix(in srgb, var(--color-error) 30%, transparent);
+  border-color: color-mix(in srgb, var(--color-error) 65%, var(--border));
+  color: var(--color-error-dark);
+}
+
 .detail-priority-select {
   border: 0;
   background: transparent;
diff --git a/packages/dashboard/app/components/__tests__/TaskDetailModal.responsive-and-dependencies.test.tsx b/packages/dashboard/app/components/__tests__/TaskDetailModal.responsive-and-dependencies.test.tsx
index f988e2b5ce..c2ba62771d 100644
--- a/packages/dashboard/app/components/__tests__/TaskDetailModal.responsive-and-dependencies.test.tsx
+++ b/packages/dashboard/app/components/__tests__/TaskDetailModal.responsive-and-dependencies.test.tsx
@@ -304,6 +304,77 @@ describe("TaskDetailModal", () => {
       expect(prioritySavingBlock).not.toMatch(/border|min-height|padding/);
     });
 
+    it("makes low/high/urgent visibly distinct colors on the detail Priority chip, scoped away from TaskCard (FN-7601)", () => {
+      const css = readDashboardStylesSource();
+
+      // FN-7585's shared base rule and FN-7597's neutral `normal` rule must
+      // survive untouched — this task only ADDS per-level overrides on top.
+      const baseChipBlock = getExactCssRuleBlock(css, ".detail-priority-chip");
+      expect(baseChipBlock).toContain("border-width: var(--btn-border-width);");
+      expect(baseChipBlock).toContain("border-color: var(--border);");
+      expect(baseChipBlock).toContain("border-radius: var(--detail-control-border-radius);");
+      const normalBlock = getExactCssRuleBlock(css, ".detail-priority-chip.card-priority-badge--normal");
+      expect(normalBlock).toMatch(/background:\s*color-mix\(in srgb, var\(--text-muted\)/);
+      expect(normalBlock).toContain("color: var(--text-muted);");
+
+      const lowBlock = getExactCssRuleBlock(css, ".detail-priority-chip.card-priority-badge--low");
+      const highBlock = getExactCssRuleBlock(css, ".detail-priority-chip.card-priority-badge--high");
+      const urgentBlock = getExactCssRuleBlock(css, ".detail-priority-chip.card-priority-badge--urgent");
+
+      // Each non-neutral level must declare its own tinted border-color AND
+      // background, using the matching semantic token family.
+      for (const [block, token] of [
+        [lowBlock, "--color-info"],
+        [highBlock, "--color-warning"],
+        [urgentBlock, "--color-error"],
+      ] as const) {
+        expect(block).not.toBe("");
+        expect(block).toMatch(/border-color\s*:/);
+        expect(block).toMatch(/background\s*:/);
+        expect(block).toContain(token);
+      }
+
+      // None of the per-level border-colors may resolve to the plain shared
+      // `var(--border)` value used by the base rule — that was the original
+      // bug (every level looked the same washed-out box).
+      const borderColorOf = (block: string): string => {
+        const match = block.match(/border-color\s*:\s*([^;]+);/);
+        return match?.[1]?.trim() ?? "";
+      };
+      const backgroundOf = (block: string): string => {
+        const match = block.match(/background\s*:\s*([^;]+);/);
+        return match?.[1]?.trim() ?? "";
+      };
+
+      const lowBorder = borderColorOf(lowBlock);
+      const highBorder = borderColorOf(highBlock);
+      const urgentBorder = borderColorOf(urgentBlock);
+
+      expect(lowBorder).not.toBe("var(--border)");
+      expect(highBorder).not.toBe("var(--border)");
+      expect(urgentBorder).not.toBe("var(--border)");
+
+      // Mutually distinct — low, high, and urgent must not collapse onto the
+      // same border-color or background declaration as one another.
+      expect(new Set([lowBorder, highBorder, urgentBorder]).size).toBe(3);
+      const lowBg = backgroundOf(lowBlock);
+      const highBg = backgroundOf(highBlock);
+      const urgentBg = backgroundOf(urgentBlock);
+      expect(new Set([lowBg, highBg, urgentBg]).size).toBe(3);
+
+      // `normal`'s background/border must remain distinct from all three tinted
+      // levels (it keeps the FN-7597 neutral treatment, not a semantic tint).
+      expect(new Set([backgroundOf(normalBlock), lowBg, highBg, urgentBg]).size).toBe(4);
+
+      // The read-only TaskCard badge tints referenced by TaskCard.css must be
+      // untouched by this task — confirm no `.detail-priority-chip` compound
+      // selector leaks a border-color override into the bare `.card-priority-badge--*`
+      // selectors (those remain single-class, background/color-only rules).
+      expect(css).toMatch(/\.card-priority-badge--low\s*\{\s*background:\s*color-mix\(in srgb, var\(--color-info\) 15%, transparent\);\s*color:\s*var\(--color-info\);\s*\}/);
+      expect(css).toMatch(/\.card-priority-badge--high\s*\{\s*background:\s*color-mix\(in srgb, var\(--color-warning\) 18%, transparent\);\s*color:\s*var\(--color-warning\);\s*\}/);
+      expect(css).toMatch(/\.card-priority-badge--urgent\s*\{\s*background:\s*color-mix\(in srgb, var\(--color-error\) 20%, transparent\);\s*color:\s*var\(--color-error-dark\);\s*\}/);
+    });
+
     it("keeps grouped timestamp metadata inline on desktop and mobile", () => {
       const css = readDashboardStylesSource();
 

From f7dfcb3b09b799045cf8a58874835faefcfd859a Mon Sep 17 00:00:00 2001
From: gsxdsm <gsxdsm@users.noreply.github.com>
Date: Sun, 5 Jul 2026 19:39:18 -0700
Subject: [PATCH 62/65] FN-7604: collapse overseer/oversight controls into a
 single dropdown across surfaces

Unifies the previously mobile-only Oversight overflow menu into a single, always-present dropdown that replaces the scattered desktop oversight buttons and the separate mobile affordance.

- Replace discrete desktop oversight action buttons in TaskDetailModal's footer with one universal "Oversight actions" dropdown trigger, reusing the menu across desktop and mobile breakpoints.
- Simplify TaskDetailModal.tsx footer rendering logic, removing now-redundant responsive branching for oversight controls.
- Update TaskDetailModal.css to drop the old mobile-only oversight-overflow styles and support the unified dropdown across breakpoints.
- Update definition-actions, oversight-controls, oversight-mobile, rendering, and responsive-and-dependencies tests to assert the single dropdown behavior and disambiguate the exact "Actions" button query from the new "Oversight actions" aria-label.
- Refresh docs/dashboard-guide.md to describe the unified oversight dropdown UX.

Files changed:
 docs/dashboard-guide.md                            |  14 +-
 packages/dashboard/app/components/TaskDetailModal.css   |  89 +++++------
 packages/dashboard/app/components/TaskDetailModal.tsx   | 177 +++------------------
 packages/dashboard/app/components/__tests__/TaskDetailModal.definition-actions.test.tsx    |  70 ++++----
 packages/dashboard/app/components/__tests__/TaskDetailModal.oversight-controls.test.tsx    | 130 ++++++++++-----
 packages/dashboard/app/components/__tests__/TaskDetailModal.oversight-mobile.test.tsx      |  42 +++--
 packages/dashboard/app/components/__tests__/TaskDetailModal.rendering.test.tsx   |  27 ++--
 packages/dashboard/app/components/__tests__/TaskDetailModal.responsive-and-dependencies.test.tsx |  57 ++++---
 8 files changed, 278 insertions(+), 328 deletions(-)

Fusion-Task-Id: FN-7604
Fusion-Task-Lineage: afbb7573-d654-48db-a9ac-aecbd8e22e46
Co-authored-by: Fusion (runfusion.ai) <noreply@runfusion.ai>
---
 docs/dashboard-guide.md                       |  14 +-
 .../app/components/TaskDetailModal.css        |  85 ++++-----
 .../app/components/TaskDetailModal.tsx        | 177 +++---------------
 ...askDetailModal.definition-actions.test.tsx |  70 ++++---
 ...askDetailModal.oversight-controls.test.tsx | 130 +++++++++----
 .../TaskDetailModal.oversight-mobile.test.tsx |  42 +++--
 .../TaskDetailModal.rendering.test.tsx        |  27 ++-
 ...Modal.responsive-and-dependencies.test.tsx |  57 +++---
 8 files changed, 276 insertions(+), 326 deletions(-)

diff --git a/docs/dashboard-guide.md b/docs/dashboard-guide.md
index 40cc1440e8..7cd3333754 100644
--- a/docs/dashboard-guide.md
+++ b/docs/dashboard-guide.md
@@ -196,12 +196,16 @@ Features:
 <!-- FNXC:PlannerOversight 2026-07-04-19:10: FN-7539 fix — the badge was rendering on virtually every card because the schema default `autonomous` tier was treated as "meaningfully configured". Narrowed the gate so an inherited (no per-task-override, no non-default workflow tier) `autonomous` level renders no badge; only an explicit per-task override or a resolved workflow/effective tier that is not the plain inherited default surfaces the badge. -->
 - 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, but only when oversight is *meaningfully configured* — an explicit per-task override (including an explicit `autonomous` override), or a resolved workflow/effective tier of `observe`/`steer` (`data-testid="card-oversight-badge"`). A card that merely **inherits** the schema default `autonomous` tier (no per-task override, no non-default workflow tier) renders no badge and no empty `.card-meta-badges` shell. The badge is also absent 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.
 <!-- FNXC:PlannerOversight 2026-07-04-HH:MM: FN-7542 removed the FN-7516 active-overseer-state ("Executor") indicator described above as unwanted per-card noise — it fired on nearly every in-progress card. The oversight-level badge documented above is unaffected. -->
-<!-- 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.
+<!-- 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.
+
+FNXC:PlannerOversight 2026-07-05-00:00: FN-7604 collapses the desktop inline cluster (documented below through FN-7545/FN-7546) into the single universal overflow-menu dropdown that FN-7545 originally built for mobile only — the dropdown is now the ONE canonical surface on every viewport, desktop included. -->
+- The task detail modal's inline meta-controls cluster (next to Priority/Execution mode) exposes planner-overseer controls behind a single compact **"Oversight" overflow-menu button** (`data-testid="detail-oversight-menu-trigger"`, `MoreVertical` icon, `aria-haspopup="menu"`) on every viewport, desktop and mobile alike. Clicking the trigger opens a `role="menu"` popover (mirroring the existing move-action dropdown pattern) containing: 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. The trigger itself is withheld entirely when none of the menu's controls would render (no empty-shell overflow button for the unresolved-default case).
 <!-- FNXC:PlannerOversight 2026-07-04-20:30: FN-7546 clarifies the cluster above — operators reported the buttons were unlabeled and looked inert, with only a hover title explaining why. Adds a visible group label and an always-visible disabled-reason line, and makes Explain always openable since it never mutates anything. -->
-- The FN-7517 controls above carry a visible, non-interactive **`"Overseer controls"` group label** (`data-testid="detail-oversight-controls-label"`) so Nudge/Stop/Explain read as an identifiable cluster rather than unlabeled chips; the label is gated by the same `(hasTaskOversightOverride || workflowOversightResolved) && !oversightIsOff` condition as the buttons, so it never renders an empty shell when oversight is Off/unresolved. When **Nudge** is disabled, an always-visible helper line (`data-testid="detail-overseer-nudge-disabled-reason"`) states the reason in-DOM (mirroring the existing hover `title`) instead of relying on a mouse-hover tooltip alone. **Explain** is read-only and non-mutating, so it is never disabled purely because the overseer is inactive — clicking it always opens/closes the panel, which shows the overseer's live state when watching or an informative "not currently watching this task" message otherwise. Nudge's mutating enablement rule (`canNudgeOverseer`, including the human-control suppression cases) and Stop's confirmation dialog are unchanged.
-<!-- FNXC:PlannerOversight 2026-07-04-19:00: FN-7545 collapses the above controls into a mobile overflow menu below the 768px breakpoint. -->
-- On mobile (viewport ≤ 768px), the level-select/nudge/stop/explain controls above collapse behind a single compact **"Oversight" overflow-menu button** (`data-testid="detail-oversight-menu-trigger"`, `MoreVertical` icon, `aria-haspopup="menu"`) that opens a `role="menu"` popover (mirroring the existing move-action dropdown pattern) listing the same controls as full-width, comfortably tappable `role="menuitem"` entries with the SAME testids and enablement/visibility rules as the desktop inline controls. The trigger itself is withheld entirely when none of those controls would render (no empty-shell overflow button for the oversight-off + overseer-inactive default). Desktop (>768px) keeps the inline cluster unchanged. Opening the menu presents exactly one surface: menu-open auto-focus lands on the first actionable button menuitem, never the native level `<select>`, so the OS option picker never auto-opens on top of the custom popover (FN-7562).
+- The controls inside the Oversight menu carry a visible, non-interactive **`"Overseer controls"` group label** (`data-testid="detail-oversight-controls-label"`) so Nudge/Stop/Explain read as an identifiable cluster rather than unlabeled entries; the label is gated by the same `(hasTaskOversightOverride || workflowOversightResolved) && !oversightIsOff` condition as the buttons, so it never renders when oversight is Off/unresolved (opening the menu in that state shows only the level select). When **Nudge** is disabled, an always-visible helper line (`data-testid="detail-overseer-nudge-disabled-reason"`) states the reason in-DOM (mirroring the existing hover `title`) instead of relying on a mouse-hover tooltip alone. **Explain** is read-only and non-mutating, so it is never disabled purely because the overseer is inactive — clicking it always opens/closes the panel, which shows the overseer's live state when watching or an informative "not currently watching this task" message otherwise. Nudge's mutating enablement rule (`canNudgeOverseer`, including the human-control suppression cases) and Stop's confirmation dialog are unchanged.
+<!-- FNXC:PlannerOversight 2026-07-04-19:00: FN-7545 originally introduced this overflow menu for mobile only, collapsing the level-select/nudge/stop/explain controls behind the trigger below the 768px breakpoint while desktop kept an inline cluster.
+
+FNXC:PlannerOversight 2026-07-05-00:00: FN-7604 removed that desktop-inline branch. The overflow-menu trigger + popover described above is now the SINGLE canonical surface at EVERY viewport — there is no longer a desktop/mobile split. -->
+- The Oversight overflow-menu trigger and its popover render identically at every viewport (desktop and mobile): the same testids, the same enablement/visibility rules, and the same `role="menu"`/`role="menuitem"` popover semantics. Menu-open auto-focus lands on the first actionable button menuitem, never the native level `<select>`, so the OS option picker never auto-opens on top of the custom popover (FN-7562).
 <!-- FNXC:PlannerOversight 2026-07-04-18:00: FN-7519 adds a read-only Intervention Timeline. FN-7571 (2026-07-04-19:00) relocates it from an inline mount below the FN-7517 controls into the task-detail Activity view dropdown as a fourth "Interventions" segment, alongside Live/Feed/Raw. -->
 - The task detail modal's **Activity** tab view dropdown (Live/Feed/Raw) gains a fourth **Interventions** option, shown only when planner oversight is active for the task (same gate as the former inline mount: `(hasTaskOversightOverride || workflowOversightResolved) && !oversightIsOff`). Selecting it renders the **Intervention Timeline** (`data-testid="planner-intervention-timeline"`) inside the Activity panel, listing every recorded planner-overseer intervention for the task, newest-first: watched stage, reason, action taken, outcome (with a `.status-dot` indicator using semantic outcome tokens), an attempt count/limit badge (only when both are present), and source links (agent log / review comment / failed check / merge error / PR state / generic URL). It renders a calm "No planner interventions yet" empty state rather than an empty shell when there are none. When oversight is off or unresolved, the Interventions option is absent from the dropdown entirely (no leftover empty segment), and if it was previously selected the view falls back to Live rather than leaving a blank panel. Entries are read via `GET /tasks/:id/overseer/interventions`, which assembles them from the existing run-audit store under the `overseer:intervention` mutation type (`recordPlannerIntervention`/`getPlannerInterventionTimeline` in `@fusion/core`). This is a pure read surface — FN-7520 wires the actual intervention-producing call-sites.
 - 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.
diff --git a/packages/dashboard/app/components/TaskDetailModal.css b/packages/dashboard/app/components/TaskDetailModal.css
index 2819c055a5..47cdecbfe8 100644
--- a/packages/dashboard/app/components/TaskDetailModal.css
+++ b/packages/dashboard/app/components/TaskDetailModal.css
@@ -322,26 +322,23 @@ The task-detail modal metadata must keep priority, execution mode, provenance, P
   /*
   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.
+  Oversight trigger) must wrap without overflowing the mobile modal width
+  rather than forcing horizontal scroll.
 
-  FNXC:PlannerOversight 2026-07-04-19:00:
-  FN-7545: the level-select/nudge/stop/explain controls now collapse behind a
-  single `.detail-oversight-menu-trigger` button below this breakpoint (JS
-  `isOversightMenuMobile` swap in TaskDetailModal.tsx, not a CSS hide), so the
-  cluster only ever needs to fit priority + execution-mode + the trigger on
-  one row; `flex-wrap: wrap` remains as a safety fallback so the cluster never
-  forces horizontal scroll if it still overflows at very narrow widths.
+  FNXC:PlannerOversight 2026-07-05-00:00:
+  FN-7604: the level-select/nudge/stop/explain controls collapse behind the
+  single `.detail-oversight-menu-trigger` button at EVERY viewport now (no
+  longer a mobile-only branch), so the cluster only ever needs to fit
+  priority + execution-mode + the trigger on one row; `flex-wrap: wrap`
+  remains as a safety fallback so the cluster never forces horizontal scroll
+  if it still overflows at very narrow widths. The `.detail-oversight-menu`
+  positioning (`right: 0`) is already declared once on the base rule above
+  and applies at every width, so no mobile-only override is needed here.
   */
   .detail-meta-inline-controls {
     flex-wrap: wrap;
   }
 
-  .detail-oversight-menu {
-    right: 0;
-    left: auto;
-  }
-
   .detail-provenance {
     align-items: center;
   }
@@ -542,36 +539,20 @@ uppercases its content; this only removes a duplicated, drift-prone override.
 
 /*
 FNXC:PlannerOversight 2026-07-04-17:00:
-FN-7517 task-detail planner-overseer controls (quick level-change chip,
+FN-7517 task-detail planner-overseer controls (quick level-change select,
 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.
+semantic source.
 
-FNXC:TaskDetail 2026-07-05-00:00:
-FN-7585 — like `.detail-priority-chip`, override `.card-oversight-badge`'s
-transparent border with the shared `--btn-border-width`/`--border`/
-`--detail-control-border-radius` trio so every oversight level (including
-`--off`, which has a neutral tint) renders the same bordered box as Priority
-and Execution-mode. The mobile `.detail-oversight-menu-trigger` swap below
-gets the identical trio so both oversight variants match.
+FNXC:PlannerOversight 2026-07-05-00:00:
+FN-7604 — the desktop-only `.detail-oversight-chip` wrapper (the inline
+quick-level-change chip rendered outside the overflow menu) was removed along
+with the desktop inline branch it styled; the level select now renders only
+inside `.detail-oversight-menu-item--select` (see below). `.detail-oversight-select`
+itself stays — the dropdown menu item reuses this class for the native
+`<select>` styling.
 */
-.detail-oversight-chip {
-  gap: var(--space-xs);
-  min-height: var(--detail-priority-control-min-height);
-  padding-block: var(--space-xs);
-  box-sizing: border-box;
-  border-width: var(--btn-border-width);
-  border-color: var(--border);
-  border-radius: var(--detail-control-border-radius);
-}
-
-.detail-oversight-chip--saving {
-  opacity: 0.75;
-}
-
 .detail-oversight-select {
   border: 0;
   background: transparent;
@@ -694,12 +675,16 @@ than a one-off style.
 
 /*
 FNXC:PlannerOversight 2026-07-04-19:00:
-FN-7545 — mobile overflow menu for the oversight action controls. Reuses the
-same `.detail-move-dropdown` / `.detail-move-menu` popover tokens/pattern
+FN-7545 — overflow menu for the oversight action controls. Reuses the same
+`.detail-move-dropdown` / `.detail-move-menu` popover tokens/pattern
 (position/border/radius/shadow) so the two overflow menus in this modal look
 and behave consistently. The popover opens DOWNWARD (`top: calc(100% + ...)`)
 since the trigger lives in the header cluster rather than the footer, unlike
 `.detail-move-menu` which opens upward from the footer.
+
+FNXC:PlannerOversight 2026-07-05-00:00:
+FN-7604 — this overflow menu is now the single universal surface at every
+viewport (desktop and mobile); it is no longer mobile-only.
 */
 .detail-oversight-menu-dropdown {
   position: relative;
@@ -714,10 +699,13 @@ since the trigger lives in the header cluster rather than the footer, unlike
   box-sizing: border-box;
   /*
   FNXC:TaskDetail 2026-07-05-00:00:
-  FN-7585 — mobile swap-in for `.detail-oversight-chip` (JS `isOversightMenuMobile`
-  swap in TaskDetailModal.tsx). Pin the same shared border/radius trio so the
-  mobile overflow-trigger variant matches the desktop chip and the
-  Priority/Execution-mode controls, per the FN-7585 surface enumeration.
+  FN-7585 — pin the same shared border/radius trio as Priority/Execution-mode
+  so the Oversight trigger matches the rest of the control cluster.
+
+  FNXC:PlannerOversight 2026-07-05-00:00:
+  FN-7604 — this trigger is now the single universal surface at every
+  viewport (the desktop-only `.detail-oversight-chip` it used to swap in for
+  was removed).
   */
   border-width: var(--btn-border-width);
   border-color: var(--border);
@@ -809,10 +797,9 @@ button.detail-oversight-menu-item svg {
 
 /*
 FNXC:PlannerOversight 2026-07-04-20:30:
-FN-7546 — the same group label / disabled-reason helper as the desktop
-cluster above, adapted to the mobile overflow-menu's padded list-item layout
-so they read as ordinary (non-interactive) menu rows rather than floating
-text.
+FN-7546 — the same group label / disabled-reason helper base rules above,
+adapted to the overflow-menu's padded list-item layout so they read as
+ordinary (non-interactive) menu rows rather than floating text.
 */
 .detail-oversight-menu .detail-oversight-controls-label,
 .detail-oversight-menu .detail-oversight-controls-helper {
diff --git a/packages/dashboard/app/components/TaskDetailModal.tsx b/packages/dashboard/app/components/TaskDetailModal.tsx
index 8f2b73d279..a1edff3916 100644
--- a/packages/dashboard/app/components/TaskDetailModal.tsx
+++ b/packages/dashboard/app/components/TaskDetailModal.tsx
@@ -86,9 +86,8 @@ const ACTIVITY_VIEW_MENU_MIN_WIDTH = 160;
 const ACTIVITY_VIEW_MENU_MIN_HEIGHT = 120;
 const ACTIVITY_VIEW_MENU_MAX_HEIGHT = 320;
 const ACTIVITY_VIEW_MENU_OPEN_VIEWPORT_GUARD_MS = 350;
-// FNXC:PlannerOversight 2026-07-04-19:00: FN-7545 — mobile breakpoint for collapsing the oversight action cluster into an overflow menu; matches the `@media (max-width: 768px)` breakpoint used across TaskDetailModal.css.
-const OVERSIGHT_MENU_MOBILE_BREAKPOINT = 768;
-// FNXC:TaskDetailSwipeBack 2026-07-05-12:30: FN-7587 — mobile breakpoint gating the presentation-only predictive-back slide/fade transition on the modal/list/nested task-detail surface; matches OVERSIGHT_MENU_MOBILE_BREAKPOINT/the `@media (max-width: 768px)` convention already used in this file.
+// FNXC:TaskDetailSwipeBack 2026-07-05-12:30: FN-7587 — mobile breakpoint gating the presentation-only predictive-back slide/fade transition on the modal/list/nested task-detail surface; matches the `@media (max-width: 768px)` convention already used in this file.
+// FNXC:PlannerOversight 2026-07-05-00:00: FN-7604 — the OVERSIGHT_MENU_MOBILE_BREAKPOINT constant (formerly used to branch the oversight controls between an inline cluster and this overflow menu) was removed; the overflow-menu dropdown is now the single universal surface at every viewport, so no breakpoint gates it.
 const TASK_DETAIL_MOBILE_TRANSITION_BREAKPOINT = 768;
 
 type ActivityViewMenuPosition = {
@@ -1070,15 +1069,16 @@ export function TaskDetailContent({
   const [overseerExplainSnapshot, setOverseerExplainSnapshot] = useState<PlannerOverseerRuntimeSnapshot | null>(null);
   /*
   FNXC:PlannerOversight 2026-07-04-19:00:
-  FN-7545 — collapse the oversight action controls into a mobile overflow
-  menu so the detail control bar fits narrow viewports; desktop keeps the
-  inline cluster; menu never renders an empty shell when oversight is
-  off/inactive. `isOversightMenuMobile` mirrors the `DocumentsView` local
-  `isMobile` resize-listener pattern (defaults false so JSDOM/unit tests keep
-  exercising the desktop inline branch unless a test explicitly narrows the
-  viewport).
+  FN-7545 — collapse the oversight action controls into an overflow menu so
+  the detail control bar fits narrow viewports; menu never renders an empty
+  shell when oversight is off/inactive.
+
+  FNXC:PlannerOversight 2026-07-05-00:00:
+  FN-7604 — the overflow menu is now the single universal surface at every
+  viewport (desktop and mobile); the `isOversightMenuMobile` resize-driven
+  branch selector was removed since there is no longer a second branch to
+  select between.
   */
-  const [isOversightMenuMobile, setIsOversightMenuMobile] = useState(false);
   const [showOversightMenu, setShowOversightMenu] = useState(false);
   const oversightMenuRef = useRef<HTMLDivElement>(null);
   const oversightMenuButtonRef = useRef<HTMLButtonElement>(null);
@@ -1503,26 +1503,6 @@ export function TaskDetailContent({
     return () => document.removeEventListener("keydown", handleKeyDown);
   }, [showMoveMenu, showActionsMenu, showActivityViewMenu, showOversightMenu]);
 
-  // FNXC:PlannerOversight 2026-07-04-19:00: FN-7545 — track the mobile breakpoint locally (mirrors DocumentsView's isMobile resize-listener pattern) so the oversight action cluster can collapse into an overflow menu on narrow viewports while desktop keeps the inline layout.
-  useEffect(() => {
-    const updateOversightMenuMobile = () => {
-      setIsOversightMenuMobile(window.innerWidth <= OVERSIGHT_MENU_MOBILE_BREAKPOINT);
-    };
-
-    updateOversightMenuMobile();
-    window.addEventListener("resize", updateOversightMenuMobile);
-
-    return () => {
-      window.removeEventListener("resize", updateOversightMenuMobile);
-    };
-  }, []);
-
-  useEffect(() => {
-    if (!isOversightMenuMobile) {
-      setShowOversightMenu(false);
-    }
-  }, [isOversightMenuMobile]);
-
   // Reset spec edit state when task changes
   useEffect(() => {
     setIsEditingSpec(false);
@@ -3983,16 +3963,19 @@ export function TaskDetailContent({
                   FNXC:PlannerOversight 2026-07-04-19:00:
                   FN-7545 — collapse the oversight action controls into a mobile
                   overflow menu so the detail control bar fits narrow viewports;
-                  desktop keeps the inline cluster; menu never renders an empty
-                  shell when oversight is off/inactive. Both branches below share
-                  the SAME enablement gates (`hasTaskOversightOverride`,
+                  menu never renders an empty shell when oversight is off/inactive.
+                  Shares the SAME enablement gates (`hasTaskOversightOverride`,
                   `workflowOversightResolved`, `oversightIsOff`, `showStopOverseer`,
                   `canNudgeOverseer`, `canExplainOverseer`) and the SAME handlers
-                  — the mobile branch only changes where the controls render, never
-                  their guard logic.
+                  as before.
+
+                  FNXC:PlannerOversight 2026-07-05-00:00:
+                  FN-7604 — the oversight action controls (level select / nudge /
+                  stop / explain) render ONLY behind the "Oversight" overflow-menu
+                  trigger on every surface (desktop and mobile); the former desktop
+                  inline cluster was removed for a consistent, simpler control bar.
                   */}
-                  {isOversightMenuMobile ? (
-                    (hasTaskOversightOverride || workflowOversightResolved) && (
+                  {(hasTaskOversightOverride || workflowOversightResolved) && (
                       <div className="detail-oversight-menu-dropdown" ref={oversightMenuRef}>
                         <button
                           type="button"
@@ -4101,119 +4084,7 @@ export function TaskDetailContent({
                           </div>
                         )}
                       </div>
-                    )
-                  ) : (
-                    <>
-                      {(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.
-
-                      FNXC:PlannerOversight 2026-07-04-20:30:
-                      FN-7546 — operators reported these controls were confusing:
-                      unlabeled inline chips, greyed out most of the time, with the
-                      only "why" behind a mouse-hover `title`. Add a visible,
-                      non-interactive `detail-oversight-controls-label` group label
-                      (gated by the SAME condition as the buttons) so the cluster is
-                      identifiable, and a `detail-overseer-nudge-disabled-reason`
-                      helper line that surfaces the disabled reason in-DOM (not just
-                      on hover) whenever Nudge is unavailable. Explain is read-only
-                      and non-mutating, so its disabled gate is removed entirely
-                      (see handleExplainOverseer below) — it always opens its panel,
-                      which already renders an informative "not currently watching"
-                      empty state. Nudge's mutating gate (`canNudgeOverseer`) and
-                      Stop's confirm dialog are unchanged.
-                      */}
-                      {(hasTaskOversightOverride || workflowOversightResolved) && !oversightIsOff && (
-                        <span className="detail-oversight-controls-label" data-testid="detail-oversight-controls-label">
-                          {t("taskDetail.oversight.controlsLabel", "Overseer controls")}
-                        </span>
-                      )}
-                      {(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") : nudgeDisabledReason}
-                          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) && !oversightIsOff && !canNudgeOverseer && (
-                        <span className="detail-oversight-controls-helper" data-testid="detail-overseer-nudge-disabled-reason">
-                          {nudgeDisabledReason}
-                        </span>
-                      )}
-                      {(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();
-                          }}
-                          title={canExplainOverseer ? t("taskDetail.oversight.explainTitle", "Explain the overseer's current action") : t("taskDetail.oversight.explainInactiveTitle", "Overseer is not currently watching this task — Explain shows its last known state")}
-                          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">
@@ -6013,8 +5884,8 @@ export function TaskDetailModal({ onClose, ...props }: TaskDetailModalProps) {
   const overlayDismissProps = useOverlayDismiss(onClose);
   /*
   FNXC:TaskDetailSwipeBack 2026-07-05-12:30:
-  FN-7587 — track the mobile breakpoint locally (mirrors the OVERSIGHT_MENU_MOBILE_BREAKPOINT
-  resize-listener pattern above) so the list/modal/nested task-detail surface gets the same
+  FN-7587 — track the mobile breakpoint locally (mirrors the same resize-listener pattern
+  used elsewhere in this file) so the list/modal/nested task-detail surface gets the same
   presentation-only predictive-back slide/fade enter transition as the board main-panel
   (MainContent.tsx), without threading a new isMobile prop through App.tsx/AppModals.tsx. This
   is presentation-only: it never touches onClose/onRequestClose timing or the underlying
diff --git a/packages/dashboard/app/components/__tests__/TaskDetailModal.definition-actions.test.tsx b/packages/dashboard/app/components/__tests__/TaskDetailModal.definition-actions.test.tsx
index acb0fa4882..b14129ed92 100644
--- a/packages/dashboard/app/components/__tests__/TaskDetailModal.definition-actions.test.tsx
+++ b/packages/dashboard/app/components/__tests__/TaskDetailModal.definition-actions.test.tsx
@@ -1,3 +1,11 @@
+/*
+FNXC:PlannerOversight 2026-07-05-00:00:
+FN-7604 — the footer "Actions" dropdown button name is matched EXACTLY
+(`{ name: "Actions" }`) throughout this file, not via a loose `/actions/i`
+regex. The now-universal Oversight overflow trigger's aria-label is
+"Oversight actions", which also matches `/actions/i` and made every such
+query ambiguous once the trigger stopped being a mobile-only affordance.
+*/
 import { describe, it, expect, vi } from "vitest";
 import { render, screen, fireEvent, act, waitFor } from "@testing-library/react";
 import userEvent from "@testing-library/user-event";
@@ -743,7 +751,7 @@ describe("TaskDetailModal", () => {
       );
 
       // Open Actions dropdown to see Duplicate
-      const actionsBtn = screen.getByRole("button", { name: /actions/i });
+      const actionsBtn = screen.getByRole("button", { name: "Actions" });
       fireEvent.click(actionsBtn);
 
       expect(screen.getByRole("menuitem", { name: "Duplicate" })).toBeTruthy();
@@ -764,7 +772,7 @@ describe("TaskDetailModal", () => {
       );
 
       // Open Actions dropdown - Duplicate should not be there
-      const actionsBtn = screen.getByRole("button", { name: /actions/i });
+      const actionsBtn = screen.getByRole("button", { name: "Actions" });
       fireEvent.click(actionsBtn);
       expect(screen.queryByRole("menuitem", { name: "Duplicate" })).toBeNull();
     });
@@ -787,7 +795,7 @@ describe("TaskDetailModal", () => {
       );
 
       // Open Actions dropdown first
-      const actionsBtn = screen.getByRole("button", { name: /actions/i });
+      const actionsBtn = screen.getByRole("button", { name: "Actions" });
       fireEvent.click(actionsBtn);
 
       fireEvent.click(screen.getByRole("menuitem", { name: "Duplicate" }));
@@ -820,7 +828,7 @@ describe("TaskDetailModal", () => {
       );
 
       // Open Actions dropdown first
-      const actionsBtn = screen.getByRole("button", { name: /actions/i });
+      const actionsBtn = screen.getByRole("button", { name: "Actions" });
       fireEvent.click(actionsBtn);
 
       fireEvent.click(screen.getByRole("menuitem", { name: "Duplicate" }));
@@ -852,7 +860,7 @@ describe("TaskDetailModal", () => {
         />,
       );
 
-      fireEvent.click(screen.getByRole("button", { name: /actions/i }));
+      fireEvent.click(screen.getByRole("button", { name: "Actions" }));
       const pauseItem = screen.getByRole("menuitem", { name: "Pause" });
 
       fireEvent.pointerUp(pauseItem, { pointerType: "touch", pointerId: 1 });
@@ -884,7 +892,7 @@ describe("TaskDetailModal", () => {
       );
 
       // Open Actions dropdown first
-      const actionsBtn = screen.getByRole("button", { name: /actions/i });
+      const actionsBtn = screen.getByRole("button", { name: "Actions" });
       fireEvent.click(actionsBtn);
 
       fireEvent.click(screen.getByRole("menuitem", { name: "Duplicate" }));
@@ -915,7 +923,7 @@ describe("TaskDetailModal", () => {
       );
 
       // Open Actions dropdown first
-      const actionsBtn = screen.getByRole("button", { name: /actions/i });
+      const actionsBtn = screen.getByRole("button", { name: "Actions" });
       fireEvent.click(actionsBtn);
 
       fireEvent.click(screen.getByRole("menuitem", { name: "Duplicate" }));
@@ -945,7 +953,7 @@ describe("TaskDetailModal", () => {
       );
 
       // Open Actions dropdown first
-      const actionsBtn = screen.getByRole("button", { name: /actions/i });
+      const actionsBtn = screen.getByRole("button", { name: "Actions" });
       fireEvent.click(actionsBtn);
 
       fireEvent.click(screen.getByRole("menuitem", { name: "Duplicate" }));
@@ -976,7 +984,7 @@ describe("TaskDetailModal", () => {
           addToast={noop}
         />,
       );
-      fireEvent.click(screen.getByRole("button", { name: /actions/i }));
+      fireEvent.click(screen.getByRole("button", { name: "Actions" }));
       const item = screen.queryByRole("menuitem", { name: "Refine" });
       if (shouldShow) expect(item).toBeTruthy();
       else expect(item).toBeNull();
@@ -1012,7 +1020,7 @@ describe("TaskDetailModal", () => {
         />,
       );
 
-      expect(screen.getByRole("button", { name: /actions/i })).toBeTruthy();
+      expect(screen.getByRole("button", { name: "Actions" })).toBeTruthy();
     });
 
     it("renders Unpause button for a paused triage task", () => {
@@ -1029,7 +1037,7 @@ describe("TaskDetailModal", () => {
         />,
       );
 
-      fireEvent.click(screen.getByRole("button", { name: /actions/i }));
+      fireEvent.click(screen.getByRole("button", { name: "Actions" }));
 
       expect(screen.getByRole("menuitem", { name: "Unpause" })).toBeTruthy();
     });
@@ -1051,7 +1059,7 @@ describe("TaskDetailModal", () => {
         />,
       );
 
-      await userEvent.click(screen.getByRole("button", { name: /actions/i }));
+      await userEvent.click(screen.getByRole("button", { name: "Actions" }));
       await userEvent.click(screen.getByRole("menuitem", { name: "Unpause" }));
 
       await waitFor(() => {
@@ -1084,7 +1092,7 @@ describe("TaskDetailModal", () => {
         expect(mockFetchAgent).toHaveBeenCalledWith("agent-1", undefined);
       });
 
-      await userEvent.click(screen.getByRole("button", { name: /actions/i }));
+      await userEvent.click(screen.getByRole("button", { name: "Actions" }));
       await userEvent.click(screen.getByRole("menuitem", { name: "Unpause" }));
 
       await waitFor(() => {
@@ -1115,7 +1123,7 @@ describe("TaskDetailModal", () => {
         expect(mockFetchAgent).toHaveBeenCalledWith("agent-1", undefined);
       });
 
-      await userEvent.click(screen.getByRole("button", { name: /actions/i }));
+      await userEvent.click(screen.getByRole("button", { name: "Actions" }));
 
       expect(screen.getByRole("menuitem", { name: "Unpause" })).toBeTruthy();
       expect(await screen.findByText("Paused by agent")).toBeTruthy();
@@ -1145,7 +1153,7 @@ describe("TaskDetailModal", () => {
         expect(mockFetchAgent).toHaveBeenCalledWith("agent-1", undefined);
       });
 
-      await userEvent.click(screen.getByRole("button", { name: /actions/i }));
+      await userEvent.click(screen.getByRole("button", { name: "Actions" }));
       await userEvent.click(screen.getByRole("menuitem", { name: "Pause" }));
 
       await waitFor(() => {
@@ -1177,7 +1185,7 @@ describe("TaskDetailModal", () => {
         />,
       );
 
-      await userEvent.click(screen.getByRole("button", { name: /actions/i }));
+      await userEvent.click(screen.getByRole("button", { name: "Actions" }));
 
       expect(screen.getByRole("menuitem", { name: expectedLabel })).toBeTruthy();
     });
@@ -1196,7 +1204,7 @@ describe("TaskDetailModal", () => {
         />,
       );
 
-      await userEvent.click(screen.getByRole("button", { name: /actions/i }));
+      await userEvent.click(screen.getByRole("button", { name: "Actions" }));
 
       expect(screen.queryByRole("menuitem", { name: "Pause" })).toBeNull();
       expect(screen.queryByRole("menuitem", { name: "Unpause" })).toBeNull();
@@ -1216,7 +1224,7 @@ describe("TaskDetailModal", () => {
         />,
       );
 
-      expect(screen.queryByRole("button", { name: /actions/i })).toBeNull();
+      expect(screen.queryByRole("button", { name: "Actions" })).toBeNull();
     });
 
     it("clicking Refine opens the refinement modal", () => {
@@ -1234,7 +1242,7 @@ describe("TaskDetailModal", () => {
       );
 
       // Open Actions dropdown first
-      const actionsBtn = screen.getByRole("button", { name: /actions/i });
+      const actionsBtn = screen.getByRole("button", { name: "Actions" });
       fireEvent.click(actionsBtn);
 
       fireEvent.click(screen.getByRole("menuitem", { name: "Refine" }));
@@ -1258,7 +1266,7 @@ describe("TaskDetailModal", () => {
       );
 
       // Open Actions dropdown first
-      const actionsBtn = screen.getByRole("button", { name: /actions/i });
+      const actionsBtn = screen.getByRole("button", { name: "Actions" });
       fireEvent.click(actionsBtn);
 
       fireEvent.click(screen.getByRole("menuitem", { name: "Refine" }));
@@ -1281,7 +1289,7 @@ describe("TaskDetailModal", () => {
       );
 
       // Open Actions dropdown first
-      const actionsBtn = screen.getByRole("button", { name: /actions/i });
+      const actionsBtn = screen.getByRole("button", { name: "Actions" });
       fireEvent.click(actionsBtn);
 
       fireEvent.click(screen.getByRole("menuitem", { name: "Refine" }));
@@ -1309,7 +1317,7 @@ describe("TaskDetailModal", () => {
       );
 
       // Open Actions dropdown first
-      const actionsBtn = screen.getByRole("button", { name: /actions/i });
+      const actionsBtn = screen.getByRole("button", { name: "Actions" });
       fireEvent.click(actionsBtn);
 
       fireEvent.click(screen.getByRole("menuitem", { name: "Refine" }));
@@ -1333,7 +1341,7 @@ describe("TaskDetailModal", () => {
       );
 
       // Open Actions dropdown first
-      const actionsBtn = screen.getByRole("button", { name: /actions/i });
+      const actionsBtn = screen.getByRole("button", { name: "Actions" });
       fireEvent.click(actionsBtn);
 
       fireEvent.click(screen.getByRole("menuitem", { name: "Refine" }));
@@ -1364,7 +1372,7 @@ describe("TaskDetailModal", () => {
       );
 
       // Open Actions dropdown first
-      const actionsBtn = screen.getByRole("button", { name: /actions/i });
+      const actionsBtn = screen.getByRole("button", { name: "Actions" });
       fireEvent.click(actionsBtn);
 
       fireEvent.click(screen.getByRole("menuitem", { name: "Refine" }));
@@ -1392,7 +1400,7 @@ describe("TaskDetailModal", () => {
       );
 
       // Open Actions dropdown first
-      const actionsBtn = screen.getByRole("button", { name: /actions/i });
+      const actionsBtn = screen.getByRole("button", { name: "Actions" });
       fireEvent.click(actionsBtn);
 
       fireEvent.click(screen.getByRole("menuitem", { name: "Refine" }));
@@ -1443,7 +1451,7 @@ describe("TaskDetailModal", () => {
       );
 
       // Open Actions dropdown first
-      const actionsBtn = screen.getByRole("button", { name: /actions/i });
+      const actionsBtn = screen.getByRole("button", { name: "Actions" });
       fireEvent.click(actionsBtn);
 
       fireEvent.click(screen.getByRole("menuitem", { name: "Refine" }));
@@ -1495,7 +1503,7 @@ describe("TaskDetailModal", () => {
       await screen.findByTestId("task-detail-workflow-badge");
       expect(screen.getByTestId("task-detail-workflow-badge")).toHaveTextContent("Custom refinement lane");
 
-      fireEvent.click(screen.getByRole("button", { name: /actions/i }));
+      fireEvent.click(screen.getByRole("button", { name: "Actions" }));
       fireEvent.click(screen.getByRole("menuitem", { name: "Refine" }));
       fireEvent.change(screen.getByPlaceholderText("Enter your feedback here..."), { target: { value: "Keep the same workflow lane" } });
       fireEvent.click(screen.getByText("Create Refinement Task"));
@@ -1531,7 +1539,7 @@ describe("TaskDetailModal", () => {
       );
 
       // Open Actions dropdown first
-      const actionsBtn = screen.getByRole("button", { name: /actions/i });
+      const actionsBtn = screen.getByRole("button", { name: "Actions" });
       fireEvent.click(actionsBtn);
 
       // Click Refine from the dropdown
@@ -1562,7 +1570,7 @@ describe("TaskDetailModal", () => {
       );
 
       // Open Actions dropdown first
-      const actionsBtn = screen.getByRole("button", { name: /actions/i });
+      const actionsBtn = screen.getByRole("button", { name: "Actions" });
       fireEvent.click(actionsBtn);
 
       // Click Refine from the dropdown
@@ -1596,7 +1604,7 @@ describe("TaskDetailModal", () => {
       );
 
       // Open Actions dropdown first
-      const actionsBtn = screen.getByRole("button", { name: /actions/i });
+      const actionsBtn = screen.getByRole("button", { name: "Actions" });
       fireEvent.click(actionsBtn);
 
       // Click Refine from the dropdown
@@ -1630,7 +1638,7 @@ describe("TaskDetailModal", () => {
       );
 
       // Open Actions dropdown first
-      const actionsBtn = screen.getByRole("button", { name: /actions/i });
+      const actionsBtn = screen.getByRole("button", { name: "Actions" });
       fireEvent.click(actionsBtn);
 
       // Click Refine from the dropdown
diff --git a/packages/dashboard/app/components/__tests__/TaskDetailModal.oversight-controls.test.tsx b/packages/dashboard/app/components/__tests__/TaskDetailModal.oversight-controls.test.tsx
index 18bf22f1ad..dccdea07d4 100644
--- a/packages/dashboard/app/components/__tests__/TaskDetailModal.oversight-controls.test.tsx
+++ b/packages/dashboard/app/components/__tests__/TaskDetailModal.oversight-controls.test.tsx
@@ -3,8 +3,18 @@ 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).
+
+FNXC:PlannerOversight 2026-07-05-00:00:
+FN-7604 — the desktop inline cluster was removed; ALL oversight controls
+(including at the historically "desktop" 1024px-ish jsdom default width) now
+render only behind the `detail-oversight-menu-trigger` overflow menu, the
+same surface the mobile suite below already exercised. This describe block's
+tests are retargeted to open the trigger via the shared `openOversightMenu()`
+helper before querying level-select/nudge/stop/explain, mirroring the
+pre-existing FN-7545/FN-7558 mobile pattern exactly — there is no longer a
+separate desktop-only assertion path.
 */
-import { describe, it, expect, vi, beforeEach } from "vitest";
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
 import { render, screen, fireEvent, waitFor } from "@testing-library/react";
 import type { PlannerOverseerRuntimeSnapshot } from "@fusion/core";
 import {
@@ -34,6 +44,20 @@ const activeSnapshot: PlannerOverseerRuntimeSnapshot = {
   lastAction: "inject_guidance",
 };
 
+/*
+FNXC:PlannerOversight 2026-07-05-00:00:
+FN-7604 — shared open-the-overflow-menu helper reused across every describe
+block in this file (the pattern the FN-7521/FN-7545 mobile-only describe
+block already used). Since the dropdown is now the universal surface at
+every viewport, every test that needs to observe the level select or the
+nudge/stop/explain buttons must click the trigger first.
+*/
+async function openOversightMenu() {
+  const trigger = await screen.findByTestId("detail-oversight-menu-trigger");
+  fireEvent.click(trigger);
+  return trigger;
+}
+
 describe("TaskDetailModal oversight controls", () => {
   beforeEach(async () => {
     vi.clearAllMocks();
@@ -63,6 +87,7 @@ describe("TaskDetailModal oversight controls", () => {
       />,
     );
 
+    await openOversightMenu();
     const select = await screen.findByTestId("detail-oversight-level-select");
     expect((select as HTMLSelectElement).value).toBe("observe");
 
@@ -90,6 +115,7 @@ describe("TaskDetailModal oversight controls", () => {
       />,
     );
 
+    await openOversightMenu();
     const select = await screen.findByTestId("detail-oversight-level-select");
     fireEvent.change(select, { target: { value: "__inherit__" } });
 
@@ -114,6 +140,7 @@ describe("TaskDetailModal oversight controls", () => {
       />,
     );
 
+    await openOversightMenu();
     const nudgeBtn = await screen.findByTestId("detail-overseer-nudge");
     expect(nudgeBtn).not.toBeDisabled();
     fireEvent.click(nudgeBtn);
@@ -136,6 +163,7 @@ describe("TaskDetailModal oversight controls", () => {
       />,
     );
 
+    await openOversightMenu();
     const nudgeBtn = await screen.findByTestId("detail-overseer-nudge");
     expect(nudgeBtn).toBeDisabled();
   });
@@ -153,6 +181,7 @@ describe("TaskDetailModal oversight controls", () => {
       />,
     );
 
+    await openOversightMenu();
     const label = await screen.findByTestId("detail-oversight-controls-label");
     expect(label).toHaveTextContent("Overseer controls");
 
@@ -181,6 +210,7 @@ describe("TaskDetailModal oversight controls", () => {
       />,
     );
 
+    await openOversightMenu();
     const nudgeBtn = await screen.findByTestId("detail-overseer-nudge");
     expect(nudgeBtn).toBeDisabled();
 
@@ -203,6 +233,7 @@ describe("TaskDetailModal oversight controls", () => {
       />,
     );
 
+    await openOversightMenu();
     const nudgeBtn = await screen.findByTestId("detail-overseer-nudge");
     expect(nudgeBtn).toBeDisabled();
 
@@ -225,6 +256,7 @@ describe("TaskDetailModal oversight controls", () => {
       />,
     );
 
+    await openOversightMenu();
     const nudgeBtn = await screen.findByTestId("detail-overseer-nudge");
     expect(nudgeBtn).not.toBeDisabled();
     expect(screen.queryByTestId("detail-overseer-nudge-disabled-reason")).not.toBeInTheDocument();
@@ -243,6 +275,7 @@ describe("TaskDetailModal oversight controls", () => {
       />,
     );
 
+    await openOversightMenu();
     const nudgeBtn = await screen.findByTestId("detail-overseer-nudge");
     expect(nudgeBtn).toBeDisabled();
   });
@@ -260,6 +293,7 @@ describe("TaskDetailModal oversight controls", () => {
       />,
     );
 
+    await openOversightMenu();
     const nudgeBtn = await screen.findByTestId("detail-overseer-nudge");
     expect(nudgeBtn).toBeDisabled();
   });
@@ -280,6 +314,7 @@ describe("TaskDetailModal oversight controls", () => {
       />,
     );
 
+    await openOversightMenu();
     const stopBtn = await screen.findByTestId("detail-overseer-stop");
     fireEvent.click(stopBtn);
 
@@ -302,6 +337,7 @@ describe("TaskDetailModal oversight controls", () => {
       />,
     );
 
+    await openOversightMenu();
     await screen.findByTestId("detail-oversight-level-select");
     expect(screen.queryByTestId("detail-overseer-stop")).not.toBeInTheDocument();
   });
@@ -322,6 +358,7 @@ describe("TaskDetailModal oversight controls", () => {
       />,
     );
 
+    await openOversightMenu();
     const explainBtn = await screen.findByTestId("detail-overseer-explain");
     fireEvent.click(explainBtn);
 
@@ -349,6 +386,7 @@ describe("TaskDetailModal oversight controls", () => {
       />,
     );
 
+    await openOversightMenu();
     const explainBtn = await screen.findByTestId("detail-overseer-explain");
     fireEvent.click(explainBtn);
 
@@ -372,6 +410,7 @@ describe("TaskDetailModal oversight controls", () => {
       />,
     );
 
+    await openOversightMenu();
     const explainBtn = await screen.findByTestId("detail-overseer-explain");
     // Read-only Explain must never be disabled purely because the overseer
     // isn't actively watching — that inactive state is exactly what the
@@ -397,9 +436,11 @@ describe("TaskDetailModal oversight controls", () => {
       />,
     );
 
-    // 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.
+    // The quick level-change select still renders inside the opened menu
+    // (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 openOversightMenu();
     await screen.findByTestId("detail-oversight-level-select");
     expect(screen.queryByTestId("detail-overseer-nudge")).not.toBeInTheDocument();
     expect(screen.queryByTestId("detail-overseer-stop")).not.toBeInTheDocument();
@@ -416,8 +457,10 @@ sites pass a slim `Task` (no `prompt` key) that never carries
 `plannerOverseerState` — only the full-detail fetch response does. These
 tests reproduce that exact path: a slim task prop with NO snapshot, plus a
 mocked `fetchTaskDetail` resolving a full TaskDetail WITH an active snapshot,
-and assert Nudge enables (helper absent) once the fetched detail lands — at
-both the desktop inline site and the mobile overflow-menu site.
+and assert Nudge enables (helper absent) once the fetched detail lands —
+behind the (now universal, FN-7604) overflow-menu trigger at both a
+"desktop" and a narrow-viewport width, exercised via the shared
+`openOversightMenu()` helper.
 */
 describe("TaskDetailModal oversight controls — snapshot delivered via fetched full detail (FN-7600)", () => {
   const originalInnerWidth = window.innerWidth;
@@ -471,6 +514,7 @@ describe("TaskDetailModal oversight controls — snapshot delivered via fetched
       />,
     );
 
+    await openOversightMenu();
     const nudgeBtn = await screen.findByTestId("detail-overseer-nudge");
     await waitFor(() => {
       expect(nudgeBtn).not.toBeDisabled();
@@ -498,6 +542,7 @@ describe("TaskDetailModal oversight controls — snapshot delivered via fetched
       />,
     );
 
+    await openOversightMenu();
     const nudgeBtn = await screen.findByTestId("detail-overseer-nudge");
     expect(nudgeBtn).toBeDisabled();
     const reason = await screen.findByTestId("detail-overseer-nudge-disabled-reason");
@@ -545,18 +590,22 @@ describe("TaskDetailModal oversight controls — snapshot delivered via fetched
  * matching the pre-FN-7545 DOM (CSS-only `@media (max-width: 768px)` wrap,
  * no conditional mount). FN-7545 then collapsed that cluster's action
  * controls (level select / nudge / stop / explain) into a mobile overflow
- * menu: at `window.innerWidth <= OVERSIGHT_MENU_MOBILE_BREAKPOINT` (768) the
- * mount-time `updateOversightMenuMobile()` effect flips `isOversightMenuMobile`
- * to true, so those controls now render INSIDE a closed `detail-oversight-menu`
- * behind a `detail-oversight-menu-trigger` button instead of inline — the old
- * flat queries no longer find them. This suite is corrected to drive the real
- * FN-7545 mobile affordance: open the trigger, then query the menu items. It
- * still asserts the same invariants FN-7521 required — select-writes-on-change,
- * enabled nudge/stop/explain when the overseer is active, and no leftover
- * empty-menu shell for the off+inactive default — just through the shipped
- * mobile surface. The desktop branch (first `describe` above) is unchanged.
+ * menu behind a `detail-oversight-menu-trigger` button instead of inline —
+ * the old flat queries no longer find them. This suite drives the real
+ * FN-7545 overflow-menu affordance: open the trigger, then query the menu
+ * items.
+ *
+ * FNXC:PlannerOversight 2026-07-05-00:00 (FN-7604):
+ * The overflow menu this suite exercises is now the UNIVERSAL surface at
+ * every viewport, not a mobile-only branch — the desktop describe block
+ * above drives the exact same menu via the shared `openOversightMenu()`
+ * helper. Forcing `window.innerWidth = 375` here no longer selects a
+ * different code path; it is kept purely as a documented regression guard
+ * that the popover still renders/behaves correctly at a narrow width (e.g.
+ * `.detail-oversight-menu { right: 0 }` positioning), not because a second
+ * branch exists to select between.
  */
-describe("TaskDetailModal oversight controls — mobile breakpoint (FN-7521, FN-7545 overflow menu)", () => {
+describe("TaskDetailModal oversight controls — narrow-viewport regression guard (FN-7521, FN-7545/FN-7604 universal overflow menu)", () => {
   const originalInnerWidth = window.innerWidth;
 
   beforeEach(async () => {
@@ -568,10 +617,10 @@ describe("TaskDetailModal oversight controls — mobile breakpoint (FN-7521, FN-
     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 });
-    // Setting innerWidth before render is sufficient: TaskDetailModal's mount
-    // effect calls `updateOversightMenuMobile()` once on mount, reading
-    // `window.innerWidth` synchronously, which flips `isOversightMenuMobile`
-    // before the first paint the tests observe.
+    // Force a narrow viewport as a regression guard for the popover's mobile
+    // positioning/rendering; the overflow menu itself is the universal
+    // surface at every width post-FN-7604, so this no longer selects a
+    // separate branch.
     Object.defineProperty(window, "innerWidth", { value: 375, configurable: true });
   });
 
@@ -579,13 +628,9 @@ describe("TaskDetailModal oversight controls — mobile breakpoint (FN-7521, FN-
     Object.defineProperty(window, "innerWidth", { value: originalInnerWidth, configurable: true });
   });
 
-  async function openOversightMenu() {
-    const trigger = await screen.findByTestId("detail-oversight-menu-trigger");
-    fireEvent.click(trigger);
-    return trigger;
-  }
+  // Reuses the shared `openOversightMenu()` helper defined at file scope.
 
-  it("still renders the quick level-change select behind the mobile overflow menu and writes on change", async () => {
+  it("still renders the quick level-change select behind the overflow menu and writes on change", async () => {
     const api = await import("../../api");
     const mockUpdate = vi.fn().mockResolvedValue(makeTask({ id: "FN-201", plannerOversightLevel: "steer" }));
     vi.mocked(api.updateTask).mockImplementation(mockUpdate as any);
@@ -613,7 +658,7 @@ describe("TaskDetailModal oversight controls — mobile breakpoint (FN-7521, FN-
     });
   });
 
-  it("still renders enabled nudge/stop/explain controls behind the mobile overflow menu when the overseer is actively watching", async () => {
+  it("still renders enabled nudge/stop/explain controls behind the overflow menu at a narrow viewport when the overseer is actively watching", async () => {
     render(
       <TaskDetailModal
         task={makeTask({ id: "FN-202", column: "in-progress", plannerOversightLevel: "autonomous", plannerOverseerState: activeSnapshot })}
@@ -633,7 +678,7 @@ describe("TaskDetailModal oversight controls — mobile breakpoint (FN-7521, FN-
     expect(await screen.findByTestId("detail-overseer-explain")).toBeTruthy();
   });
 
-  it("still shows the reworded periodic-observation copy (not the old alarming phrase) behind the mobile overflow menu (FN-7582)", async () => {
+  it("still shows the reworded periodic-observation copy (not the old alarming phrase) behind the overflow menu at a narrow viewport (FN-7582)", async () => {
     render(
       <TaskDetailModal
         task={makeTask({ id: "FN-216", column: "in-progress", plannerOversightLevel: "autonomous" })}
@@ -656,7 +701,7 @@ describe("TaskDetailModal oversight controls — mobile breakpoint (FN-7521, FN-
     expect(reason).toHaveTextContent("Nudge becomes available once the overseer is observing this task's current stage");
   });
 
-  it("still renders no oversight-control leftover shell behind the mobile overflow menu for the off+inactive default case", async () => {
+  it("still renders no oversight-control leftover shell behind the overflow menu at a narrow viewport for the off+inactive default case", async () => {
     render(
       <TaskDetailModal
         task={makeTask({ id: "FN-203", column: "todo", plannerOversightLevel: "off" })}
@@ -690,8 +735,17 @@ inline mount used. These assertions cover: (a) no inline mount remains,
 (b) the dropdown option appears/renders the timeline when oversight is
 active, (c) the option is absent and nothing mounts when oversight is off,
 and (d) selecting Interventions then losing oversight falls back to Live
-with no blank panel. Runs at the default (desktop) breakpoint, matching the
-first describe block's setup rather than the FN-7521/FN-7545 mobile one.
+with no blank panel.
+
+FNXC:PlannerOversight 2026-07-05-00:00:
+FN-7604 — these tests previously used `detail-overseer-nudge`/
+`detail-oversight-level-select` as a "wait for the oversight cluster to
+mount" sync point. Since ALL oversight controls now render only inside the
+closed-by-default overflow menu, that sync point no longer mounts without
+first opening the trigger. Retargeted to sync on `detail-oversight-menu-trigger`
+instead (the now-universal mount point) — the Intervention-Timeline-specific
+assertions (open Activity dropdown → click "Interventions" → assert
+`planner-intervention-timeline`) are otherwise unchanged.
 */
 describe("Intervention Timeline relocation into the Activity dropdown (FN-7571)", () => {
   beforeEach(async () => {
@@ -726,7 +780,7 @@ describe("Intervention Timeline relocation into the Activity dropdown (FN-7571)"
         />,
       );
 
-      await screen.findByTestId("detail-overseer-nudge");
+      await screen.findByTestId("detail-oversight-menu-trigger");
       expect(screen.queryByTestId("planner-intervention-timeline")).not.toBeInTheDocument();
     });
 
@@ -743,7 +797,7 @@ describe("Intervention Timeline relocation into the Activity dropdown (FN-7571)"
         />,
       );
 
-      await screen.findByTestId("detail-overseer-nudge");
+      await screen.findByTestId("detail-oversight-menu-trigger");
       openActivityViewMenu();
       const option = screen.getByRole("menuitem", { name: "Interventions" });
       fireEvent.click(option);
@@ -764,7 +818,7 @@ describe("Intervention Timeline relocation into the Activity dropdown (FN-7571)"
         />,
       );
 
-      await screen.findByTestId("detail-oversight-level-select");
+      await screen.findByTestId("detail-oversight-menu-trigger");
       openActivityViewMenu();
       expect(screen.queryByRole("menuitem", { name: "Interventions" })).not.toBeInTheDocument();
       expect(screen.queryByTestId("planner-intervention-timeline")).not.toBeInTheDocument();
@@ -783,7 +837,7 @@ describe("Intervention Timeline relocation into the Activity dropdown (FN-7571)"
         />,
       );
 
-      await screen.findByTestId("detail-overseer-nudge");
+      await screen.findByTestId("detail-oversight-menu-trigger");
       openActivityViewMenu();
       fireEvent.click(screen.getByRole("menuitem", { name: "Interventions" }));
       expect(await screen.findByTestId("planner-intervention-timeline")).toBeInTheDocument();
@@ -828,7 +882,7 @@ describe("Intervention Timeline relocation into the Activity dropdown (FN-7571)"
         />,
       );
 
-      await screen.findByTestId("detail-overseer-nudge");
+      await screen.findByTestId("detail-oversight-menu-trigger");
 
       openActivityViewMenu();
       fireEvent.click(screen.getByRole("menuitem", { name: "Feed" }));
@@ -858,7 +912,7 @@ describe("Intervention Timeline relocation into the Activity dropdown (FN-7571)"
         />,
       );
 
-      await screen.findByTestId("detail-overseer-nudge");
+      await screen.findByTestId("detail-oversight-menu-trigger");
       openActivityViewMenu();
       fireEvent.click(screen.getByRole("menuitem", { name: "Interventions" }));
 
diff --git a/packages/dashboard/app/components/__tests__/TaskDetailModal.oversight-mobile.test.tsx b/packages/dashboard/app/components/__tests__/TaskDetailModal.oversight-mobile.test.tsx
index ad14f00d29..bf1598e14d 100644
--- a/packages/dashboard/app/components/__tests__/TaskDetailModal.oversight-mobile.test.tsx
+++ b/packages/dashboard/app/components/__tests__/TaskDetailModal.oversight-mobile.test.tsx
@@ -1,15 +1,21 @@
 /*
 FNXC:PlannerOversight 2026-07-04-19:00:
-FN-7545 coverage for the mobile collapse of the FN-7517 oversight action
-controls into a single overflow menu (`detail-oversight-menu-trigger`). The
-suite forces the narrow-viewport branch by setting `window.innerWidth` below
-the `TaskDetailModal.tsx` `OVERSIGHT_MENU_MOBILE_BREAKPOINT` (768) BEFORE
-render, since the component reads `window.innerWidth` on mount via a resize
-listener (mirroring `DocumentsView`'s local `isMobile` pattern) rather than a
-CSS media query. Every action inside the menu reuses the SAME handlers and
-enablement gates as the desktop suite
-(`TaskDetailModal.oversight-controls.test.tsx`) — this file only asserts the
-collapsed-menu affordance, not new guard logic.
+FN-7545 coverage for the collapse of the FN-7517 oversight action controls
+into a single overflow menu (`detail-oversight-menu-trigger`). Every action
+inside the menu reuses the SAME handlers and enablement gates as the desktop
+suite (`TaskDetailModal.oversight-controls.test.tsx`) — this file only
+asserts the collapsed-menu affordance, not new guard logic.
+
+FNXC:PlannerOversight 2026-07-05-00:00:
+FN-7604 — the overflow menu is now the SINGLE UNIVERSAL surface at every
+viewport (desktop and mobile); it is no longer a narrow-viewport-only branch
+selected by a JS `isOversightMenuMobile` resize listener (that state, the
+`OVERSIGHT_MENU_MOBILE_BREAKPOINT` constant, and its effects were removed
+from `TaskDetailModal.tsx`). `setViewportWidth`/`MOBILE_WIDTH`/`DESKTOP_WIDTH`
+no longer select which branch mounts — both widths mount the exact same
+dropdown — they are kept as a documented regression guard that the popover
+still renders/positions/behaves correctly across a narrow AND a desktop
+viewport, per the Surface Enumeration breakpoint requirement.
 */
 import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
 import { render, screen, fireEvent, waitFor } from "@testing-library/react";
@@ -455,7 +461,7 @@ describe("TaskDetailModal oversight controls — mobile overflow menu", () => {
     expect(screen.getAllByRole("menu")).toHaveLength(1);
   });
 
-  it("desktop inline oversight select is unaffected by the mobile auto-focus fix", async () => {
+  it("the overflow-menu popover renders identically at a desktop viewport (FN-7604 universal dropdown)", async () => {
     setViewportWidth(DESKTOP_WIDTH);
 
     render(
@@ -470,12 +476,18 @@ describe("TaskDetailModal oversight controls — mobile overflow menu", () => {
       />,
     );
 
-    // Desktop renders the inline native select directly (no overflow trigger,
-    // no custom popover) — confirm that surface is untouched by this fix.
-    expect(screen.queryByTestId("detail-oversight-menu-trigger")).not.toBeInTheDocument();
+    // FNXC:PlannerOversight 2026-07-05-00:00: FN-7604 — there is no longer a
+    // desktop-only inline select surface; the overflow-menu trigger is the
+    // single universal mount point at every viewport, including desktop. The
+    // popover stays closed until clicked, exactly like the mobile width.
+    const trigger = await screen.findByTestId("detail-oversight-menu-trigger");
+    expect(screen.queryByTestId("detail-oversight-level-select")).not.toBeInTheDocument();
+    expect(screen.queryByRole("menu")).not.toBeInTheDocument();
+
+    fireEvent.click(trigger);
     const select = await screen.findByTestId("detail-oversight-level-select");
     expect(select).toBeInTheDocument();
-    expect(screen.queryByRole("menu")).not.toBeInTheDocument();
+    expect(screen.getByRole("menu")).toBeInTheDocument();
 
     setViewportWidth(MOBILE_WIDTH);
   });
diff --git a/packages/dashboard/app/components/__tests__/TaskDetailModal.rendering.test.tsx b/packages/dashboard/app/components/__tests__/TaskDetailModal.rendering.test.tsx
index e63acd3a39..0b5cdd3998 100644
--- a/packages/dashboard/app/components/__tests__/TaskDetailModal.rendering.test.tsx
+++ b/packages/dashboard/app/components/__tests__/TaskDetailModal.rendering.test.tsx
@@ -1,6 +1,13 @@
 /*
 FNXC:TaskDetailTabs 2026-06-17-08:20:
 FN-7306 labels the stable internal `chat` tab as Activity and keeps it as the default TaskDetailModal tab. Tests that assert Definition-only sections must opt into `initialTab="definition"` so they verify the intended surface instead of the Activity landing state.
+
+FNXC:PlannerOversight 2026-07-05-00:00:
+FN-7604 — the footer "Actions" dropdown button name is matched EXACTLY
+(`{ name: "Actions" }`) throughout this file, not via a loose `/actions/i`
+regex. The now-universal Oversight overflow trigger's aria-label is
+"Oversight actions", which also matches `/actions/i` and made every such
+query ambiguous once the trigger stopped being a mobile-only affordance.
 */
 import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
 import { render, screen, fireEvent, act, waitFor } from "@testing-library/react";
@@ -1538,7 +1545,7 @@ describe("TaskDetailModal", () => {
     );
 
     // Open Actions dropdown to see Retry
-    const actionsBtn = screen.getByRole("button", { name: /actions/i });
+    const actionsBtn = screen.getByRole("button", { name: "Actions" });
     fireEvent.click(actionsBtn);
 
     expect(screen.getByRole("menuitem", { name: "Retry" })).toBeTruthy();
@@ -1560,7 +1567,7 @@ describe("TaskDetailModal", () => {
     );
 
     // No Retry should be visible in the Actions dropdown
-    const actionsBtn = screen.getByRole("button", { name: /actions/i });
+    const actionsBtn = screen.getByRole("button", { name: "Actions" });
     fireEvent.click(actionsBtn);
     expect(screen.queryByRole("menuitem", { name: "Retry" })).toBeNull();
   });
@@ -1599,7 +1606,7 @@ describe("TaskDetailModal", () => {
       );
 
       // Open Actions dropdown and check for exactly one Retry
-      const actionsBtn = screen.getByRole("button", { name: /actions/i });
+      const actionsBtn = screen.getByRole("button", { name: "Actions" });
       fireEvent.click(actionsBtn);
 
       const retryButtons = screen.getAllByRole("menuitem", { name: "Retry" });
@@ -1622,7 +1629,7 @@ describe("TaskDetailModal", () => {
       );
 
       // Open Actions dropdown and check for exactly one Retry
-      const actionsBtn = screen.getByRole("button", { name: /actions/i });
+      const actionsBtn = screen.getByRole("button", { name: "Actions" });
       fireEvent.click(actionsBtn);
 
       const retryButtons = screen.getAllByRole("menuitem", { name: "Retry" });
@@ -1644,7 +1651,7 @@ describe("TaskDetailModal", () => {
         />,
       );
 
-      const actionsBtn = screen.getByRole("button", { name: /actions/i });
+      const actionsBtn = screen.getByRole("button", { name: "Actions" });
       fireEvent.click(actionsBtn);
 
       const retryButtons = screen.getAllByRole("menuitem", { name: "Retry" });
@@ -1670,7 +1677,7 @@ describe("TaskDetailModal", () => {
       );
 
       // Open Actions dropdown and click Retry
-      const actionsBtn = screen.getByRole("button", { name: /actions/i });
+      const actionsBtn = screen.getByRole("button", { name: "Actions" });
       await act(async () => {
         fireEvent.click(actionsBtn);
       });
@@ -1706,7 +1713,7 @@ describe("TaskDetailModal", () => {
       );
 
       // Open Actions dropdown and click Retry
-      const actionsBtn = screen.getByRole("button", { name: /actions/i });
+      const actionsBtn = screen.getByRole("button", { name: "Actions" });
       await act(async () => {
         fireEvent.click(actionsBtn);
       });
@@ -1746,7 +1753,7 @@ describe("TaskDetailModal", () => {
       );
 
       // Open Actions dropdown and click Retry
-      const actionsBtn = screen.getByRole("button", { name: /actions/i });
+      const actionsBtn = screen.getByRole("button", { name: "Actions" });
       await act(async () => {
         fireEvent.click(actionsBtn);
       });
@@ -1787,7 +1794,7 @@ describe("TaskDetailModal", () => {
       expect(screen.getByRole("menuitem", { name: "Back to In Progress" })).toBeTruthy();
       expect(screen.queryByRole("menuitem", { name: "Move to Todo" })).toBeNull();
 
-      const actionsBtn = screen.getByRole("button", { name: /actions/i });
+      const actionsBtn = screen.getByRole("button", { name: "Actions" });
       fireEvent.click(actionsBtn);
       expect(screen.queryByRole("menuitem", { name: "Retry" })).toBeNull();
     });
@@ -1807,7 +1814,7 @@ describe("TaskDetailModal", () => {
         />,
       );
 
-      const actionsBtn = screen.getByRole("button", { name: /actions/i });
+      const actionsBtn = screen.getByRole("button", { name: "Actions" });
       await act(async () => {
         fireEvent.click(actionsBtn);
       });
diff --git a/packages/dashboard/app/components/__tests__/TaskDetailModal.responsive-and-dependencies.test.tsx b/packages/dashboard/app/components/__tests__/TaskDetailModal.responsive-and-dependencies.test.tsx
index c2ba62771d..c4342edd93 100644
--- a/packages/dashboard/app/components/__tests__/TaskDetailModal.responsive-and-dependencies.test.tsx
+++ b/packages/dashboard/app/components/__tests__/TaskDetailModal.responsive-and-dependencies.test.tsx
@@ -232,13 +232,16 @@ describe("TaskDetailModal", () => {
       const inlineControlsBlock = getStandaloneCssRuleBlock(css, ".detail-meta-inline-controls");
       const priorityChipBlock = getExactCssRuleBlock(css, ".detail-priority-chip");
       const executionToggleBlock = getExactCssRuleBlock(css, ".detail-execution-mode-toggle");
-      const oversightChipBlock = getExactCssRuleBlock(css, ".detail-oversight-chip");
       const oversightTriggerBlock = getExactCssRuleBlock(css, ".detail-oversight-menu-trigger");
 
-      // The cluster declares one shared border-radius token; all four controls
-      // must reference it rather than four independent literal radii.
+      // The cluster declares one shared border-radius token; all three
+      // controls must reference it rather than independent literal radii.
+      // FNXC:PlannerOversight 2026-07-05-00:00: FN-7604 removed the desktop-only
+      // `.detail-oversight-chip` wrapper (the inline branch it styled was
+      // deleted); the Oversight surface is now represented solely by
+      // `.detail-oversight-menu-trigger`, which already carried this trio.
       expect(inlineControlsBlock).toContain("--detail-control-border-radius: var(--radius-md);");
-      for (const block of [priorityChipBlock, executionToggleBlock, oversightChipBlock, oversightTriggerBlock]) {
+      for (const block of [priorityChipBlock, executionToggleBlock, oversightTriggerBlock]) {
         expect(block).toContain("border-radius: var(--detail-control-border-radius);");
         expect(block).toContain("border-width: var(--btn-border-width);");
         expect(block).toContain("border-color: var(--border);");
@@ -247,26 +250,25 @@ describe("TaskDetailModal", () => {
         expect(block).toContain("box-sizing: border-box;");
       }
 
-      // Guard against regressing back to four independent literal radius values
-      // (e.g. reintroducing a bare `var(--radius-pill)` on only the chips).
+      // Guard against regressing back to independent literal radius values
+      // (e.g. reintroducing a bare `var(--radius-pill)` on the priority chip).
       expect(priorityChipBlock).not.toMatch(/border-radius:\s*var\(--radius-pill\)/);
-      expect(oversightChipBlock).not.toMatch(/border-radius:\s*var\(--radius-pill\)/);
+      expect(oversightTriggerBlock).not.toMatch(/border-radius:\s*var\(--radius-pill\)/);
     });
 
     it("renders the Priority dropdown chip like the Oversight dropdown chip, on every surface (FN-7597)", () => {
       const css = readDashboardStylesSource();
 
       const priorityChipBlock = getExactCssRuleBlock(css, ".detail-priority-chip");
-      const oversightChipBlock = getExactCssRuleBlock(css, ".detail-oversight-chip");
       const oversightTriggerBlock = getExactCssRuleBlock(css, ".detail-oversight-menu-trigger");
       const prioritySelectBlock = getExactCssRuleBlock(css, ".detail-priority-select");
       const oversightSelectBlock = getExactCssRuleBlock(css, ".detail-oversight-select");
       const prioritySelectOptionBlock = getExactCssRuleBlock(css, ".detail-priority-select option");
       const oversightSelectOptionBlock = getExactCssRuleBlock(css, ".detail-oversight-select option");
 
-      // Same box size AND same border source for the desktop Priority chip vs.
-      // BOTH oversight surfaces (desktop chip and the mobile overflow trigger).
-      for (const block of [priorityChipBlock, oversightChipBlock, oversightTriggerBlock]) {
+      // Same box size AND same border source for the Priority chip vs. the
+      // (now-universal, FN-7604) Oversight overflow trigger.
+      for (const block of [priorityChipBlock, oversightTriggerBlock]) {
         expect(block).toContain("min-height: var(--detail-priority-control-min-height);");
         expect(block).toContain("border-width: var(--btn-border-width);");
         expect(block).toContain("border-color: var(--border);");
@@ -613,8 +615,13 @@ describe("TaskDetailModal", () => {
         />,
       );
 
-      // Actions are now in a dropdown - open it first
-      const actionsBtn = screen.getByRole("button", { name: /actions/i });
+      // Actions are now in a dropdown - open it first.
+      // FNXC:PlannerOversight 2026-07-05-00:00: FN-7604 — the footer "Actions"
+      // dropdown button name must be matched EXACTLY (not `/actions/i`) because
+      // the now-universal Oversight overflow trigger's aria-label is "Oversight
+      // actions", which also matches a loose /actions/i regex and made this
+      // query ambiguous once the trigger stopped being mobile-only.
+      const actionsBtn = screen.getByRole("button", { name: "Actions" });
       fireEvent.click(actionsBtn);
 
       // Now the dropdown items should be visible
@@ -653,7 +660,7 @@ describe("TaskDetailModal", () => {
         />,
       );
 
-      fireEvent.click(screen.getByRole("button", { name: /actions/i }));
+      fireEvent.click(screen.getByRole("button", { name: "Actions" }));
       fireEvent.click(screen.getByRole("menuitem", { name: "Delete" }));
 
       await waitFor(() => {
@@ -680,7 +687,7 @@ describe("TaskDetailModal", () => {
         />,
       );
 
-      fireEvent.click(screen.getByRole("button", { name: /actions/i }));
+      fireEvent.click(screen.getByRole("button", { name: "Actions" }));
       fireEvent.click(screen.getByRole("menuitem", { name: "Delete" }));
 
       await waitFor(() => {
@@ -707,7 +714,7 @@ describe("TaskDetailModal", () => {
         />,
       );
 
-      fireEvent.click(screen.getByRole("button", { name: /actions/i }));
+      fireEvent.click(screen.getByRole("button", { name: "Actions" }));
       fireEvent.click(screen.getByRole("menuitem", { name: "Delete" }));
 
       await waitFor(() => {
@@ -732,7 +739,7 @@ describe("TaskDetailModal", () => {
         />,
       );
 
-      fireEvent.click(screen.getByRole("button", { name: /actions/i }));
+      fireEvent.click(screen.getByRole("button", { name: "Actions" }));
       fireEvent.click(screen.getByRole("menuitem", { name: "Delete" }));
 
       await waitFor(() => {
@@ -771,7 +778,7 @@ describe("TaskDetailModal", () => {
         />,
       );
 
-      fireEvent.click(screen.getByRole("button", { name: /actions/i }));
+      fireEvent.click(screen.getByRole("button", { name: "Actions" }));
       fireEvent.click(screen.getByRole("menuitem", { name: "Delete" }));
 
       await waitFor(() => {
@@ -833,7 +840,7 @@ describe("TaskDetailModal", () => {
         />,
       );
 
-      fireEvent.click(screen.getByRole("button", { name: /actions/i }));
+      fireEvent.click(screen.getByRole("button", { name: "Actions" }));
       fireEvent.click(screen.getByRole("menuitem", { name: "Delete" }));
 
       await waitFor(() => {
@@ -870,7 +877,7 @@ describe("TaskDetailModal", () => {
         />,
       );
 
-      fireEvent.click(screen.getByRole("button", { name: /actions/i }));
+      fireEvent.click(screen.getByRole("button", { name: "Actions" }));
       fireEvent.click(screen.getByRole("menuitem", { name: "Delete" }));
 
       await waitFor(() => {
@@ -907,7 +914,7 @@ describe("TaskDetailModal", () => {
         />,
       );
 
-      fireEvent.click(screen.getByRole("button", { name: /actions/i }));
+      fireEvent.click(screen.getByRole("button", { name: "Actions" }));
       fireEvent.click(screen.getByRole("menuitem", { name: "Delete" }));
 
       await waitFor(() => {
@@ -950,7 +957,7 @@ describe("TaskDetailModal", () => {
         />,
       );
 
-      fireEvent.click(screen.getByRole("button", { name: /actions/i }));
+      fireEvent.click(screen.getByRole("button", { name: "Actions" }));
       fireEvent.click(screen.getByRole("menuitem", { name: "Delete" }));
 
       await waitFor(() => {
@@ -981,7 +988,7 @@ describe("TaskDetailModal", () => {
         />,
       );
 
-      fireEvent.click(screen.getByRole("button", { name: /actions/i }));
+      fireEvent.click(screen.getByRole("button", { name: "Actions" }));
       fireEvent.click(screen.getByRole("menuitem", { name: "Delete" }));
 
       await waitFor(() => {
@@ -1018,7 +1025,7 @@ describe("TaskDetailModal", () => {
         />,
       );
 
-      fireEvent.click(screen.getByRole("button", { name: /actions/i }));
+      fireEvent.click(screen.getByRole("button", { name: "Actions" }));
       fireEvent.click(screen.getByRole("menuitem", { name: "Delete" }));
 
       await waitFor(() => {
@@ -1052,7 +1059,7 @@ describe("TaskDetailModal", () => {
         />,
       );
 
-      fireEvent.click(screen.getByRole("button", { name: /actions/i }));
+      fireEvent.click(screen.getByRole("button", { name: "Actions" }));
       fireEvent.click(screen.getByRole("menuitem", { name: "Delete" }));
 
       await waitFor(() => {

From e347062e1f55ca4a59de556d379b00247cb1d2b5 Mon Sep 17 00:00:00 2001
From: gsxdsm <gsxdsm@users.noreply.github.com>
Date: Sun, 5 Jul 2026 19:42:16 -0700
Subject: [PATCH 63/65] FN-7603: force xterm DOM-based char measurement to fix
 mobile terminal spacing

Fixes recurrence #5 of mobile terminal inter-character spacing by unifying xterm's cell-width measurement pipeline with WidthCache's DOM-based glyph measurement, validated against real xterm instead of the jsdom mock.

- Add withDomBasedTerminalCharacterMeasurement() in terminalPreferences.ts: transiently hides window.OffscreenCanvas during terminal.open() so CharSizeService's constructor throws and self-selects its own DOM-based fallback strategy, unifying dimensions.css.cell.width with WidthCache.get('W') measurement
- Wire withDomBasedTerminalCharacterMeasurement() around terminal.open() calls in SessionTerminal.tsx and TerminalModal.tsx
- Add FNXC:Terminal comments documenting the Canvas-vs-DOM measurement divergence root cause, grounded in the installed @xterm/xterm@5.5.0 source
- Add docs/solutions/ui-bugs/xterm-options-noop-remeasure-after-font-settle.md recurrence #5 section
- Expand TerminalModal.test.tsx coverage for the new measurement-forcing behavior
- Add changeset fn-7603-mobile-terminal-spacing.md (patch, fix)

Files changed:
 .changeset/fn-7603-mobile-terminal-spacing.md      |   7 +
 docs/solutions/ui-bugs/xterm-options-noop-remeasure-after-font-settle.md | 101 ++++++
 packages/dashboard/app/components/SessionTerminal.tsx   |  16 +-
 packages/dashboard/app/components/TerminalModal.tsx     |  16 +-
 packages/dashboard/app/components/__tests__/TerminalModal.test.tsx    | 363 ++++++++++++++++++++-
 packages/dashboard/app/utils/terminalPreferences.ts     |  63 ++++
 6 files changed, 554 insertions(+), 12 deletions(-)

Fusion-Task-Id: FN-7603
Fusion-Task-Lineage: 6c7d980f-953e-4fa9-908e-b24125904cbe
Co-authored-by: Fusion (runfusion.ai) <noreply@runfusion.ai>
---
 .changeset/fn-7603-mobile-terminal-spacing.md |   7 +
 ...ptions-noop-remeasure-after-font-settle.md | 101 +++++
 .../app/components/SessionTerminal.tsx        |  16 +-
 .../app/components/TerminalModal.tsx          |  16 +-
 .../__tests__/TerminalModal.test.tsx          | 363 +++++++++++++++++-
 .../app/utils/terminalPreferences.ts          |  63 +++
 6 files changed, 554 insertions(+), 12 deletions(-)
 create mode 100644 .changeset/fn-7603-mobile-terminal-spacing.md

diff --git a/.changeset/fn-7603-mobile-terminal-spacing.md b/.changeset/fn-7603-mobile-terminal-spacing.md
new file mode 100644
index 0000000000..65ace4897f
--- /dev/null
+++ b/.changeset/fn-7603-mobile-terminal-spacing.md
@@ -0,0 +1,7 @@
+---
+"@runfusion/fusion": patch
+---
+
+summary: Fix persistent mobile terminal inter-character spacing (5th recurrence root cause).
+category: fix
+dev: xterm's CharSizeService picks a Canvas-based (OffscreenCanvas) or DOM-based character-measurement strategy at terminal.open() time; DomRenderer's letter-spacing bake always measures via a separate DOM-based WidthCache, so a Canvas-vs-DOM measurement mismatch survived FN-7561/FN-7567's remeasure-ordering fixes. `withDomBasedTerminalCharacterMeasurement` in terminalPreferences.ts forces CharSizeService onto the same DOM strategy for both TerminalModal and SessionTerminal.
diff --git a/docs/solutions/ui-bugs/xterm-options-noop-remeasure-after-font-settle.md b/docs/solutions/ui-bugs/xterm-options-noop-remeasure-after-font-settle.md
index 2ea9a036da..1ac2a1a29b 100644
--- a/docs/solutions/ui-bugs/xterm-options-noop-remeasure-after-font-settle.md
+++ b/docs/solutions/ui-bugs/xterm-options-noop-remeasure-after-font-settle.md
@@ -207,3 +207,104 @@ jsdom cannot exercise real xterm.js internals, so the FN-7567 regression models
   obtainable in this execution environment (headless coding agent, no physical device access) — this
   gap is recorded explicitly rather than treating jsdom/desktop WebKit as proof. See task document
   key="repro" on FN-7567 and `docs/ios-acceptance.md`.
+
+## Recurrence #5 (FN-7603): mock/real divergence — Canvas vs DOM character measurement
+
+FN-7561's `forceTerminalFontRemeasure()` and FN-7567's post-fit re-bake both ran correctly, and both
+were validated ONLY against jsdom test doubles that never exercise real `@xterm/xterm@5.5.0`. On the
+reported real mobile device, ordinary ASCII still rendered with visible gaps on the initial paint. This
+is the fifth recurrence of the same defect, so the FN-7603 executor was required to read the installed
+`@xterm/xterm@5.5.0`/`@xterm/addon-fit@0.10.0` source before touching production code (see task
+document key="xterm-source-audit" on FN-7603).
+
+### The actual mechanism
+
+xterm's `CharSizeService` selects ONE of two measurement strategies **the moment `terminal.open()`
+runs**:
+
+```js
+// @xterm/xterm/lib/xterm.js (installed 5.5.0), CharSizeService constructor
+try { this._measureStrategy = new OffscreenCanvasStrategy(optionsService) }      // canvas: ctx.measureText("W")
+catch { this._measureStrategy = new DomFallbackStrategy(document, container, optionsService) } // DOM: offsetWidth/32
+```
+
+The Canvas strategy is chosen whenever `OffscreenCanvas` + `CanvasRenderingContext2D.measureText()`
+reporting `fontBoundingBoxAscent`/`fontBoundingBoxDescent` are available — true on essentially every
+real modern mobile Safari/Chrome. `dimensions.css.cell.width` (which feeds both `FitAddon.fit()`'s
+column count, per the installed `addon-fit@0.10.0` `proposeDimensions()`, and
+`DomRenderer._setDefaultSpacing()`'s baked letter-spacing) derives from whichever strategy
+`CharSizeService` picked.
+
+Separately, `DomRenderer._setDefaultSpacing()` and `DomRendererRowFactory.createRow()`'s per-glyph
+override BOTH measure via `WidthCache`, which is **always** DOM-based (`offsetWidth` of a hidden
+32×-repeated-character span) — entirely independent of `CharSizeService`'s strategy choice. Real glyphs
+are painted 100% through the DOM (`DomRenderer` never draws through canvas). Canvas 2D text measurement
+and DOM/CSS text layout are two different browser rendering pipelines that can disagree — even by a
+fraction of a device pixel — for the same font on the same device; this is a documented,
+long-standing cross-API text-metrics inconsistency. `_setDefaultSpacing()`'s formula
+(`dimensions.css.cell.width - widthCache.get('W')`) only correctly converges to zero (tight, contiguous
+cells) when both operands are measured through the SAME pipeline. None of FN-7456/FN-7460/FN-7561/
+FN-7567 (or their test doubles) ever modeled this — all four assumed CharSizeService's measurement and
+WidthCache's measurement were the same value.
+
+### Why FN-7456/FN-7460/FN-7561/FN-7567 missed this
+
+Every prior fix's test double (`mockHandleCharSizeChanged`) treated the measured character width as a
+single shared value used for both "the cell width that drives fit" and "the width WidthCache subtracts
+in `_setDefaultSpacing()`" — a faithful-looking model of xterm's DOM-only fallback strategy, but NOT of
+the Canvas strategy that real xterm actually selects by default on real mobile browsers. Because jsdom
+cannot run real `@xterm/xterm`, and no fix before FN-7603 cross-checked the double against the installed
+source, the divergence between "what CharSizeService measures" (Canvas, in the real common case) and
+"what WidthCache measures" (always DOM) went completely uncovered for four recurrences.
+
+### Solution
+
+Force `CharSizeService` to construct with its own DOM fallback strategy — unifying the cell-width
+measurement with `WidthCache`'s measurement — by making `OffscreenCanvas` transiently unavailable for
+the synchronous duration of `terminal.open()` (where `CharSizeService` is constructed):
+
+```ts
+// packages/dashboard/app/utils/terminalPreferences.ts
+export function withDomBasedTerminalCharacterMeasurement<T>(fn: () => T): T {
+  const descriptor = Object.getOwnPropertyDescriptor(window, "OffscreenCanvas");
+  delete (window as any).OffscreenCanvas;
+  try {
+    return fn();
+  } finally {
+    if (descriptor) Object.defineProperty(window, "OffscreenCanvas", descriptor);
+  }
+}
+```
+
+Both `TerminalModal.tsx` and `SessionTerminal.tsx` now wrap their `terminal.open(container)` call in
+`withDomBasedTerminalCharacterMeasurement(() => terminal.open(container))`. `CharSizeService`'s
+constructor try-block throws (no `OffscreenCanvas` global), so it self-selects the SAME DOM-based
+strategy `WidthCache` already always uses — no hardcoded letter-spacing/cell-width compensation is
+added; the fix unifies the measurement pipeline instead.
+
+Do not:
+
+- Patch `window.OffscreenCanvas` outside the narrow synchronous `open()` window — other page code
+  (charts, canvas-based rendering elsewhere in the dashboard) may legitimately need it.
+- Assume this is scoped to mobile only — desktop with the DOM renderer (WebGL addon failed to load, or
+  `renderer: "canvas"` preference) has the identical divergence and benefits from the same fix.
+- Treat this as a replacement for FN-7561/FN-7567 — both remain necessary; this fix addresses a
+  different, independent measurement-pipeline mismatch.
+
+### Regression coverage (Canvas-vs-DOM divergence, not CSS/call-count)
+
+- Extended the FN-7567 double: `mockCanvasCharWidthPx` (drives `FitAddon.fit()`'s column count,
+  mirroring `dimensions.css.cell.width`) can diverge from `mockDomCharWidthPx` (mirrors
+  `WidthCache.get('W')`) by a fixed offset, gated on `window.OffscreenCanvas` being defined at the
+  moment the mock's `open()` runs — exactly mirroring the real `CharSizeService` constructor's
+  try/catch strategy selection.
+- The assertion is the same rendered-geometry invariant as FN-7567 (baked letter-spacing `== 0`), but
+  now fails on HEAD even with the full FN-7561/FN-7567 settle+pre/post-fit-remeasure sequence present,
+  because the divergence is NOT an ordering bug — it's a measurement-pipeline bug those fixes cannot
+  see or fix.
+- See `TerminalModal.test.tsx` describe block "FN-7603 mobile inter-character spacing (Canvas vs DOM
+  CharSizeService measurement divergence)".
+- Run: `pnpm --filter @fusion/dashboard exec vitest run app/components/__tests__/TerminalModal.test.tsx app/components/__tests__/SessionTerminal.test.tsx app/components/__tests__/SessionTerminal.mobile.test.tsx app/utils/__tests__/terminalPreferences.test.ts app/__tests__/terminal-input.test.ts --silent=passed-only --reporter=dot`.
+- Real mobile Safari/Chrome sanity check remains the strongest signal; a real-device screenshot was not
+  obtainable in this execution environment — this gap is recorded explicitly (task document
+  key="repro" on FN-7603) rather than treating jsdom/desktop WebKit as proof.
diff --git a/packages/dashboard/app/components/SessionTerminal.tsx b/packages/dashboard/app/components/SessionTerminal.tsx
index 1b0d72cd2f..f81c358432 100644
--- a/packages/dashboard/app/components/SessionTerminal.tsx
+++ b/packages/dashboard/app/components/SessionTerminal.tsx
@@ -15,6 +15,7 @@ import {
   resolveTerminalFontFamily,
   resolveTerminalGlyphFontFamily,
   waitForTerminalFontMetrics,
+  withDomBasedTerminalCharacterMeasurement,
 } from "../utils/terminalPreferences";
 
 /**
@@ -459,7 +460,20 @@ export function SessionTerminal({
       term.loadAddon(unicode11);
       term.unicode.activeVersion = "11";
 
-      term.open(containerRef.current);
+      /*
+      FNXC:Terminal 2026-07-05-12:40:
+      FN-7603 recurrence #5: mirror TerminalModal's fix — force xterm's
+      CharSizeService to self-select its DOM-based measurement strategy for
+      the synchronous duration of open() so cell-width measurement (feeding
+      FitAddon.fit() and DomRenderer._setDefaultSpacing()'s baked
+      letter-spacing) uses the SAME pipeline as WidthCache's DOM-based
+      per-glyph measurement, instead of the default Canvas/OffscreenCanvas
+      strategy that measures through a different pipeline. See
+      docs/solutions/ui-bugs/xterm-options-noop-remeasure-after-font-settle.md.
+      */
+      withDomBasedTerminalCharacterMeasurement(() => {
+        term.open(containerRef.current!);
+      });
       xtermRef.current = term;
       fitAddonRef.current = fitAddon as unknown as ITerminalAddon;
 
diff --git a/packages/dashboard/app/components/TerminalModal.tsx b/packages/dashboard/app/components/TerminalModal.tsx
index 39e4c78bf1..041fb2f2cc 100644
--- a/packages/dashboard/app/components/TerminalModal.tsx
+++ b/packages/dashboard/app/components/TerminalModal.tsx
@@ -46,6 +46,7 @@ import {
   resolveTerminalFontFamily,
   resolveTerminalGlyphFontFamily,
   waitForTerminalFontMetrics,
+  withDomBasedTerminalCharacterMeasurement,
   writeTerminalPreferences,
   type TerminalPreferences,
   type TerminalRenderer,
@@ -1406,7 +1407,20 @@ export function TerminalModal({ isOpen, onClose, initialCommand, initialCommandG
         }
 
         // Open terminal in container
-        terminal.open(terminalRef.current);
+        /*
+        FNXC:Terminal 2026-07-05-12:40:
+        FN-7603 recurrence #5: force xterm's CharSizeService to self-select its
+        DOM-based measurement strategy (instead of its default Canvas/
+        OffscreenCanvas strategy) for the synchronous duration of open(), so the
+        cell-width measurement that feeds FitAddon.fit() and
+        DomRenderer._setDefaultSpacing()'s baked letter-spacing uses the SAME
+        pipeline as WidthCache's DOM-based per-glyph measurement. See
+        `withDomBasedTerminalCharacterMeasurement` and
+        docs/solutions/ui-bugs/xterm-options-noop-remeasure-after-font-settle.md.
+        */
+        withDomBasedTerminalCharacterMeasurement(() => {
+          terminal.open(terminalRef.current!);
+        });
 
         // Clear watchdog — imports and open() succeeded within deadline
         if (watchdogTimer) {
diff --git a/packages/dashboard/app/components/__tests__/TerminalModal.test.tsx b/packages/dashboard/app/components/__tests__/TerminalModal.test.tsx
index 40d96c86ce..14ca8230e2 100644
--- a/packages/dashboard/app/components/__tests__/TerminalModal.test.tsx
+++ b/packages/dashboard/app/components/__tests__/TerminalModal.test.tsx
@@ -83,13 +83,40 @@ CSS-property or call-count check.
 const MOCK_CONTAINER_WIDTH_PX = 728;
 const MOCK_FALLBACK_CHAR_WIDTH_PX = 9;
 const MOCK_SETTLED_CHAR_WIDTH_PX = 7;
+/*
+FNXC:Terminal 2026-07-05-12:45:
+FN-7603 recurrence #5: real xterm's `CharSizeService` picks ONE of two
+measurement strategies at `terminal.open()` time — Canvas/OffscreenCanvas
+(`ctx.measureText("W")`, chosen whenever `OffscreenCanvas` + the required
+`TextMetrics` fields are available, i.e. virtually every real mobile browser)
+or a DOM fallback (`offsetWidth` of a hidden repeated-"W" span, chosen only if
+the canvas strategy's constructor throws). Separately, `DomRenderer.
+_setDefaultSpacing()`/`DomRendererRowFactory` ALWAYS measure via `WidthCache`,
+which is ALWAYS DOM-based (`offsetWidth`), regardless of which strategy
+CharSizeService picked. The FN-7567 mock above (and prior recurrences) modeled
+both as the SAME shared width, hiding this divergence. Model them
+independently: `mockCanvasCharWidthPx` (drives `FitAddon.fit()`'s column
+count, mirroring `dimensions.css.cell.width`) can diverge from
+`mockDomCharWidthPx` (mirrors `WidthCache.get('W')`) whenever
+`window.OffscreenCanvas` is defined at the moment the mock's `open()` runs —
+exactly mirroring the real `CharSizeService` constructor's
+`try { new OffscreenCanvasStrategy } catch { new DomFallbackStrategy }`
+selection. The production fix (`withDomBasedTerminalCharacterMeasurement`)
+hides `window.OffscreenCanvas` for the synchronous duration of `open()`, which
+this mock's `open()` observes to decide which strategy was "selected".
+*/
+const MOCK_CANVAS_DOM_DIVERGENCE_PX = 0.7;
 let mockFontsSettledForCharSize = false;
-let mockMeasuredCharWidthPx = MOCK_FALLBACK_CHAR_WIDTH_PX;
+let mockDomCharWidthPx = MOCK_FALLBACK_CHAR_WIDTH_PX;
+let mockCanvasCharWidthPx = MOCK_FALLBACK_CHAR_WIDTH_PX;
+let mockCharSizeServiceUsesCanvasStrategy = true;
 let mockBakedLetterSpacingPx = 0;
 
 function resetMockTerminalGeometry(): void {
   mockFontsSettledForCharSize = false;
-  mockMeasuredCharWidthPx = MOCK_FALLBACK_CHAR_WIDTH_PX;
+  mockDomCharWidthPx = MOCK_FALLBACK_CHAR_WIDTH_PX;
+  mockCanvasCharWidthPx = MOCK_FALLBACK_CHAR_WIDTH_PX;
+  mockCharSizeServiceUsesCanvasStrategy = true;
   mockBakedLetterSpacingPx = 0;
   mockTerminalInstance.cols = 80;
 }
@@ -104,27 +131,48 @@ function getMockBakedLetterSpacingPx(): number {
   return mockBakedLetterSpacingPx;
 }
 
+/**
+ * Mirrors real xterm's `CharSizeService` constructor picking its measurement
+ * strategy the moment `terminal.open()` runs: Canvas/OffscreenCanvas when
+ * `window.OffscreenCanvas` is present, DOM fallback otherwise.
+ */
+function mockSelectCharSizeServiceStrategyAtOpen(): void {
+  mockCharSizeServiceUsesCanvasStrategy =
+    typeof (window as unknown as { OffscreenCanvas?: unknown }).OffscreenCanvas !== "undefined";
+}
+
 // Mirrors xterm's CharSizeService.measure() -> onCharSizeChange ->
 // DomRenderer.handleCharSizeChanged() -> _updateDimensions() +
 // _setDefaultSpacing(): runs on every GENUINE fontFamily/fontSize option
 // transition, using the CURRENT (possibly stale, pre-fit) column count.
+//
+// `mockDomCharWidthPx` mirrors `WidthCache.get('W')` (always DOM-based).
+// `mockCanvasCharWidthPx` mirrors `CharSizeService.width`: identical to the
+// DOM value when the DOM strategy was selected at open(), but offset by a
+// fixed divergence when the Canvas strategy was selected — modeling the real
+// cross-pipeline (Canvas 2D vs DOM layout) measurement discrepancy that
+// `_setDefaultSpacing()`'s `dimensions.css.cell.width - widthCache.get('W')`
+// formula depends on both operands agreeing to correctly converge to zero.
 function mockHandleCharSizeChanged(): void {
-  mockMeasuredCharWidthPx = mockFontsSettledForCharSize
+  mockDomCharWidthPx = mockFontsSettledForCharSize
     ? MOCK_SETTLED_CHAR_WIDTH_PX
     : MOCK_FALLBACK_CHAR_WIDTH_PX;
+  mockCanvasCharWidthPx = mockCharSizeServiceUsesCanvasStrategy
+    ? mockDomCharWidthPx + MOCK_CANVAS_DOM_DIVERGENCE_PX
+    : mockDomCharWidthPx;
   const cols = (mockTerminalInstance.cols as number) || 1;
   const cellWidthPx = MOCK_CONTAINER_WIDTH_PX / cols;
-  mockBakedLetterSpacingPx = cellWidthPx - mockMeasuredCharWidthPx;
+  mockBakedLetterSpacingPx = cellWidthPx - mockDomCharWidthPx;
 }
 
-// Mirrors FitAddon.fit() -> terminal.resize(cols, rows) ->
-// DomRenderer.handleResize(): recomputes cols/cell-width from the CURRENT
-// measured char width but deliberately does NOT touch letter-spacing (real
-// xterm's handleResize() never calls _setDefaultSpacing()).
+// Mirrors FitAddon.proposeDimensions(): cols = floor(availableWidth /
+// renderService.dimensions.css.cell.width) — the CANVAS-strategy-derived
+// value when that strategy is active, matching the installed
+// @xterm/addon-fit@0.10.0 source (`t.css.cell.width`).
 const mockFitAddonFit = vi.fn(() => {
   mockTerminalInstance.cols = Math.max(
     1,
-    Math.floor(MOCK_CONTAINER_WIDTH_PX / mockMeasuredCharWidthPx),
+    Math.floor(MOCK_CONTAINER_WIDTH_PX / mockCanvasCharWidthPx),
   );
 });
 
@@ -183,7 +231,11 @@ function createMockTerminalOptions(): Record<string, unknown> {
 
 const mockTerminalInstance = {
   loadAddon: vi.fn(),
-  open: vi.fn(),
+  // FN-7603: mirror the real CharSizeService constructor's strategy
+  // selection, which happens synchronously inside terminal.open().
+  open: vi.fn(() => {
+    mockSelectCharSizeServiceStrategyAtOpen();
+  }),
   onData: vi.fn((cb: (data: string) => void) => {
     terminalDataHandler = cb;
     return { dispose: vi.fn() };
@@ -7645,3 +7697,294 @@ describe("TerminalModal — FN-7567 mobile inter-character spacing (stale post-f
     });
   });
 });
+
+/*
+FNXC:Terminal 2026-07-05-12:50:
+FN-7603 (recurrence #5 of mobile terminal inter-character spacing, after
+FN-7456's DOM glyph-fallback fix, FN-7460's `text-size-adjust: none`,
+FN-7561's `forceTerminalFontRemeasure`, and FN-7567's post-fit re-bake) root
+cause, grounded against the installed `@xterm/xterm@5.5.0` source (see task
+document key="xterm-source-audit" on FN-7603): xterm's `CharSizeService`
+selects ONE of two independent measurement strategies the moment
+`terminal.open()` runs — a Canvas/`OffscreenCanvas` strategy (chosen whenever
+`OffscreenCanvas` + the required `TextMetrics` fields are available, i.e.
+virtually every real modern mobile browser) or a DOM fallback strategy (only
+selected if the canvas strategy's constructor throws). `dimensions.css.cell.width`
+(which feeds `FitAddon.fit()`'s column count AND `DomRenderer.
+_setDefaultSpacing()`'s baked letter-spacing) derives from whichever strategy
+CharSizeService picked. Separately, `WidthCache` (used by both
+`_setDefaultSpacing()` and `DomRendererRowFactory`'s per-glyph override) is
+ALWAYS DOM-based. Real glyphs are painted 100% through the DOM, so
+`_setDefaultSpacing()`'s `cell.width - widthCache.get('W')` formula only
+converges to zero — i.e. tight, contiguous monospace cells — when BOTH
+operands are measured through the SAME pipeline. Canvas 2D text measurement
+and DOM/CSS text layout are two different browser rendering pipelines that can
+disagree by a small but visible amount for the same font on the same device —
+a divergence none of FN-7456/FN-7460/FN-7561/FN-7567 (or their test doubles)
+ever modeled, because all four assumed a single unified character-width
+measurement. This is why the reported symptom survived every prior remedy:
+none of them touched WHICH measurement pipeline xterm's cell geometry is
+computed from, only WHEN it recomputes.
+
+The fix (`withDomBasedTerminalCharacterMeasurement` in terminalPreferences.ts)
+makes `window.OffscreenCanvas` transiently unavailable for the synchronous
+duration of `terminal.open()`, forcing `CharSizeService`'s constructor
+try-block to throw and self-select its own DOM fallback strategy — unifying
+`dimensions.css.cell.width` and `WidthCache.get('W')` onto the SAME
+measurement pipeline instead of adding any hardcoded letter-spacing
+compensation.
+
+This suite extends the FN-7567 geometry-accurate mock
+(`mockHandleCharSizeChanged`/`mockFitAddonFit`) to model the Canvas-vs-DOM
+divergence explicitly (`mockCanvasCharWidthPx` vs `mockDomCharWidthPx`, gated
+on `window.OffscreenCanvas` availability observed at the mock's `open()` call
+— exactly mirroring the real CharSizeService constructor's strategy
+selection), which the FN-7567 double could not represent (it modeled both
+measurements as a single shared value). It fails on pre-fix code — where
+`window.OffscreenCanvas` stays available throughout `open()`, so the mock
+selects its "Canvas strategy" and the baked letter-spacing settles to a
+persistent NONZERO value even after the full settle + pre/post-fit remeasure
+sequence FN-7561/FN-7567 added — and passes once the fix hides
+`OffscreenCanvas` around `open()`, converging the bake to exactly zero.
+See `docs/solutions/ui-bugs/xterm-options-noop-remeasure-after-font-settle.md`
+recurrence-#5 section.
+*/
+describe("TerminalModal — FN-7603 mobile inter-character spacing (Canvas vs DOM CharSizeService measurement divergence)", () => {
+  const mockOnClose = vi.fn();
+  const mockSendInput = vi.fn();
+  const mockResize = vi.fn();
+  const mockReconnect = vi.fn();
+
+  const createMockTerminalState = (overrides = {}) => ({
+    connectionStatus: "connected" as const,
+    sendInput: mockSendInput,
+    resize: mockResize,
+    onData: vi.fn(() => vi.fn()),
+    onExit: vi.fn(() => vi.fn()),
+    onConnect: vi.fn(() => vi.fn()),
+    onScrollback: vi.fn(() => vi.fn()),
+    reconnect: mockReconnect,
+    onSessionInvalid: vi.fn(() => vi.fn()),
+    ...overrides,
+  });
+
+  let previousInnerWidth: number;
+  let previousOntouchstart: unknown;
+  let previousOffscreenCanvas: unknown;
+  let hadOwnOffscreenCanvas: boolean;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    resetFontRemeasureCount();
+    resetMockTerminalGeometry();
+    vi.spyOn(window, "matchMedia").mockImplementation((query: string) => ({
+      matches: false,
+      media: query,
+      onchange: null,
+      addListener: vi.fn(),
+      removeListener: vi.fn(),
+      addEventListener: vi.fn(),
+      removeEventListener: vi.fn(),
+      dispatchEvent: vi.fn(),
+    }));
+    previousInnerWidth = window.innerWidth;
+    previousOntouchstart = window.ontouchstart;
+    hadOwnOffscreenCanvas = Object.prototype.hasOwnProperty.call(window, "OffscreenCanvas");
+    previousOffscreenCanvas = (window as unknown as { OffscreenCanvas?: unknown }).OffscreenCanvas;
+    // Real reported device: a narrow touch-primary mobile viewport with a
+    // modern engine that supports OffscreenCanvas (true on essentially every
+    // real mobile Safari/Chrome), so xterm's CharSizeService would pick its
+    // Canvas measurement strategy absent the fix.
+    Object.defineProperty(window, "innerWidth", { value: 390, configurable: true });
+    Object.defineProperty(window, "ontouchstart", { value: null, configurable: true });
+    Object.defineProperty(window, "OffscreenCanvas", {
+      value: class MockOffscreenCanvas {},
+      writable: true,
+      configurable: true,
+    });
+    window.localStorage.removeItem(TERMINAL_FONT_SIZE_KEY);
+    window.localStorage.removeItem(TERMINAL_PREFERENCES_KEY);
+    mockTerminalInstance.options.fontFamily = XTERM_FONT_FAMILY;
+    mockTerminalInstance.options.fontSize = 12;
+    mockTerminalInstance.options.cursorStyle = "block";
+    mockTerminalInstance.options.cursorBlink = true;
+    resetFontRemeasureCount();
+    resetMockTerminalGeometry();
+    mockUseTerminal.mockReturnValue(createMockTerminalState());
+    mockUseTerminalSessions.mockReturnValue(defaultSessionState);
+    mockUseWorkspaces.mockReturnValue({
+      projectName: "kb",
+      workspaces: [],
+      loading: false,
+      error: null,
+    });
+    mockCreateTerminalSession.mockResolvedValue({
+      sessionId: "test-session-123",
+      shell: "/bin/bash",
+      cwd: "/project",
+    });
+  });
+
+  afterEach(() => {
+    Object.defineProperty(window, "innerWidth", { value: previousInnerWidth, configurable: true });
+    if (previousOntouchstart === undefined) {
+      delete (window as unknown as { ontouchstart?: unknown }).ontouchstart;
+    } else {
+      Object.defineProperty(window, "ontouchstart", { value: previousOntouchstart, configurable: true });
+    }
+    if (hadOwnOffscreenCanvas) {
+      Object.defineProperty(window, "OffscreenCanvas", {
+        value: previousOffscreenCanvas,
+        writable: true,
+        configurable: true,
+      });
+    } else {
+      delete (window as unknown as { OffscreenCanvas?: unknown }).OffscreenCanvas;
+    }
+    vi.useRealTimers();
+    vi.restoreAllMocks();
+  });
+
+  it("converges baked letter-spacing to exactly zero by forcing xterm off its Canvas character-measurement strategy during open()", async () => {
+    let resolveLoad: (() => void) | undefined;
+    let resolveReady: (() => void) | undefined;
+    Object.defineProperty(document, "fonts", {
+      value: {
+        load: vi.fn(
+          () =>
+            new Promise<void>((resolve) => {
+              resolveLoad = resolve;
+            }),
+        ),
+        ready: new Promise<void>((resolve) => {
+          resolveReady = resolve;
+        }),
+      },
+      configurable: true,
+    });
+
+    render(<TerminalModal isOpen={true} onClose={mockOnClose} />);
+
+    await waitFor(() => expect(mockTerminalInstance.open).toHaveBeenCalled());
+    resetFontRemeasureCount();
+
+    settleMockTerminalFontForCharSize();
+
+    await act(async () => {
+      resolveLoad?.();
+      resolveReady?.();
+      await Promise.resolve();
+      await Promise.resolve();
+      await Promise.resolve();
+    });
+
+    await waitFor(() => {
+      expect(getFontRemeasureCount()).toBeGreaterThan(0);
+    });
+
+    /*
+     * The decisive geometry assertion for this recurrence: on pre-fix code,
+     * `window.OffscreenCanvas` stays defined throughout `terminal.open()`, so
+     * the mock's CharSizeService strategy selects "Canvas" and
+     * `mockCanvasCharWidthPx` diverges from `mockDomCharWidthPx` by
+     * `MOCK_CANVAS_DOM_DIVERGENCE_PX`. Even after the full FN-7561/FN-7567
+     * settle + pre/post-fit remeasure sequence runs to completion, the baked
+     * letter-spacing does NOT converge to zero — it settles at a persistent,
+     * nonzero residual driven purely by the Canvas-vs-DOM measurement
+     * mismatch, exactly matching "still spaced apart even after every prior
+     * fix ran correctly". This assertion fails on HEAD before this task's fix
+     * and passes once `withDomBasedTerminalCharacterMeasurement` hides
+     * `OffscreenCanvas` around `open()`.
+     */
+    await waitFor(() => {
+      expect(getMockBakedLetterSpacingPx()).toBeCloseTo(0, 5);
+    });
+  });
+
+  it("also converges to zero with the mobile keyboard already open and a persisted 10px font", async () => {
+    window.localStorage.setItem(TERMINAL_FONT_SIZE_KEY, "10");
+
+    const mockVV = {
+      width: 375,
+      height: 300,
+      offsetTop: 0,
+      offsetLeft: 0,
+      addEventListener: vi.fn(),
+      removeEventListener: vi.fn(),
+    };
+    Object.defineProperty(window, "visualViewport", {
+      value: mockVV,
+      writable: true,
+      configurable: true,
+    });
+    Object.defineProperty(window, "innerHeight", { value: 300, writable: true, configurable: true });
+
+    let resolveLoad: (() => void) | undefined;
+    let resolveReady: (() => void) | undefined;
+    Object.defineProperty(document, "fonts", {
+      value: {
+        load: vi.fn(
+          () =>
+            new Promise<void>((resolve) => {
+              resolveLoad = resolve;
+            }),
+        ),
+        ready: new Promise<void>((resolve) => {
+          resolveReady = resolve;
+        }),
+      },
+      configurable: true,
+    });
+
+    render(<TerminalModal isOpen={true} onClose={mockOnClose} />);
+
+    await waitFor(() => expect(mockTerminalInstance.open).toHaveBeenCalled());
+    resetFontRemeasureCount();
+    settleMockTerminalFontForCharSize();
+
+    await act(async () => {
+      resolveLoad?.();
+      resolveReady?.();
+      await Promise.resolve();
+      await Promise.resolve();
+      await Promise.resolve();
+    });
+
+    await waitFor(() => {
+      expect(getFontRemeasureCount()).toBeGreaterThan(0);
+    });
+
+    await waitFor(() => {
+      expect(getMockBakedLetterSpacingPx()).toBeCloseTo(0, 5);
+    });
+
+    Object.defineProperty(window, "visualViewport", { value: undefined, writable: true, configurable: true });
+  });
+
+  it("does not regress when the real browser has no OffscreenCanvas support (xterm already self-selects the DOM strategy)", async () => {
+    window.localStorage.removeItem(TERMINAL_FONT_SIZE_KEY);
+    delete (window as unknown as { OffscreenCanvas?: unknown }).OffscreenCanvas;
+    settleMockTerminalFontForCharSize();
+
+    Object.defineProperty(document, "fonts", {
+      value: {
+        load: vi.fn(() => Promise.resolve()),
+        ready: Promise.resolve(),
+      },
+      configurable: true,
+    });
+
+    render(<TerminalModal isOpen={true} onClose={mockOnClose} />);
+    await waitFor(() => expect(mockTerminalInstance.open).toHaveBeenCalled());
+
+    await act(async () => {
+      await Promise.resolve();
+      await Promise.resolve();
+      await Promise.resolve();
+    });
+
+    await waitFor(() => {
+      expect(getMockBakedLetterSpacingPx()).toBeCloseTo(0, 5);
+    });
+  });
+});
diff --git a/packages/dashboard/app/utils/terminalPreferences.ts b/packages/dashboard/app/utils/terminalPreferences.ts
index a97d5a2ba8..38e2aac000 100644
--- a/packages/dashboard/app/utils/terminalPreferences.ts
+++ b/packages/dashboard/app/utils/terminalPreferences.ts
@@ -231,6 +231,69 @@ export function forceTerminalFontRemeasure(
   terminal.options.fontFamily = fontFamily;
 }
 
+/*
+FNXC:Terminal 2026-07-05-12:40:
+FN-7603 recurrence #5 root cause (grounded in the installed `@xterm/xterm@5.5.0`
+source, see task doc key="xterm-source-audit" on FN-7603): xterm's
+`CharSizeService` picks its character-measurement strategy at construction time
+(inside `terminal.open()`) via `try { new OffscreenCanvasStrategy(optionsService) }
+catch { new DomFallbackStrategy(document, helperContainer, optionsService) }`.
+Whenever `OffscreenCanvas` + `CanvasRenderingContext2D.measureText()` reporting
+`fontBoundingBoxAscent`/`fontBoundingBoxDescent` are available — true on
+essentially every real modern mobile Safari/Chrome — the CANVAS strategy is
+chosen, and `dimensions.css.cell.width` (which feeds `FitAddon.fit()`'s column
+count AND `DomRenderer._setDefaultSpacing()`'s baked letter-spacing) is measured
+via Canvas 2D `ctx.measureText("W")`. Separately, `DomRenderer._setDefaultSpacing()`
+subtracts `WidthCache.get('W')` — an ENTIRELY SEPARATE, DOM-based measurement
+(`offsetWidth` of a hidden 32x-repeated-"W" span) — from that canvas-measured
+cell width to compute the compensating letter-spacing baked onto `.xterm-rows`.
+Those are two DIFFERENT browser text-rendering pipelines (Canvas 2D vs CSS/DOM
+layout) queried against the same font; real glyphs are painted 100% via DOM
+(`DomRenderer` never draws through canvas), so the only way for the baked
+spacing to reliably converge to the DOM's own natural (tight) glyph advance is
+for BOTH measurements to go through the SAME (DOM) pipeline. FN-7456/FN-7460/
+FN-7561/FN-7567 never touched which measurement strategy CharSizeService uses,
+only WHEN/how often it remeasures — so this Canvas-vs-DOM divergence survived
+all four prior fixes and can still bake a small-but-visible, non-zero,
+systematic inter-character gap on the very first mobile layout even after every
+prior remedy runs correctly. Force xterm onto the SAME (DOM) measurement
+pipeline CharSizeService already ships as its own fallback strategy by making
+`OffscreenCanvas` transiently unavailable for the synchronous duration of
+`terminal.open()`, so `CharSizeService`'s constructor try-block throws and it
+self-selects its own DOM-based `l` strategy — unifying `dimensions.css.cell.width`
+and `WidthCache.get('W')` onto one measurement pipeline instead of adding any
+hardcoded compensation. See `docs/solutions/ui-bugs/xterm-options-noop-remeasure-after-font-settle.md`
+recurrence #5 section.
+*/
+export function withDomBasedTerminalCharacterMeasurement<T>(fn: () => T): T {
+  if (typeof window === "undefined" || !("OffscreenCanvas" in window)) {
+    // Nothing to hide — CharSizeService will already fall back to its DOM
+    // strategy on its own (e.g. older WebKit without OffscreenCanvas support).
+    return fn();
+  }
+
+  const descriptor = Object.getOwnPropertyDescriptor(window, "OffscreenCanvas");
+  const originalValue = (window as unknown as Record<string, unknown>).OffscreenCanvas;
+
+  try {
+    delete (window as unknown as Record<string, unknown>).OffscreenCanvas;
+  } catch {
+    // Some environments define OffscreenCanvas as non-configurable; nothing
+    // we can safely do, so proceed without forcing the DOM strategy.
+    return fn();
+  }
+
+  try {
+    return fn();
+  } finally {
+    if (descriptor) {
+      Object.defineProperty(window, "OffscreenCanvas", descriptor);
+    } else if (originalValue !== undefined) {
+      (window as unknown as Record<string, unknown>).OffscreenCanvas = originalValue;
+    }
+  }
+}
+
 function isObject(value: unknown): value is Record<string, unknown> {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }

From f4f165640aee51a9c0735fe92676ba028ab32c52 Mon Sep 17 00:00:00 2001
From: gsxdsm <gsxdsm@users.noreply.github.com>
Date: Sun, 5 Jul 2026 19:51:35 -0700
Subject: [PATCH 64/65] FN-7607: fix manual PR flow gating to key off global
 auto-merge setting

Fixes TaskDetailModal so manual PR affordances stay visible based on the live global auto-merge setting rather than the per-task effective override, and repairs a pre-existing test regression from the FN-7510 oversight default change.

- isManualPrFlow now checks mergeStrategy === "pull-request" && !autoMergeEnabled (live global setting) instead of the per-task effective auto-merge override, fixing a regression from FN-7255 that stranded users without manual PR controls when a task's auto-merge override was true but global auto-merge was off.
- Pinned plannerOversightLevel: "off" on the Chat-first default-routing test fixture so the FN-7510 autonomous-oversight default doesn't add an extra Activity-view option and break the test's actual intent (asserting Chat-first tab routing).
- Added changeset documenting the fix.

Files changed:
 .changeset/fn-7607-manual-pr-flow.md                       |  7 +++++++
 packages/dashboard/app/components/TaskDetailModal.tsx      | 14 +++++++++++++-
 .../TaskDetailModal.attachments-and-tabs.test.tsx          | 12 +++++++++++-
 3 files changed, 31 insertions(+), 2 deletions(-)

Fusion-Task-Id: FN-7607

Fusion-Task-Lineage: f0b077d4-792f-4e43-8e40-43d325920be5

Co-authored-by: Fusion (runfusion.ai) <noreply@runfusion.ai>
---
 .changeset/fn-7607-manual-pr-flow.md               |  7 +++++++
 .../dashboard/app/components/TaskDetailModal.tsx   | 14 +++++++++++++-
 .../TaskDetailModal.attachments-and-tabs.test.tsx  | 12 +++++++++++-
 3 files changed, 31 insertions(+), 2 deletions(-)
 create mode 100644 .changeset/fn-7607-manual-pr-flow.md

diff --git a/.changeset/fn-7607-manual-pr-flow.md b/.changeset/fn-7607-manual-pr-flow.md
new file mode 100644
index 0000000000..9a4af33b9c
--- /dev/null
+++ b/.changeset/fn-7607-manual-pr-flow.md
@@ -0,0 +1,7 @@
+---
+"@runfusion/fusion": patch
+---
+
+summary: Fix manual PR actions hidden when a task auto-merge override was on but global auto-merge was off.
+category: fix
+dev: TaskDetailModal isManualPrFlow now keys off live global autoMergeEnabled, not the per-task effective override (regression from FN-7255).
diff --git a/packages/dashboard/app/components/TaskDetailModal.tsx b/packages/dashboard/app/components/TaskDetailModal.tsx
index a1edff3916..3f6f8fc86b 100644
--- a/packages/dashboard/app/components/TaskDetailModal.tsx
+++ b/packages/dashboard/app/components/TaskDetailModal.tsx
@@ -3130,7 +3130,19 @@ export function TaskDetailContent({
   const mergeStrategy = settings?.mergeStrategy ?? "direct";
   const autoMergeEnabled = autoMergeEnabledProp ?? (settings?.autoMerge ?? false);
   const effectiveAutoMerge = resolveEffectiveAutoMerge({ autoMerge: task.autoMerge }, { autoMerge: autoMergeEnabled });
-  const isManualPrFlow = mergeStrategy === "pull-request" && !effectiveAutoMerge;
+  /*
+  FNXC:TaskDetailPr 2026-07-05-19:45:
+  Manual PR flow visibility must follow the LIVE GLOBAL auto-merge setting
+  (`autoMergeEnabled`), not the per-task effective auto-merge override
+  (`effectiveAutoMerge`). Otherwise a per-task auto-merge override of `true`
+  hides manual PR affordances even when global auto-merge is off, stranding
+  the user with no way to manually open/manage the PR (FN-7607; regression
+  introduced by FN-7255 / commit 924bcb97d, which switched this from
+  `!autoMergeEnabled` to `!effectiveAutoMerge`). The `autoMerge` prop passed
+  to PrPanel stays `effectiveAutoMerge` — only this flow-gating boolean is
+  keyed off the live global setting.
+  */
+  const isManualPrFlow = mergeStrategy === "pull-request" && !autoMergeEnabled;
   /*
   FNXC:PlannerOversight 2026-07-04-17:00:
   FN-7517 enablement rules for the nudge/stop/explain controls. Nudge and
diff --git a/packages/dashboard/app/components/__tests__/TaskDetailModal.attachments-and-tabs.test.tsx b/packages/dashboard/app/components/__tests__/TaskDetailModal.attachments-and-tabs.test.tsx
index d61fdde6b1..959a10ec4b 100644
--- a/packages/dashboard/app/components/__tests__/TaskDetailModal.attachments-and-tabs.test.tsx
+++ b/packages/dashboard/app/components/__tests__/TaskDetailModal.attachments-and-tabs.test.tsx
@@ -483,9 +483,19 @@ describe("TaskDetailModal", () => {
 
   describe("tab toggle", () => {
     it("restores planner Chat as the omitted non-done default when Chat-first is enabled", () => {
+      /*
+      FNXC:PlannerOversight 2026-07-05-19:45:
+      FN-7510 made DEFAULT_PLANNER_OVERSIGHT_LEVEL = "autonomous", so a task
+      fixture with no per-task override and no resolvable workflow now
+      legitimately resolves oversight-active, which surfaces an additional
+      "Interventions" Activity-view option. This test's intent is to assert
+      Chat-first default routing (the omitted-tab default lands on Chat), not
+      oversight gating, so pin plannerOversightLevel: "off" to keep the
+      three-label Activity-view assertion meaningful and honest (FN-7607).
+      */
       const { container } = render(
         <TaskDetailModal
-          task={makeTask({ prompt: "# Hello\n\nContent" })}
+          task={makeTask({ prompt: "# Hello\n\nContent", plannerOversightLevel: "off" })}
           taskDetailChatFirst
           onClose={noop}
           onMoveTask={noopMove}

From eb8655579740a45e82e5a5a9053b739f485a7876 Mon Sep 17 00:00:00 2001
From: gsxdsm <gsxdsm@users.noreply.github.com>
Date: Sun, 5 Jul 2026 19:57:09 -0700
Subject: [PATCH 65/65] chore(release): v0.56.1

Version bump via changesets.
---
 .changeset/anthropic-oauth-refresh-scope.md   |   7 -
 .changeset/coding-ideas-custom-column-move.md |   7 -
 .changeset/fn-7602-shortcut-row-layout.md     |   7 -
 .changeset/fn-7603-mobile-terminal-spacing.md |   7 -
 .changeset/fn-7607-manual-pr-flow.md          |   7 -
 CHANGELOG.md                                  | 598 ++++++++++++++----
 package.json                                  |   2 +-
 packages/cli-alias/CHANGELOG.md               |  11 +
 packages/cli-alias/package.json               |   2 +-
 packages/cli/CHANGELOG.md                     |  20 +
 packages/cli/package.json                     |   2 +-
 packages/core/CHANGELOG.md                    |   2 +
 packages/core/package.json                    |   2 +-
 packages/dashboard/CHANGELOG.md               |  17 +
 packages/dashboard/package.json               |   2 +-
 packages/desktop/CHANGELOG.md                 |   8 +
 packages/desktop/package.json                 |   2 +-
 packages/droid-cli/CHANGELOG.md               |   6 +
 packages/droid-cli/package.json               |   2 +-
 packages/engine/CHANGELOG.md                  |   7 +
 packages/engine/package.json                  |   2 +-
 packages/i18n/CHANGELOG.md                    |   6 +
 packages/i18n/package.json                    |   2 +-
 packages/mobile/CHANGELOG.md                  |   2 +
 packages/mobile/package.json                  |   2 +-
 packages/pi-claude-cli/CHANGELOG.md           |   2 +
 packages/pi-claude-cli/package.json           |   2 +-
 packages/plugin-sdk/CHANGELOG.md              |   6 +
 packages/plugin-sdk/package.json              |   2 +-
 .../fusion-plugin-auto-label/CHANGELOG.md     |   6 +
 .../fusion-plugin-auto-label/package.json     |   2 +-
 .../fusion-plugin-ci-status/CHANGELOG.md      |   6 +
 .../fusion-plugin-ci-status/package.json      |   2 +-
 .../fusion-plugin-notification/CHANGELOG.md   |   6 +
 .../fusion-plugin-notification/package.json   |   2 +-
 .../fusion-plugin-settings-demo/CHANGELOG.md  |   6 +
 .../fusion-plugin-settings-demo/package.json  |   2 +-
 .../fusion-plugin-acp-runtime/CHANGELOG.md    |   7 +
 .../fusion-plugin-acp-runtime/package.json    |   2 +-
 .../fusion-plugin-agent-browser/CHANGELOG.md  |   6 +
 .../fusion-plugin-agent-browser/package.json  |   2 +-
 .../CHANGELOG.md                              |   7 +
 .../package.json                              |   2 +-
 .../CHANGELOG.md                              |   7 +
 .../package.json                              |   2 +-
 .../fusion-plugin-cursor-runtime/CHANGELOG.md |   6 +
 .../fusion-plugin-cursor-runtime/package.json |   2 +-
 .../CHANGELOG.md                              |   7 +
 .../package.json                              |   2 +-
 .../fusion-plugin-droid-runtime/CHANGELOG.md  |   6 +
 .../fusion-plugin-droid-runtime/package.json  |   2 +-
 .../CHANGELOG.md                              |   7 +
 .../package.json                              |   2 +-
 .../fusion-plugin-hermes-runtime/CHANGELOG.md |   6 +
 .../fusion-plugin-hermes-runtime/package.json |   2 +-
 .../fusion-plugin-linear-import/CHANGELOG.md  |   7 +
 .../fusion-plugin-linear-import/package.json  |   2 +-
 .../CHANGELOG.md                              |   6 +
 .../package.json                              |   2 +-
 .../CHANGELOG.md                              |   6 +
 .../package.json                              |   2 +-
 plugins/fusion-plugin-reports/CHANGELOG.md    |   8 +
 plugins/fusion-plugin-reports/package.json    |   2 +-
 plugins/fusion-plugin-roadmap/CHANGELOG.md    |   7 +
 plugins/fusion-plugin-roadmap/package.json    |   2 +-
 .../fusion-plugin-whatsapp-chat/CHANGELOG.md  |   6 +
 .../fusion-plugin-whatsapp-chat/package.json  |   2 +-
 67 files changed, 729 insertions(+), 176 deletions(-)
 delete mode 100644 .changeset/anthropic-oauth-refresh-scope.md
 delete mode 100644 .changeset/coding-ideas-custom-column-move.md
 delete mode 100644 .changeset/fn-7602-shortcut-row-layout.md
 delete mode 100644 .changeset/fn-7603-mobile-terminal-spacing.md
 delete mode 100644 .changeset/fn-7607-manual-pr-flow.md

diff --git a/.changeset/anthropic-oauth-refresh-scope.md b/.changeset/anthropic-oauth-refresh-scope.md
deleted file mode 100644
index 6dbb6e0632..0000000000
--- a/.changeset/anthropic-oauth-refresh-scope.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": patch
----
-
-summary: Fix Anthropic subscription showing "logged in" while all model calls fail.
-category: fix
-dev: Two-part fix. (1) OAuth token refresh in `packages/engine/src/auth-storage.ts` sent a `scope` param (defaulting to `user:profile`), which per RFC 6749 §6 re-issued the access token narrowed to that scope and stripped `user:inference` — so refreshed tokens 403'd on every model call. Refresh now omits `scope` (preserving the originally-granted scopes, matching pi-ai's own refresh), and `ANTHROPIC_DEFAULT_SCOPES` mirrors the full Claude Code scope set. (2) `/auth/status` now reports an unexpired Anthropic OAuth token that lacks an inference scope as not-connected (authenticated:false, expired:true so the re-login banner fires) with a scope-specific loginError, instead of falsely claiming a live session. Existing narrowed tokens need one re-login to obtain a fresh broad grant.
diff --git a/.changeset/coding-ideas-custom-column-move.md b/.changeset/coding-ideas-custom-column-move.md
deleted file mode 100644
index b0fcc920fb..0000000000
--- a/.changeset/coding-ideas-custom-column-move.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": patch
----
-
-summary: Fix "Invalid transition" error when moving cards out of a custom workflow column like Coding (Ideas) → Ideas.
-category: fix
-dev: moveTaskInternal's compat-flag legacy path validated moves against the legacy VALID_TRANSITIONS table, which is keyed only by the built-in column ids; a task in a non-legacy workflow column (e.g. "ideas") had no key and every move was rejected. The legacy branch now resolves a non-legacy source column's targets from the task's own workflow adjacency (resolveAllowedColumns) while preserving the legacy bare-Error contract for legacy columns.
diff --git a/.changeset/fn-7602-shortcut-row-layout.md b/.changeset/fn-7602-shortcut-row-layout.md
deleted file mode 100644
index 908fbba219..0000000000
--- a/.changeset/fn-7602-shortcut-row-layout.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": patch
----
-
-summary: Fix overlapping Record and Clear buttons in the Keyboard Shortcuts settings rows on desktop and mobile.
-category: fix
-dev: The shortcut-capture Record/Clear buttons no longer use the icon-only `btn-icon` class (which set `line-height:0` and a mobile 36px square, clipping/overlapping the text labels); they use a text-button class and the `.shortcut-capture` row locks buttons with `flex-shrink:0` so the input and controls never overlap, stacking cleanly on mobile.
diff --git a/.changeset/fn-7603-mobile-terminal-spacing.md b/.changeset/fn-7603-mobile-terminal-spacing.md
deleted file mode 100644
index 65ace4897f..0000000000
--- a/.changeset/fn-7603-mobile-terminal-spacing.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": patch
----
-
-summary: Fix persistent mobile terminal inter-character spacing (5th recurrence root cause).
-category: fix
-dev: xterm's CharSizeService picks a Canvas-based (OffscreenCanvas) or DOM-based character-measurement strategy at terminal.open() time; DomRenderer's letter-spacing bake always measures via a separate DOM-based WidthCache, so a Canvas-vs-DOM measurement mismatch survived FN-7561/FN-7567's remeasure-ordering fixes. `withDomBasedTerminalCharacterMeasurement` in terminalPreferences.ts forces CharSizeService onto the same DOM strategy for both TerminalModal and SessionTerminal.
diff --git a/.changeset/fn-7607-manual-pr-flow.md b/.changeset/fn-7607-manual-pr-flow.md
deleted file mode 100644
index 9a4af33b9c..0000000000
--- a/.changeset/fn-7607-manual-pr-flow.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-"@runfusion/fusion": patch
----
-
-summary: Fix manual PR actions hidden when a task auto-merge override was on but global auto-merge was off.
-category: fix
-dev: TaskDetailModal isManualPrFlow now keys off live global autoMergeEnabled, not the per-task effective override (regression from FN-7255).
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 60d1b72104..833a246cfc 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,123 +2,485 @@
 
 User-facing release notes aggregated across all packages. This file is auto-synced from each `packages/*/CHANGELOG.md` by `scripts/release.mjs` — do not edit by hand.
 
-## 0.56.0
-
-### New
-
-- Add a workflow setting to disable automatic large-task triage splitting.
-- Expand first-run AI provider quick-start choices beyond Anthropic.
-- Show Git prerequisite guidance during first-run GitHub onboarding.
-- Add GitHub OAuth and CLI setup actions to first-run onboarding.
-- Add configurable dashboard keyboard shortcuts for Quick Chat and Terminal.
-- Add search in Settings so operators can find settings faster.
-- Add before-to-after transformation summaries to generated task definitions.
-- Add a pinned below-application layout option for the dashboard terminal.
-- Show first-token and tool processing durations in task agent logs.
-- Settings descriptions now show each setting's default value.
-- Add a Reset Settings button to restore a menu's or all project settings to defaults.
-- Add a per-workflow planner oversight level setting (Off, Observe, Steer, Autonomous recovery).
-- Tasks can override the workflow planner oversight level (Off, Observe, Steer, Autonomous recovery).
-- Planner oversight now defaults to full steering/control for every workflow unless explicitly changed.
-- Planner oversight now monitors tasks across executor, reviewer, merger, pull-request, and workflow-gate stages.
-- Planner oversight can autonomously inject guidance, retry stuck/failed steps, and request fixes within bounded limits.
-- Planner oversight now requires confirmation before merge/PR actions and destructive/external side effects.
-- Planner overseer now stays fully hands-off for paused tasks and auto-merge-off / human-review tasks.
-- Configure planner oversight level per task and per project in the workflow editor and task create/detail.
-- Add a configurable planner-overseer notification verbosity level (Silent/Errors/Important/All).
-- Add a task-detail planner-overseer intervention timeline (stage, reason, action, outcome, attempts, links).
-- Emit planner-overseer run-audit events for observations, steering, retries, recovery, confirmations, and escalations.
-- Add an intelligent git-revert engine service and POST /api/tasks/:id/revert route.
-- Add an AI-undo fallback task when reverting a done task via git conflicts or is unsupported.
-- Add a Revert action to Done/Archived task cards to undo landed changes.
-- Capture a structured performance snapshot when an agent task completes.
-- Task cards can now show the planner overseer's active state (idle/watching/steering/recovering/awaiting-confirmation).
-- Original task prompt now renders as Markdown and is collapsed by default in the task Plan tab.
-- Support reverting multi-repo workspace tasks via git, all-or-nothing across sub-repos.
-- Add per-sha revert commit granularity to the task revert API and service.
-- Add a dedicated Keyboard Shortcuts settings section with click-to-record capture and more configurable actions.
-- Open a revert PR for done/archived tasks when autoMerge is disabled instead of refusing.
-- AI-undo tasks now default to a configurable, stricter review workflow.
-- Plan auto-approval is now the default; specified tasks skip manual approval unless you opt into workflow/require-all.
-- Move the planner intervention timeline into the task Activity view dropdown.
-- Fusion self-repo issue-close comments now show current and target release versions.
-- Open one revert PR per sub-repo for workspace tasks when autoMerge is disabled.
-- Add a Settings → General picker to choose the workflow used for AI-undo (revert) tasks.
-- Add "Ask user question" and "Exit gate" workflow nodes for mid-flow chat reach-out and early exit.
-- Add a built-in "Brainstorming" workflow that talks to you before planning.
-- Add a "Coding (Ideas)" workflow with a manual Ideas intake and a merged Todo planner column.
+## 0.56.1
 
 ### Fixed
 
-- Show active Plan Review progress on triage task cards.
-- Clarify task-detail oversight Nudge/Explain controls: visible label, disabled reason, always-openable Explain panel.
-- Unify border, radius, and height of the task-detail Priority/Execution/Oversight controls.
-- Keep the task-detail Activity view menu open during mobile iOS taps.
-- Fix Anthropic subscription login when pasted callback URLs contain fragment OAuth parameters.
-- Fix Claude/Anthropic subscription re-login showing "Login did not complete" after logging out.
-- Stop self-healing from killing actively-running tasks after ~30 minutes.
-- Stop Windows Terminal version dialogs from popping up when opening the dashboard or Settings on Windows.
-- Select newly created folders automatically during project setup.
-- Prevent Desktop update banners from using 0.0.0 as the current version.
-- Quit Fusion Desktop on Windows when the window is closed.
-- Open desktop Anthropic Subscription OAuth logins in the system browser.
-- Delay GitHub setup warnings for one day and add a dashboard connect action.
-- Fix a false AI engine not running banner in desktop mode.
-- Clarify the desktop Connection Manager add-remote flow.
-- Restore Local Server in the desktop Switch server list.
-- Make right-dock task list clicks respect the task popup setting.
-- Auto-retry retryable Code Review remediation failures.
-- Fix no-op task branch recovery after a previously landed task.
-- Allow documented source-free task-artifact deliveries to finish without commits.
-- Fix direct merges so Push to remote after merge honors the configured remote and branch.
-- Keep task popups on the board layer with Activity menus above them.
-- Keep accepted chat requests waiting instead of showing false first-event timeout failures.
-- Show each task's original prompt in the Plan tab alongside the generated plan.
-- Restore terminal Ctrl/Cmd copy and paste shortcuts.
-- Fix mobile Chat composer being hidden behind the keyboard accessory bar.
-- Auto-approve now reliably sends specified plans to the board without a manual approval stop.
-- Fix the in-dashboard Switch server menu not switching desktop local/remote.
-- Fix branch group completion checklists to show accurate landed/finished counts.
-- Branch groups no longer report complete (or become promotable) when an unlanded member is archived.
-- Fix the global GitLab integration setting not persisting when saved.
-- Fix task-detail Activity view dropdown not opening reliably on mobile.
-- Manual "Run now" for the Database Backup automation now runs in-process like the scheduler, matching cron behavior.
-- Task cards no longer show the "Auto-recovery" oversight badge unless oversight is explicitly configured.
-- Remove the per-card overseer-state ("Executor") badge from task cards.
-- Fix agent-created artifacts not appearing live in the dashboard artifacts view.
-- Fix the mobile terminal shortcut bar so it scrolls horizontally to reach every key.
-- Planner-oversight intervention timeline now populates from real engine activity.
-- Show the "Global" prefix on the Authentication entry in the mobile Settings picker.
-- Tasks held for release authorization or Plan Review are now shown distinctly, so auto-approve no longer looks broken.
-- Move mobile terminal controls into a bottom footer so they no longer crowd the header, with a scrollable shortcut bar.
-- Stop the release-authorization gate from holding tasks that merely disclaim releasing.
-- Fix mobile terminal text still rendering with excess inter-character gaps after font-load settle.
-- Stop Plan Review from looping tasks forever and fix its "can't find the plan" reviews.
-- Planner-overseer task badge now shows a readable label and explains what it is waiting on.
-- Plan approve/reject API now blocks release-authorization holds, requiring the authorization marker first.
-- Pin the mobile terminal close (X) button to the top-right corner so it is easy to find and tap.
-- Fix mobile terminal excess character spacing that survived earlier font-remeasure fixes.
-- Manual plan approval no longer re-asks you to approve a plan you already approved when it hasn't changed.
-- Expired Claude subscription logins now show disconnected with a re-login prompt; tokens auto-refresh before expiry.
-- Anthropic subscription reads now refresh the OAuth token automatically instead of silently failing when expired.
-- Stop GitHub tracking-issue creation from linking new tasks to old/closed issues.
-- Clarify the oversight "Nudge unavailable" guideline so it no longer reads as an overseer fault.
-- New tasks created under the Coding (Ideas) workflow now land in the Ideas column and wait for you to promote them.
-- Fix tasks vanishing from the board after being added to a workflow like Coding (Ideas).
-- Move the Before → After transformation summary to the top of generated task definitions.
-- Task-detail Priority dropdown now matches the Oversight dropdown's size, border, and typography.
-- Default workflow boards now label the intake column "Planning" instead of "Triage".
-- Fix the task-detail Nudge control staying disabled when the overseer is actively watching.
-- Honor mission branchStrategy when triage omits branchAssignment; skip validation for inactive missions.
-- Planner overseer no longer marks healthy in-progress tasks as "recovering" or steers them.
+- Fix Anthropic subscription showing "logged in" while all model calls fail.
+- Fix "Invalid transition" error when moving cards out of a custom workflow column like Coding (Ideas) → Ideas.
+- Fix overlapping Record and Clear buttons in the Keyboard Shortcuts settings rows on desktop and mobile.
+- Fix persistent mobile terminal inter-character spacing (5th recurrence root cause).
+- Fix manual PR actions hidden when a task auto-merge override was on but global auto-merge was off.
 
-### Breaking
+## 0.56.0
 
-- Remove the eye icon markdown/plain toggle from chat; messages always render as Markdown.
+### @fusion/dashboard
 
-### Internal
+#### Patch Changes
 
-- Rename downloadable CLI release binaries to the fn-cli-<platform> base name.
+- @fusion/core@0.56.0
+- @fusion/engine@0.56.0
+- @fusion/i18n@0.39.20
+- @fusion-plugin-examples/cli-printing-press@0.1.37
+- @fusion-plugin-examples/compound-engineering@0.1.20
+- @fusion-plugin-examples/dependency-graph@0.1.51
+- @fusion-plugin-examples/roadmap@0.1.39
+- @fusion-plugin-examples/cursor-runtime@0.1.39
+- @fusion-plugin-examples/droid-runtime@0.1.46
+- @fusion-plugin-examples/hermes-runtime@0.2.70
+- @fusion-plugin-examples/openclaw-runtime@0.2.70
+- @fusion-plugin-examples/paperclip-runtime@0.2.70
+
+### @fusion/desktop
+
+#### Patch Changes
+
+- @fusion/core@0.56.0
+- @fusion/dashboard@0.56.0
+- @fusion/engine@0.56.0
+
+### @fusion/engine
+
+#### Patch Changes
+
+- @fusion/core@0.56.0
+- @fusion/pi-claude-cli@0.56.0
+
+### @fusion/plugin-sdk
+
+#### Patch Changes
+
+- @fusion/core@0.56.0
+
+### @runfusion/fusion
+
+#### Minor Changes
+
+- d16c8b4: summary: Expand first-run AI provider quick-start choices beyond Anthropic.
+  category: feature
+  dev: Moves advanced/all-provider onboarding controls under the quick-start provider section.
+- 315f3bc: summary: Show Git prerequisite guidance during first-run GitHub onboarding.
+  category: feature
+  dev: Adds bounded server-host git availability to auth status and onboarding.
+- 50cdab1: summary: Add GitHub OAuth and CLI setup actions to first-run onboarding.
+  category: feature
+  dev: GitHub onboarding now shows in-flow OAuth connect, gh auth login, and gh install guidance.
+- 2f23d22: summary: Add configurable dashboard keyboard shortcuts for Quick Chat and Terminal.
+  category: feature
+  dev: Global dashboardKeyboardShortcuts settings, guarded document-level key handling, and Escape topmost-popup dismissal.
+- efa8105: summary: Add search in Settings so operators can find settings faster.
+  category: feature
+  dev: Dashboard Settings filters visible sections by setting labels and keywords.
+- 7d8a1b8: summary: Add a pinned below-application layout option for the dashboard terminal.
+  category: feature
+  dev: Terminal display mode now supports persisted docked, floating, and below layouts, with header controls replacing the footer shell.
+- 87a700c: summary: Add a Reset Settings button to restore a menu's or all project settings to defaults.
+  category: feature
+  dev: New tested section→keys (scope-aware) registry (packages/dashboard/app/components/settings/section-keys.ts) drives per-menu reset via updateSettings/updateGlobalSettings with null-as-delete; non-blob sections (secrets, MCP, plugins, memory, auth, prompts, CLI agents, runtimes) are excluded with a documented reason.
+- 68f5153: summary: Add a per-workflow planner oversight level setting (Off, Observe, Steer, Autonomous recovery).
+  category: feature
+  dev: New workflow setting `plannerOversightLevel` declared in BUILTIN_OVERSIGHT_SETTINGS; default `autonomous`. Per-task override and engine behavior land in follow-up tasks.
+- aa757bc: summary: Tasks can override the workflow planner oversight level (Off, Observe, Steer, Autonomous recovery).
+  category: feature
+  dev: New nullable Task.plannerOversightLevel field (migration 137, SCHEMA_VERSION 137) mirroring executionMode; NULL inherits the workflow setting. Adds resolveEffectivePlannerOversightLevel precedence helper. Dashboard UI/API threading and engine behavior land in follow-up tasks.
+- 0689250: summary: Planner oversight now defaults to full steering/control for every workflow unless explicitly changed.
+  category: feature
+  dev: Confirms the `plannerOversightLevel` workflow-setting default is the highest (autonomous) level; unset workflow value and unset per-task override both resolve to full steering via `resolveEffectivePlannerOversightLevel` (task override → workflow effective value → autonomous), adding dedicated regression coverage for the "unless explicitly disabled" precedence.
+- 12a6d1b: summary: Planner oversight now monitors tasks across executor, reviewer, merger, pull-request, and workflow-gate stages.
+  category: feature
+  dev: Adds records-only PlannerOverseerMonitor + resolveWatchedStage + OverseerStageObservation in @fusion/engine, gated by resolveEffectivePlannerOversightLevel (off = no observation) and wired into ProjectEngine via a bounded poll. Steering/recovery and UI land in FN-7512/FN-7515+.
+- 81f2053: summary: Planner oversight can autonomously inject guidance, retry stuck/failed steps, and request fixes within bounded limits.
+  category: feature
+  dev: Adds pure `decidePlannerRecovery` + recovery types (core) and `PlannerRecoveryController` with injected guidance/retry/targeted-fix handlers (engine), consuming the FN-7511 observation. Acts only at effective level `autonomous`, caps attempts per (task, stage) via `PLANNER_RECOVERY_MAX_ATTEMPTS`, skips user-paused tasks, and excludes merge/PR/destructive actions (deferred to FN-7513) and comprehensive human-control safeguards (FN-7514).
+- 2cc84b5: summary: Planner oversight now requires confirmation before merge/PR actions and destructive/external side effects.
+  category: feature
+  dev: Adds `PlannerActionSideEffectClass` + `PlannerConfirmationRequest` and `classifyPlannerActionSideEffect`/`requiresPlannerConfirmation` (core), extends `decidePlannerRecovery` with an `await_confirmation` action, and adds `requestConfirmation`/`resolveConfirmation` gating to `PlannerRecoveryController` (engine). Merge/PR and destructive/external actions never execute without a recorded approval; bounded recovery (guidance/retry/targeted-fix) is unchanged. UX rendering, human-control safeguards, timeline, and run-audit land in follow-up tasks.
+- 79ab367: summary: Planner overseer now stays fully hands-off for paused tasks and auto-merge-off / human-review tasks.
+  category: feature
+  dev: Adds the pure `evaluateOverseerHumanControl` policy (packages/engine/src/overseer-human-control-policy.ts), consulted at the top of `PlannerRecoveryController.tick()` before any action classification, confirmation gating, steering, retry, or dispatch — so a user-paused or `autoMerge:false`/human-review task never even records a pending confirmation. Reuses `allowsAutoMergeProcessing` from `@fusion/core` verbatim (never re-derives the auto-merge/human-review predicate). Distinguishes explicit user pause (`task.userPaused===true`, or `task.paused===true` with no `pausedReason`) from engine/self-healing parks (which always stamp a `pausedReason`). Emits a bounded `overseer:oversight-withheld-human-control` run-audit no-action event (metadata: `{ taskId, reason, stage, oversightLevel }`), deduped per (taskId, reason) so it does not spam every poll.
+- c16cc9e: summary: Configure planner oversight level per task and per project in the workflow editor and task create/detail.
+  category: feature
+  dev: Per-task `plannerOversightLevel` override exposed via TaskForm (Inherit/off/observe/steer/autonomous), threaded through createTask/updateTask; workflow-editor Values tab gets a first-class display entry. Workflow-native setting; not a project setting.
+- aae603b: summary: Add a configurable planner-overseer notification verbosity level (Silent/Errors/Important/All).
+  category: feature
+  dev: New workflow-native enum setting `plannerOversightNotificationLevel` in BUILTIN_OVERSIGHT_SETTINGS; default `important`. Resolves via resolveEffectiveSettings; emission gating that reads it lands in FN-7519/FN-7520.
+- d10ea9a: summary: Add a task-detail planner-overseer intervention timeline (stage, reason, action, outcome, attempts, links).
+  category: feature
+  dev: New core `PlannerInterventionEntry` model + `recordPlannerIntervention`/`getPlannerInterventionTimeline` helpers persisting via the run-audit store under the `overseer:intervention` mutation, plus a `PlannerInterventionTimeline` component rendered in the task-detail Planner Oversight cluster. Emission call-sites land in FN-7520.
+- bf68839: summary: Emit planner-overseer run-audit events for observations, steering, retries, recovery, confirmations, and escalations.
+  category: feature
+  dev: New core emitters (emitOverseerObservation/Steering/RecoveryAttempt/Retry/Confirmation/Escalation) in planner-overseer-events.ts, each mapping its decision-point to the correct intervention action/outcome and delegating to FN-7519's recordPlannerIntervention under the overseer:intervention mutation. Producer call-sites land in FN-7511/FN-7512/FN-7513.
+- c4d81fe: summary: Add an AI-undo fallback task when reverting a done task via git conflicts or is unsupported.
+  category: feature
+  dev: `POST /api/tasks/:id/revert` now accepts `{ mode?: "git" | "ai" | "auto" }` (default `"auto"`). `"auto"` tries the FN-7523 git-revert path first and falls back to creating an AI-undo board task (`{ mode: "ai", createdTaskId, alreadyOpen? }`) on a conflicting or unsupported (e.g. workspace) git result; `needsHuman` (autoMerge-off) never triggers the fallback. `"ai"` always creates the AI-undo task; `"git"` keeps the FN-7523 git-only contract, which is otherwise unchanged. New engine exports: `createAiUndoTask`, `buildAiUndoTaskDescription`, `REVERT_OF_METADATA_KEY`. New core store method `TaskStore.findOpenRevertTaskForSource` backs the idempotency guard (an open undo task suppresses a duplicate; a closed one does not).
+- e7cb2f1: summary: Add a Revert action to Done/Archived task cards to undo landed changes.
+  category: feature
+  dev: Wires onRevertTask through Board/List/Detail surfaces; calls POST /tasks/:id/revert in "auto" mode with a conflict-confirm AI-undo fallback (mode: "ai").
+- 5ad8ec8: summary: Capture a structured performance snapshot when an agent task completes.
+  category: feature
+  dev: New AgentReflectionService.captureTaskPerformance persists a non-LLM post-task ReflectionMetrics record (duration, packages/files touched, verification command + scope, retry/rework count) and emits ids/counts-only `reflection:captured` run-audit telemetry; populates performanceSummary/latestReflection.
+- 726cbf8: summary: Task cards can now show the planner overseer's active state (idle/watching/steering/recovering/awaiting-confirmation).
+  category: feature
+  dev: Adds a serializable `PlannerOverseerRuntimeSnapshot` + pure `derivePlannerOverseerState` (core), a read-only `ProjectEngine.getPlannerOverseerRuntimeSnapshot(taskId)` accessor assembling it from the FN-7511 monitor + FN-7512/7513 recovery controller, and a best-effort additive `plannerOverseerState` enrichment on `GET /api/tasks` (mirrors the `branchProgress` pattern; never persisted, never fails the board load). Consumed by FN-7516's TaskCard.
+- 2ed06f9: summary: Support reverting multi-repo workspace tasks via git, all-or-nothing across sub-repos.
+  category: feature
+  dev: Extends `packages/engine/src/task-revert.ts` with `resolveWorkspaceTaskRevertCommits`/`revertWorkspaceTask` and wires `POST /api/tasks/:id/revert` to dispatch workspace tasks (`isWorkspaceTask`) to the new path; returns `{ mode: "git", clean, workspace: { repos: [...] }, conflicts? }`. Single-repo `performTaskRevert` path is unchanged.
+- 8c6f76c: summary: Add per-sha revert commit granularity to the task revert API and service.
+  category: feature
+  dev: `performTaskRevert` and `POST /api/tasks/:id/revert` accept an optional `granularity: "squash" | "per-sha"` (default `"squash"`, unchanged FN-7523 behavior). `"per-sha"` creates one attributed `revert(FN-xxxx)` commit per original sha (each with its own `Fusion-Task-Id` trailer and audit line), skipping no-op shas without empty commits. A mid-batch conflict in either mode rolls back the whole batch to the pre-call HEAD — no partially-landed per-sha commits. The clean result now reports `revertCommitShas: string[]` (all created commits) alongside the existing `revertCommitSha` (kept for backward compatibility).
+- f992e6a: summary: Add a dedicated Keyboard Shortcuts settings section with click-to-record capture and more configurable actions.
+  category: feature
+  dev: Relocates dashboardKeyboardShortcuts into its own settings section, adds a ShortcutCaptureInput recorder, and extends DashboardShortcutAction with openFiles/openSettings/openCommandCenter/newTask actions wired into existing App nav handlers.
+- 2df6c35: summary: Open a revert PR for done/archived tasks when autoMerge is disabled instead of refusing.
+  category: feature
+  dev: `POST /api/tasks/:id/revert` gains an additive `{ mode: "pr", clean: true, prUrl, prNumber, revertBranch, existingPr? }` result for clean single-repo reverts under `autoMerge:false`, reusing `GitHubClient.createPr`, `findPrForBranch` idempotency, and the `manual:true` PR handoff. New engine export `prepareRevertPrBranch` (packages/engine/src/task-revert.ts) prepares the dedicated `fusion/revert-<id>` branch without ever mutating the base branch. Existing `{ mode: "git" | "ai", ... }` shapes and the `autoMerge:true` path are unchanged.
+- 94e9d15: summary: AI-undo tasks now default to a configurable, stricter review workflow.
+  category: feature
+  dev: New project setting `aiUndoTaskWorkflowId` (default `builtin:review-heavy`) selects the workflow for AI-undo board tasks created by `POST /api/tasks/:id/revert` (`mode: "ai"`, the `auto` conflict fallback, and the workspace conflict fallback all share the `createAiUndoResult()` closure, so all three inherit this default). A blank/unset value means the created task inherits the project default workflow (pre-FN-7556 behavior). The route validates the configured id via `getWorkflowDefinition`/`isBuiltinWorkflowId` and falls back to inherit (with a logged warning) on a blank or unknown value, so a misconfigured id never breaks AI-undo task creation. The engine's `createAiUndoTask` helper stays pure — it only forwards a `workflowId` it is given, never resolves the setting itself. The Settings Modal UI field for this setting is a deliberate follow-up task; the value is settable today only via the settings API.
+- 3dd227b: summary: Plan auto-approval is now the default; specified tasks skip manual approval unless you opt into workflow/require-all.
+  category: feature
+  dev: `DEFAULT_PROJECT_SETTINGS.planApprovalMode` flips `workflow` → `auto-approve-all`; existing projects with an explicit stored value are unchanged; consumed by `resolvePlanApprovalRequired` at the triage gating sites.
+- 78d4db9: summary: Fusion self-repo issue-close comments now show current and target release versions.
+  category: feature
+  dev: GitHubIssueCommentService appends "Current version: v{current}" and "Target release: v{next-minor}" lines when the linked source issue is runfusion/fusion; other repos unchanged. Version resolved via getCliPackageVersion.
+- 7435849: summary: Open one revert PR per sub-repo for workspace tasks when autoMerge is disabled.
+  category: feature
+  dev: `POST /api/tasks/:id/revert` gains an additive workspace `{ mode: "pr", clean: true, workspace: { repos: [{ repo, revertBranch, prUrl, prNumber, existingPr? }] } }` result for clean multi-repo reverts under `autoMerge:false`, extending FN-7554's single-repo `mode:"pr"` path. New engine export `prepareWorkspaceRevertPrBranches` (packages/engine/src/task-revert.ts) classifies every sub-repo first and only prepares a dedicated `fusion/revert-<id>` branch per sub-repo when all are clean/already-reverted (all-or-nothing at the branch-prep phase), never force-writing any sub-repo integration branch. The route resolves owner/repo and checks the rate limiter for every sub-repo before pushing/creating any PR, so GitHub-unconfigured/rate-limited cases degrade the whole task to `needsHuman` rather than opening a partial subset of PRs. Existing `{ mode: "git" | "ai" | "pr", ... }` shapes, the `autoMerge:true` workspace path, and FN-7554's single-repo path are unchanged.
+- 73b38ba: summary: Add a Settings → General picker to choose the workflow used for AI-undo (revert) tasks.
+  category: feature
+  dev: Surfaces `aiUndoTaskWorkflowId` (default `builtin:review-heavy`) in GeneralSection; empty selection means "inherit project default workflow", matching the revert route's blank-is-inherit behavior from FN-7556.
+- 42bbe58: summary: Add "Ask user question" and "Exit gate" workflow nodes for mid-flow chat reach-out and early exit.
+  category: feature
+  dev: New IR node kinds `ask-user` (reuses await-input park/resume; surfaces the question in the task chat) and `exit-gate` (terminates the workflow early, optional condition). Editor palette + summaries + help updated; `prompt`+`awaitInput` remains a back-compat alias.
+- 53fe0d7: summary: Add a built-in "Brainstorming" workflow that talks to you before planning.
+  category: feature
+  dev: Registers `builtin:brainstorming` (non-default, default-enabled) composing FN-7579's `ask-user` → refine → `exit-gate`-on-approval phase ahead of the normal coding plan/execute/review/merge spine. Parity suite (`builtin-workflows.test.ts`) extended for the new entry.
+- ecbbb29: summary: Add a "Coding (Ideas)" workflow with a manual Ideas intake and a merged Todo planner column.
+  category: feature
+  dev: New `builtin:coding-ideas` clones the default stepwise pipeline with an `ideas` intake (autoTriage:false) in front of a merged `todo` planner+capacity column. createTask lands cards in the workflow's intake column; the triage service plans unplanned todo tasks in place; the scheduler skips bootstrap-prompt todo tasks; TaskCard gains a Start button and a Ready badge.
+
+#### Patch Changes
+
+- 8668a05: summary: Add a workflow setting to disable automatic large-task triage splitting.
+  category: feature
+  dev: Adds triageProactiveSubtaskSplittingEnabled while preserving explicit breakIntoSubtasks requests.
+- 978cdda: summary: Show active Plan Review progress on triage task cards.
+  category: fix
+  dev: TaskCard now renders the existing progress affordance for Triage only when unified progress has active workflow work.
+- 635fca2: summary: Remove the eye icon markdown/plain toggle from chat; messages always render as Markdown.
+  category: breaking
+  dev: Removed ChatView `chat-thread-header-render-toggle` (desktop + mobile), `showAllAsPlain` state, and `chat.showRenderedMarkdown`/`chat.showPlainText` i18n keys (FN-7541).
+- 3d55102: summary: Clarify task-detail oversight Nudge/Explain controls: visible label, disabled reason, always-openable Explain panel.
+  category: fix
+  dev: TaskDetailModal now renders a `detail-oversight-controls-label` group label and `detail-overseer-nudge-disabled-reason` helper text (both gated by the existing oversight-cluster visibility condition); Explain no longer disables on `!canExplainOverseer` since it is read-only. Nudge's `canNudgeOverseer` gate and Stop's confirm dialog are unchanged.
+- 0f1cd0a: summary: Unify border, radius, and height of the task-detail Priority/Execution/Oversight controls.
+  category: fix
+  dev: Adds a shared --detail-control-border-radius token alongside --detail-priority-control-min-height so .detail-priority-chip, .detail-execution-mode-toggle, .detail-oversight-chip, and .detail-oversight-menu-trigger all resolve the same border-width/color/radius/height.
+- b42ba9f: summary: Keep the task-detail Activity view menu open during mobile iOS taps.
+  category: fix
+  dev: Guards the Activity views dropdown against iOS visualViewport resize/scroll echoes during menu opening.
+- a7559b0: summary: Fix Anthropic subscription login when pasted callback URLs contain fragment OAuth parameters.
+  category: fix
+  dev: Normalizes pasted OAuth callback fragments before resolving dashboard manual-code login prompts.
+- 4b530a6: summary: Fix Claude/Anthropic subscription re-login showing "Login did not complete" after logging out.
+  category: fix
+  dev: Anthropic subscription OAuth is aliased across the legacy `anthropic` row (where interactive login persists the credential) and the `anthropic-subscription` id (where the settings card's in-memory logged-out suppression and status read are keyed). Re-login wrote only `anthropic`, so `loggedOutProviders` kept suppressing `anthropic-subscription` and the card reported failure despite a valid stored credential until process restart. auth-storage's proxy now clears the logged-out state on both aliases when either is re-authenticated (new `login` trap + hardened `set` trap via `clearReauthenticatedLogoutState`; raw api_key writes stay scoped to their own card). Also surfaces background OAuth login failures on `GET /auth/status` (`loginError`) + server logs so future paste-callback failures are diagnosable instead of a generic error.
+- a5ac3c3: summary: Stop self-healing from killing actively-running tasks after ~30 minutes.
+  category: fix
+  dev: FN-7566. isPhantomExecutorBinding's liveness gate (heartbeat/checkout/runAudit) was blind to ephemeral executor agents, leaving only the age>graceMs\*3 threshold, so any ephemeral-executor task running longer than ~30 min was reclaimed to `todo` mid-flight. Adds the in-process live-session veto (activeSessionRegistry path / executingTaskLock / isTaskActive), mirroring the isWorkspaceTaskLive/sessionDead predicate, and honors clearPhantomExecutorBinding's live-session refusal in reclaimSelfOwnedBranchConflicts.
+- 8912399: summary: Stop Windows Terminal version dialogs from popping up when opening the dashboard or Settings on Windows.
+  category: fix
+  dev: Root cause was the worktrunk integration, not the embedded terminal: worktrunk's CLI is named `wt`, which collides with Windows Terminal (`wt.exe`) on PATH, so probing it with `wt --version` launched Windows Terminal. Fixed by (1) `useWorktrunkInstallStatus` only auto-fetching `/api/worktrunk/status` when the integration is enabled (user opt-in) instead of on every Settings/dashboard mount, and (2) an engine-level guard in `probeWorktrunk` that refuses to exec a resolved `wt` that is the Windows Terminal alias (under `WindowsApps` / a `WindowsTerminal` package dir), covering all resolution surfaces.
+- b800f7d: summary: Select newly created folders automatically during project setup.
+  category: fix
+  dev: Adds DirectoryPicker opt-in selection for project-registration surfaces while preserving default picker behavior.
+- 9dc248e: summary: Prevent Desktop update banners from using 0.0.0 as the current version.
+  category: fix
+  dev: Dashboard update checks now resolve packaged @fusion/desktop metadata and fail closed for unresolved versions.
+- 52dbc0e: summary: Quit Fusion Desktop on Windows when the window is closed.
+  category: fix
+  dev: Updates Electron close lifecycle so Windows shutdown reaches embedded runtime cleanup.
+- ced783e: summary: Open desktop Anthropic Subscription OAuth logins in the system browser.
+  category: fix
+  dev: Adds Electron window-open policy coverage and preserves Settings auth polling completion paths.
+- 50786f2: summary: Delay GitHub setup warnings for one day and add a dashboard connect action.
+  category: fix
+  dev: Dashboard setup warnings now gate GitHub prompts per project and route the CTA to Settings → Authentication.
+- b4b1f6d: summary: Fix a false AI engine not running banner in desktop mode.
+  category: fix
+  dev: Distinguishes transient embedded desktop engine startup from true dashboard-only mode.
+- e8b7362: summary: Clarify the desktop Connection Manager add-remote flow.
+  category: fix
+  dev: Desktop Connection Manager now separates Local Server context from saved remote profiles and collapses the remote editor until add/edit.
+- 0900a38: summary: Restore Local Server in the desktop Switch server list.
+  category: fix
+  dev: Desktop Connection Manager now lists local and saved remote destinations together.
+- a2b09f2: summary: Make right-dock task list clicks respect the task popup setting.
+  category: fix
+  dev: Threads openMobileTasksInPopup through the right-dock Tasks list route while preserving embedded dock detail when disabled.
+- 0f05156: summary: Auto-retry retryable Code Review remediation failures.
+  category: fix
+  dev: Prevents retryable code-review-remediation graph failures from stranding tasks in in-review.
+- 20184ac: summary: Fix no-op task branch recovery after a previously landed task.
+  category: fix
+  dev: Merge/recovery ownership classification now checks no-diff branches before foreign trailer rejection.
+- 82493e0: summary: Allow documented source-free task-artifact deliveries to finish without commits.
+  category: fix
+  dev: fn_task_done now recognizes explicit gitignored .fusion/tasks artifact contracts while preserving source-change no-commit guards.
+- 5689346: summary: Fix direct merges so Push to remote after merge honors the configured remote and branch.
+  category: fix
+  dev: Resolves remote-only push targets from the merge integration branch and preserves non-fatal push errors on done tasks.
+- b42be87: summary: Keep task popups on the board layer with Activity menus above them.
+  category: fix
+  dev: Task-detail FloatingWindow callers use a lower layer band, and Activity view menus reposition after popup geometry changes.
+- 61c8bdc: summary: Keep accepted chat requests waiting instead of showing false first-event timeout failures.
+  category: fix
+  dev: Dashboard chat POST streams no longer abort accepted-but-silent responses on the client first-event timer.
+- e8dc2ae: summary: Show each task's original prompt in the Plan tab alongside the generated plan.
+  category: fix
+  dev: Adds a read-only Task Detail original-prompt section backed by task.description.
+- d2e3134: summary: Add before-to-after transformation summaries to generated task definitions.
+  category: feature
+  dev: Built-in standard and fast triage prompts now require a `## Before → After Transformation` section.
+- b0208c1: summary: Restore terminal Ctrl/Cmd copy and paste shortcuts.
+  category: fix
+  dev: Integrated and embedded terminals now own physical clipboard paste to avoid swallowed or duplicate input.
+- 2797803: summary: Show first-token and tool processing durations in task agent logs.
+  category: feature
+  dev: Adds optional agent-log timing fields `timeToFirstTokenMs` and `durationMs`.
+- a2d6349: summary: Fix mobile Chat composer being hidden behind the keyboard accessory bar.
+  category: fix
+  dev: Adds keyboard-open bottom clearance in ChatView so the composer clears the iOS input-assistant/autofill bar without a persistent .chat-thread transform or Android reserved-gap.
+- 4baa4c4: summary: Settings descriptions now show each setting's default value.
+  category: feature
+  dev: Appended default-value copy to settings.\* i18n descriptions across Global, Runtimes, and Project Settings sections, sourced from DEFAULT_GLOBAL_SETTINGS/DEFAULT_PROJECT_SETTINGS in settings-schema.ts; added settings-default-descriptions.test.tsx guarding that every surfaced setting states a default (or explicit "inherits"/"no default \u2014 unset") and that every DEFAULT_SETTINGS key is documented or allowlisted as not surfaced.
+- 53d7b7e: summary: Add an intelligent git-revert engine service and POST /api/tasks/:id/revert route.
+  category: feature
+  dev: New `packages/engine/src/task-revert.ts` exports `resolveTaskRevertCommits`, `classifyTaskRevert`, and `performTaskRevert` (squash/rebase/lineage attribution precedence, dry-run classification, guaranteed-clean rollback). Route enforces done/archived-only and autoMerge-off guard rails; conflicting results are returned unresolved for sibling FN-7524 (AI-undo) to act on. Workspace tasks return `unsupported`.
+- 4707eb5: summary: Auto-approve now reliably sends specified plans to the board without a manual approval stop.
+  category: fix
+  dev: FN-7526 — investigated the reported "plans still park at awaiting-approval when auto-approve is on" symptom; resolvePlanApprovalRequired, mergeEffectiveSettings/applyWorkflowSettingsOverlay, and every finalizeApprovedTask call site (specifyTask, recoverApprovedTask, retryUnavailablePlanReview, tryFinalizeExplicitDuplicateMarker) already honored project planApprovalMode: "auto-approve-all" over a stored workflow requirePlanApproval value — no production defect reproduced. Added end-to-end regression coverage across every enumerated surface (Plan Review reviewer-outage retry, refinement routing, self-healing starved-refinement recovery) using the real mergeEffectiveSettings pipeline instead of isolated bare-settings unit calls, plus explicit assertions that the independent release-authorization and Workflow Plan Review gates remain intact under auto-approve-all, so a future bare-settings call site is caught immediately instead of silently reintroducing the reported behavior.
+- 3b52a4d: summary: Fix the in-dashboard Switch server menu not switching desktop local/remote.
+  category: fix
+  dev: The desktop shell's redirect effects in App.tsx read a dead `localServer` field that the preload never populates; extracted `resolveDesktopShellRedirectTarget` in appLifecycle.ts now derives the navigation target from the live `localRuntime`/`activeProfileId` state for both directions, and the unused `localServer` field was removed from `ShellConnectionState`.
+- 36bd74e: summary: Fix branch group completion checklists to show accurate landed/finished counts.
+  category: fix
+  dev: runAiMerge (the sole merge path since master-plan U0) never resolved branch-group routing or stamped mergeDetails.mergeTargetBranch/mergeTargetSource, so isBranchGroupMemberLanded permanently reported shared-group members as not landed. Routes through resolveBranchGroupMergeRouting (matching the legacy merger.ts pattern) and stamps the target fields on both the landed and no-op finalize paths; preserves merge-target-safety in isBranchGroupMemberLanded (a sibling/mismatched-branch member still never counts as landed).
+- df0be88: summary: Branch groups no longer report complete (or become promotable) when an unlanded member is archived.
+  category: fix
+  dev: listTasksByBranchGroup membership now scans with includeArchived:true so an archived-but-unlanded member stays counted in total instead of silently dropping out; mergeDetails is now persisted on ArchivedTaskEntry so an archived member that had already landed keeps counting as landed. evaluateBranchGroupCompletion / promoteBranchGroup gate correctly; merge-target-safety in isBranchGroupMemberLanded is unchanged.
+- ec9ac61: summary: Fix the global GitLab integration setting not persisting when saved.
+  category: fix
+  dev: splitSettingsSave now diffs the five global GitLab keys (gitlabEnabled, gitlabInstanceUrl, gitlabApiBaseUrl, gitlabAuthToken, gitlabAuthTokenType) against scoped global initials only, never the project-effective merged initialValues, so a project override no longer suppresses a real global save.
+- 8d36b99: summary: Fix task-detail Activity view dropdown not opening reliably on mobile.
+  category: fix
+  dev: Guards the Activity menu's window resize/orientationchange/scroll close-listener with the same opening-tap timing guard already used for visualViewport, and exempts scroll events originating in the `.detail-tabs` scroller, so a same-gesture mobile tap echo (Android/iOS, fixed modal or `.floating-window--task-detail` popup) no longer closes the menu the instant it opens.
+- ad744aa: summary: Manual "Run now" for the Database Backup automation now runs in-process like the scheduler, matching cron behavior.
+  category: fix
+  dev: The legacy single-command and command-step manual automation run path (`executeSingleCommand` in packages/dashboard/src/routes.ts) now intercepts `isInProcessBackupCommand`/`isInProcessMemoryBackupCommand` via the scoped TaskStore, mirroring `RoutineRunner.executeCommand`/`CronRunner`, instead of always shelling out via `exec()`. `formatInProcessBackupError`, `isInProcessBackupCommand`, and `isInProcessMemoryBackupCommand` are now exported from `@fusion/engine` for reuse. Existing onStep/onText live-run callbacks already stream incremental output for command/backup runs; added regression coverage confirming this holds for the new interception branch.
+- 5c3d58a: summary: Task cards no longer show the "Auto-recovery" oversight badge unless oversight is explicitly configured.
+  category: fix
+  dev: `TaskCard.tsx`'s `showOversightBadge` gate now also suppresses the badge when the effective level equals `DEFAULT_PLANNER_OVERSIGHT_LEVEL` ("autonomous") and there is no explicit per-task `plannerOversightLevel` override; an explicit per-task override of "autonomous" still renders the badge.
+- b4be515: summary: Remove the per-card overseer-state ("Executor") badge from task cards.
+  category: fix
+  dev: Deleted the FN-7516 `card-overseer-state-badge` render, its card-local `deriveOverseerCardWatchedStage` helper/label maps, and its CSS; the sibling oversight-level badge (`card-oversight-badge`) is unaffected.
+- 62ddb19: summary: Original task prompt now renders as Markdown and is collapsed by default in the task Plan tab.
+  category: feature
+  dev: Task Detail Plan/Definition tab original-prompt section reuses the existing `.detail-source-toggle`/`.detail-source-chevron--expanded` collapse pattern and the shared `ReactMarkdown` pipeline (`remarkGfm`, `sharedRehypePlugins`, `markdownLinkifyComponents`); backed by read-only `task.description`, no change to the generated `PROMPT.md` editor/revision flow.
+- 883c73e: summary: Fix agent-created artifacts not appearing live in the dashboard artifacts view.
+  category: fix
+  dev: Root cause was cross-instance artifact-registration replication, not the route/hook/render path (all already correct). `TaskStore.registerArtifact()` never bumped `lastModified`, and `checkForChanges()` (the polling replicator that lets a second TaskStore instance on the same project — e.g. the dashboard's cached store vs. the engine's own store — mirror events it did not write itself) only ever diffed the `tasks` table, never `artifacts`. A store instance that did not perform the write could therefore never observe or re-emit `artifact:registered`, leaving an already-open Documents/task Artifacts gallery stale until a full reload. Fixed by bumping `lastModified` on artifact writes and adding a strictly-increasing `rowid`-cursor poll over the `artifacts` table in `checkForChanges()`. See `packages/core/src/__tests__/artifacts.test.ts` and `packages/dashboard/src/routes/__tests__/artifacts-route-integration.test.ts` for regression coverage.
+- d09b57f: summary: Fix the mobile terminal shortcut bar so it scrolls horizontally to reach every key.
+  category: fix
+  dev: Added `min-width: 0` to `.terminal-shortcut-panel` to defeat the flex min-width:auto trap that clipped overflow instead of engaging `overflow-x: auto`.
+- 3d58260: summary: Planner-oversight intervention timeline now populates from real engine activity.
+  category: fix
+  dev: Wires PlannerOverseerMonitor/PlannerRecoveryController decision points to the FN-7520 emitOverseer\* façade with the real TaskStore; observation/escalation emission deduped per (task, stage[, signal]).
+- 052a277: summary: Show the "Global" prefix on the Authentication entry in the mobile Settings picker.
+  category: fix
+  dev: resolveSettingsSectionOptionLabel now derives the Global-group prefix for storage-less (scope: undefined) sections in SettingsModal.tsx (FN-7552).
+- 6e4c207: summary: Tasks held for release authorization or Plan Review are now shown distinctly, so auto-approve no longer looks broken.
+  category: fix
+  dev: FN-7559 — auto-approve-all bypasses only the manual plan-approval gate (unchanged, FN-7526). Release-authorization holds are surfaced with a new distinct status reason (`Task.awaitingApprovalReason: "release-authorization"`) and no longer render the generic manual Approve/Reject affordance in TaskCard/TaskDetailModal; Workflow Plan Review already used distinct statuses (`needs-replan`/`plan-review-unavailable`) and is unaffected. Both gates remain independent and intact — this is UI/data disambiguation only.
+- 6d364fc: summary: Move mobile terminal controls into a bottom footer so they no longer crowd the header, with a scrollable shortcut bar.
+  category: fix
+  dev: On the ≤768px terminal, the `.terminal-actions` cluster now renders in a `terminal-footer-actions` bar (with `min-width:0; overflow-x:auto`) instead of the header; desktop/floating/pinned-below keep the FN-7502 header layout. Preserves the FN-7550 shortcut-panel scroll fix.
+- b471aec: summary: Stop the release-authorization gate from holding tasks that merely disclaim releasing.
+  category: fix
+  dev: classifyReleaseTask now strips negated release-disclaimer clauses (e.g. "this task performs no release/publish; releases are owned by scripts/release.mjs") before signal matching in packages/engine/src/triage-release-authorization.ts, so revert/undo/UI specs are no longer false-flagged as release-class. Genuine "run pnpm release"/"publish @runfusion/fusion" intent still trips the gate.
+- 9d4a45b: summary: Fix mobile terminal text still rendering with excess inter-character gaps after font-load settle.
+  category: fix
+  dev: Root cause: xterm's OptionsService setter is a no-op when reassigning an already-current fontFamily/fontSize, so post-settle reapply never forced CharSizeService/DomRenderer to remeasure. Added `forceTerminalFontRemeasure()` in `terminalPreferences.ts`, used by both `TerminalModal.tsx` and `SessionTerminal.tsx` at every post-`waitForTerminalFontMetrics()` settle site.
+- 72b77bf: summary: Stop Plan Review from looping tasks forever and fix its "can't find the plan" reviews.
+  category: fix
+  dev: FN-7561 — Plan Review pre-merge gate hardening in packages/engine/src/executor.ts. (1) The reviewer ran readonly with cwd=worktree but the spec lives at project-root .fusion/tasks/<id>/PROMPT.md, so "Read PROMPT.md" produced "no PROMPT.md found / data is in a DB" non-verdicts; the spec text is now injected into the reviewer prompt via readTaskArtifact. (2) A malformed reviewer response now self-retries once on the primary model when no fallback is configured. (3) A malformed (advisory_failure, no verdict) plan-review result can never trigger a triage replan. (4) The unbounded plan-review replan default is capped at 15 attempts with a loud halting log entry, so a persistently-disagreeing planner/reviewer no longer burns LLM calls indefinitely (FN-7525 ran 13+ attempts overnight).
+- c08498e: summary: Planner-overseer task badge now shows a readable label and explains what it is waiting on.
+  category: fix
+  dev: TaskCard badge renders plannerOverseerStateLabel + plannerOverseerBadgeTooltip built from the existing PlannerOverseerRuntimeSnapshot (reason/watchedStage/signal/pendingConfirmation); presentation-only, no engine changes.
+- 24b27e8: summary: Plan approve/reject API now blocks release-authorization holds, requiring the authorization marker first.
+  category: fix
+  dev: FN-7564 — POST /tasks/:id/approve-plan and /reject-plan now return 400 when task.awaitingApprovalReason === "release-authorization" (FN-7559 discriminator), enforcing the FN-6481 release-authorization gate at the API layer regardless of client. Manual-approval holds are unaffected.
+- fb45157: summary: Pin the mobile terminal close (X) button to the top-right corner so it is easy to find and tap.
+  category: fix
+  dev: On the ≤768px terminal, the `terminal-close` button now carries a `terminal-close--corner` class (order:3 + margin-inline-start:auto) so it renders last in flex order and hugs the right edge next to the tab dropdown, instead of falling back to order:0 (far left). Desktop/floating/pinned-below placement inside `.terminal-actions` is unchanged.
+- 7c0be53: summary: Fix mobile terminal excess character spacing that survived earlier font-remeasure fixes.
+  category: fix
+  dev: `TerminalModal`/`SessionTerminal` re-bake xterm's `DomRenderer` letter-spacing compensation AFTER `fitAddon.fit()` settles the post-fit column count (not just before it), since `handleResize()` never re-bakes spacing itself. See `docs/solutions/ui-bugs/xterm-options-noop-remeasure-after-font-settle.md` recurrence #4.
+- 71dfd3a: summary: Rename downloadable CLI release binaries to the fn-cli-<platform> base name.
+  category: internal
+  dev: `binaryNameForTarget` in `packages/cli/build.ts` and the `release.yml` / `test-release.yml` matrices now emit `fn-cli-<suffix>`; the local dev binary stays `fn`/`fn.exe`.
+- 9592e3a: summary: Manual plan approval no longer re-asks you to approve a plan you already approved when it hasn't changed.
+  category: fix
+  dev: FN-7569 — approving a plan records a fingerprint of the approved PROMPT.md (new nullable Task.approvedPlanFingerprint, migration 139). The manual plan-approval gate skips re-parking at awaiting-approval when a re-specification (replan, plan-review retry, self-healing rebound) produces the same plan; a changed plan or reject-plan still requires fresh approval. Release authorization, Workflow Plan Review, and auto-approve-all are unchanged.
+- c31f9ef: summary: Move the planner intervention timeline into the task Activity view dropdown.
+  category: feature
+  dev: Removes the inline `PlannerInterventionTimeline` mount from the FN-7517 oversight cluster in `TaskDetailModal.tsx` and adds a fourth `interventions` `ActivitySegment`, shown in the Activity dropdown only when planner oversight is active for the task; falls back to Live if oversight turns off while Interventions is selected.
+- ce9df29: summary: Expired Claude subscription logins now show disconnected with a re-login prompt; tokens auto-refresh before expiry.
+  category: fix
+  dev: Unifies OAuth expiry detection between OAuthExpiryMonitor and /api/auth/status, and adds an engine-side proactive OAuth refresh scheduler wired in project-engine (guarded by skipNotifier). No token material logged.
+- 196abb5: summary: Anthropic subscription reads now refresh the OAuth token automatically instead of silently failing when expired.
+  category: fix
+  dev: mergeAuthStorageReads getApiKey("anthropic-subscription") now delegates to the underlying engine authStorage.getApiKey (the only refresh-token HTTP round trip) instead of a local static expiry check; regression tests drive the wrapper directly. No token material logged.
+- 45e5a26: summary: Stop GitHub tracking-issue creation from linking new tasks to old/closed issues.
+  category: fix
+  dev: github-tracking dedup now only reuses OPEN issues and requires a File-Scope path overlap (keyword-only matches no longer link). Prevents mis-linking a fresh task to a stale/resolved tracking issue (FN-7579). Setting `githubTrackingDedupEnabled` unchanged.
+- a1a6b09: summary: Clarify the oversight "Nudge unavailable" guideline so it no longer reads as an overseer fault.
+  category: fix
+  dev: TaskDetailModal oversight controls — reworded taskDetail.oversight.nudgeDisabledTitle and added taskDetail.oversight.nudgeSuppressedTitle to differentiate periodic-observation vs. manual-control states. No enablement/engine logic changed.
+- cf3fe8b: summary: New tasks created under the Coding (Ideas) workflow now land in the Ideas column and wait for you to promote them.
+  category: fix
+  dev: Dashboard create surfaces (InlineCreateCard, QuickEntryBox, NewTaskModal, insight/todo → task) no longer hard-code column:"triage"; the store now resolves the selected/default workflow's intake column. InlineCreateCard forwards workflowId at create time instead of applying it post-create. Also fixed a glue-layer regression in `useTaskHandlers.ts` (`handleBoardQuickCreate`/`handleModalCreate`) that re-forced column:"triage" even after the UI surfaces stopped sending it.
+- 8b4e522: summary: Fix tasks vanishing from the board after being added to a workflow like Coding (Ideas).
+  category: fix
+  dev: Board.tsx forces a board-workflows refetch (deferred one tick, signature-guarded) whenever a rendered task is missing from the taskWorkflowIds map, so its real workflow and intake column resolve regardless of which create surface added it; the single-workflow grouping also re-homes a task whose column its workflow no longer declares into the intake lane instead of dropping it. Fixes the FN-7591 regression where intake-column cards (column "ideas") fell back to the default workflow, which has no such column, and were filtered out until a manual reload.
+- f30d55f: summary: Move the Before → After transformation summary to the top of generated task definitions.
+  category: fix
+  dev: Reorders the standard and fast triage `PROMPT.md` templates in packages/core/src/agent-prompts.ts so `## Before → After Transformation` is the first content section, ahead of `## Review Level` and `## Mission`, matching FN-7499's glance-verification intent.
+- 20379e8: summary: Task-detail Priority dropdown now matches the Oversight dropdown's size, border, and typography.
+  category: fix
+  dev: Removed the Priority-only forced select/option uppercase, added a neutral chip background scoped to `.detail-priority-chip.card-priority-badge--normal` for the untinted `normal` level, and reused the FN-7585 shared `--btn-border-width`/`--border`/`--detail-control-border-radius`/`--detail-priority-control-min-height` tokens so both dropdowns render as one control style across desktop and the mobile oversight-overflow surface.
+- e0f3d3d: summary: Default workflow boards now label the intake column "Planning" instead of "Triage".
+  category: fix
+  dev: Renamed the `name` of the `id: "triage"` intake column to "Planning" in builtin-coding, builtin-stepwise-coding, and builtin-pr workflow IRs (column id unchanged; linear built-ins inherit via canonicalBuiltinWorkflowColumns). COLUMN_LABELS.triage was already "Planning".
+- 5b193d2: summary: Fix the task-detail Nudge control staying disabled when the overseer is actively watching.
+  category: fix
+  dev: GET /api/tasks/:id now attaches the transient plannerOverseerState snapshot (mirrors the list route); TaskDetailModal reads the snapshot from workingTask so detail refetches no longer drop it.
+- 546ef16: summary: Honor mission branchStrategy when triage omits branchAssignment; skip validation for inactive missions.
+  category: fix
+  dev: resolveBranchAssignmentContext returns undefined for absent mode so triage falls back to mission.branchStrategy; processTaskOutcome gates on mission.status === "active" like recoverActiveMissions.
+- b173f76: summary: Planner overseer no longer marks healthy in-progress tasks as "recovering" or steers them.
+  category: fix
+  dev: `decidePlannerRecovery` now returns `none` for healthy (`progressing`/`complete`) and `awaiting-human` executor/workflow-gate signals instead of falling through to `inject_guidance`; only `stuck`/`blocked`/`failed` trigger autonomous steering. Also dedupes the `PlannerOverseerMonitor` activity-feed heartbeat so an unchanged `(stage, signal, reason)` observation is logged once per change, not every poll tick. Fixes the "overseer recovering" badge appearing on every autonomous card and the needless AI-consuming guidance injections (FN-7577).
+
+### runfusion.ai
+
+#### Patch Changes
+
+- Updated dependencies [8668a05]
+- Updated dependencies [978cdda]
+- Updated dependencies [635fca2]
+- Updated dependencies [3d55102]
+- Updated dependencies [0f1cd0a]
+- Updated dependencies [b42ba9f]
+- Updated dependencies [a7559b0]
+- Updated dependencies [4b530a6]
+- Updated dependencies [a5ac3c3]
+- Updated dependencies [8912399]
+- Updated dependencies [d16c8b4]
+- Updated dependencies [b800f7d]
+- Updated dependencies [315f3bc]
+- Updated dependencies [9dc248e]
+- Updated dependencies [52dbc0e]
+- Updated dependencies [ced783e]
+- Updated dependencies [50cdab1]
+- Updated dependencies [50786f2]
+- Updated dependencies [b4b1f6d]
+- Updated dependencies [e8b7362]
+- Updated dependencies [0900a38]
+- Updated dependencies [a2b09f2]
+- Updated dependencies [0f05156]
+- Updated dependencies [20184ac]
+- Updated dependencies [82493e0]
+- Updated dependencies [5689346]
+- Updated dependencies [b42be87]
+- Updated dependencies [2f23d22]
+- Updated dependencies [efa8105]
+- Updated dependencies [61c8bdc]
+- Updated dependencies [e8dc2ae]
+- Updated dependencies [d2e3134]
+- Updated dependencies [b0208c1]
+- Updated dependencies [7d8a1b8]
+- Updated dependencies [2797803]
+- Updated dependencies [a2d6349]
+- Updated dependencies [4baa4c4]
+- Updated dependencies [87a700c]
+- Updated dependencies [68f5153]
+- Updated dependencies [aa757bc]
+- Updated dependencies [0689250]
+- Updated dependencies [12a6d1b]
+- Updated dependencies [81f2053]
+- Updated dependencies [2cc84b5]
+- Updated dependencies [79ab367]
+- Updated dependencies [c16cc9e]
+- Updated dependencies [aae603b]
+- Updated dependencies [d10ea9a]
+- Updated dependencies [bf68839]
+- Updated dependencies [53d7b7e]
+- Updated dependencies [c4d81fe]
+- Updated dependencies [e7cb2f1]
+- Updated dependencies [4707eb5]
+- Updated dependencies [3b52a4d]
+- Updated dependencies [5ad8ec8]
+- Updated dependencies [726cbf8]
+- Updated dependencies [36bd74e]
+- Updated dependencies [df0be88]
+- Updated dependencies [ec9ac61]
+- Updated dependencies [8d36b99]
+- Updated dependencies [ad744aa]
+- Updated dependencies [5c3d58a]
+- Updated dependencies [b4be515]
+- Updated dependencies [62ddb19]
+- Updated dependencies [883c73e]
+- Updated dependencies [2ed06f9]
+- Updated dependencies [8c6f76c]
+- Updated dependencies [d09b57f]
+- Updated dependencies [3d58260]
+- Updated dependencies [052a277]
+- Updated dependencies [f992e6a]
+- Updated dependencies [2df6c35]
+- Updated dependencies [94e9d15]
+- Updated dependencies [3dd227b]
+- Updated dependencies [6e4c207]
+- Updated dependencies [6d364fc]
+- Updated dependencies [b471aec]
+- Updated dependencies [9d4a45b]
+- Updated dependencies [72b77bf]
+- Updated dependencies [c08498e]
+- Updated dependencies [24b27e8]
+- Updated dependencies [fb45157]
+- Updated dependencies [7c0be53]
+- Updated dependencies [71dfd3a]
+- Updated dependencies [9592e3a]
+- Updated dependencies [c31f9ef]
+- Updated dependencies [ce9df29]
+- Updated dependencies [78d4db9]
+- Updated dependencies [196abb5]
+- Updated dependencies [7435849]
+- Updated dependencies [73b38ba]
+- Updated dependencies [42bbe58]
+- Updated dependencies [45e5a26]
+- Updated dependencies [a1a6b09]
+- Updated dependencies [53fe0d7]
+- Updated dependencies [cf3fe8b]
+- Updated dependencies [8b4e522]
+- Updated dependencies [f30d55f]
+- Updated dependencies [20379e8]
+- Updated dependencies [e0f3d3d]
+- Updated dependencies [5b193d2]
+- Updated dependencies [ecbbb29]
+- Updated dependencies [546ef16]
+- Updated dependencies [b173f76]
+  - @runfusion/fusion@0.56.0
 
 ## 0.55.0
 
@@ -12427,6 +12789,14 @@ for reference.
 - Updated dependencies [a2ed6d0]
   - @runfusion/fusion@0.1.0
 
+## 0.39.21
+
+### @fusion/i18n
+
+#### Patch Changes
+
+- @fusion/core@0.56.1
+
 ## 0.39.20
 
 ### @fusion/i18n
@@ -12589,6 +12959,14 @@ for reference.
 
 - @fusion/core@0.40.0
 
+## 0.11.47
+
+### @fusion/droid-cli
+
+#### Patch Changes
+
+- @fusion-plugin-examples/droid-runtime@0.1.47
+
 ## 0.11.46
 
 ### @fusion/droid-cli
diff --git a/package.json b/package.json
index dd01cdf9c9..6873ec1ab3 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "fusion-workspace",
-  "version": "0.56.0",
+  "version": "0.56.1",
   "private": true,
   "license": "MIT",
   "homepage": "https://github.com/Runfusion/Fusion#readme",
diff --git a/packages/cli-alias/CHANGELOG.md b/packages/cli-alias/CHANGELOG.md
index cbcb5126d8..6d000e9c3c 100644
--- a/packages/cli-alias/CHANGELOG.md
+++ b/packages/cli-alias/CHANGELOG.md
@@ -1,5 +1,16 @@
 # runfusion.ai
 
+## 0.56.1
+
+### Patch Changes
+
+- Updated dependencies [ed823c7]
+- Updated dependencies [dc44730]
+- Updated dependencies [b9d60b3]
+- Updated dependencies [e347062]
+- Updated dependencies [f4f1656]
+  - @runfusion/fusion@0.56.1
+
 ## 0.56.0
 
 ### Patch Changes
diff --git a/packages/cli-alias/package.json b/packages/cli-alias/package.json
index 214ec777c8..f9e5024570 100644
--- a/packages/cli-alias/package.json
+++ b/packages/cli-alias/package.json
@@ -1,6 +1,6 @@
 {
   "name": "runfusion.ai",
-  "version": "0.56.0",
+  "version": "0.56.1",
   "license": "MIT",
   "description": "Launch Fusion with `npx runfusion.ai` — tiny alias for @runfusion/fusion.",
   "homepage": "https://runfusion.ai",
diff --git a/packages/cli/CHANGELOG.md b/packages/cli/CHANGELOG.md
index 7f2d684887..94f2909e77 100644
--- a/packages/cli/CHANGELOG.md
+++ b/packages/cli/CHANGELOG.md
@@ -1,5 +1,25 @@
 # @runfusion/fusion
 
+## 0.56.1
+
+### Patch Changes
+
+- ed823c7: summary: Fix Anthropic subscription showing "logged in" while all model calls fail.
+  category: fix
+  dev: Two-part fix. (1) OAuth token refresh in `packages/engine/src/auth-storage.ts` sent a `scope` param (defaulting to `user:profile`), which per RFC 6749 §6 re-issued the access token narrowed to that scope and stripped `user:inference` — so refreshed tokens 403'd on every model call. Refresh now omits `scope` (preserving the originally-granted scopes, matching pi-ai's own refresh), and `ANTHROPIC_DEFAULT_SCOPES` mirrors the full Claude Code scope set. (2) `/auth/status` now reports an unexpired Anthropic OAuth token that lacks an inference scope as not-connected (authenticated:false, expired:true so the re-login banner fires) with a scope-specific loginError, instead of falsely claiming a live session. Existing narrowed tokens need one re-login to obtain a fresh broad grant.
+- dc44730: summary: Fix "Invalid transition" error when moving cards out of a custom workflow column like Coding (Ideas) → Ideas.
+  category: fix
+  dev: moveTaskInternal's compat-flag legacy path validated moves against the legacy VALID_TRANSITIONS table, which is keyed only by the built-in column ids; a task in a non-legacy workflow column (e.g. "ideas") had no key and every move was rejected. The legacy branch now resolves a non-legacy source column's targets from the task's own workflow adjacency (resolveAllowedColumns) while preserving the legacy bare-Error contract for legacy columns.
+- b9d60b3: summary: Fix overlapping Record and Clear buttons in the Keyboard Shortcuts settings rows on desktop and mobile.
+  category: fix
+  dev: The shortcut-capture Record/Clear buttons no longer use the icon-only `btn-icon` class (which set `line-height:0` and a mobile 36px square, clipping/overlapping the text labels); they use a text-button class and the `.shortcut-capture` row locks buttons with `flex-shrink:0` so the input and controls never overlap, stacking cleanly on mobile.
+- e347062: summary: Fix persistent mobile terminal inter-character spacing (5th recurrence root cause).
+  category: fix
+  dev: xterm's CharSizeService picks a Canvas-based (OffscreenCanvas) or DOM-based character-measurement strategy at terminal.open() time; DomRenderer's letter-spacing bake always measures via a separate DOM-based WidthCache, so a Canvas-vs-DOM measurement mismatch survived FN-7561/FN-7567's remeasure-ordering fixes. `withDomBasedTerminalCharacterMeasurement` in terminalPreferences.ts forces CharSizeService onto the same DOM strategy for both TerminalModal and SessionTerminal.
+- f4f1656: summary: Fix manual PR actions hidden when a task auto-merge override was on but global auto-merge was off.
+  category: fix
+  dev: TaskDetailModal isManualPrFlow now keys off live global autoMergeEnabled, not the per-task effective override (regression from FN-7255).
+
 ## 0.56.0
 
 ### Minor Changes
diff --git a/packages/cli/package.json b/packages/cli/package.json
index fd3058f086..f8a2286eb3 100644
--- a/packages/cli/package.json
+++ b/packages/cli/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@runfusion/fusion",
-  "version": "0.56.0",
+  "version": "0.56.1",
   "license": "MIT",
   "description": "Fusion CLI: HTTP API server, daemon, dashboard launcher, and task tooling for the Fusion AI coding agent.",
   "homepage": "https://github.com/Runfusion/Fusion#readme",
diff --git a/packages/core/CHANGELOG.md b/packages/core/CHANGELOG.md
index 9dd821dbb1..c8d6eef7fc 100644
--- a/packages/core/CHANGELOG.md
+++ b/packages/core/CHANGELOG.md
@@ -1,5 +1,7 @@
 # @fusion/core
 
+## 0.56.1
+
 ## 0.56.0
 
 ## 0.55.0
diff --git a/packages/core/package.json b/packages/core/package.json
index 231c17ef04..c6ad2fd87d 100644
--- a/packages/core/package.json
+++ b/packages/core/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@fusion/core",
-  "version": "0.56.0",
+  "version": "0.56.1",
   "license": "MIT",
   "description": "Fusion core: task store, scheduler, settings, and shared domain types backing the Fusion AI coding agent.",
   "homepage": "https://github.com/Runfusion/Fusion#readme",
diff --git a/packages/dashboard/CHANGELOG.md b/packages/dashboard/CHANGELOG.md
index 2c24c505ba..7d9e93287d 100644
--- a/packages/dashboard/CHANGELOG.md
+++ b/packages/dashboard/CHANGELOG.md
@@ -1,5 +1,22 @@
 # @fusion/dashboard
 
+## 0.56.1
+
+### Patch Changes
+
+- @fusion/core@0.56.1
+- @fusion/engine@0.56.1
+- @fusion/i18n@0.39.21
+- @fusion-plugin-examples/cli-printing-press@0.1.38
+- @fusion-plugin-examples/compound-engineering@0.1.21
+- @fusion-plugin-examples/dependency-graph@0.1.52
+- @fusion-plugin-examples/roadmap@0.1.40
+- @fusion-plugin-examples/cursor-runtime@0.1.40
+- @fusion-plugin-examples/droid-runtime@0.1.47
+- @fusion-plugin-examples/hermes-runtime@0.2.71
+- @fusion-plugin-examples/openclaw-runtime@0.2.71
+- @fusion-plugin-examples/paperclip-runtime@0.2.71
+
 ## 0.56.0
 
 ### Patch Changes
diff --git a/packages/dashboard/package.json b/packages/dashboard/package.json
index fd257dd688..b11d2f8ad9 100644
--- a/packages/dashboard/package.json
+++ b/packages/dashboard/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@fusion/dashboard",
-  "version": "0.56.0",
+  "version": "0.56.1",
   "license": "MIT",
   "description": "Fusion dashboard: React UI and HTTP API server for monitoring and controlling the Fusion AI coding agent.",
   "homepage": "https://github.com/Runfusion/Fusion#readme",
diff --git a/packages/desktop/CHANGELOG.md b/packages/desktop/CHANGELOG.md
index 9cdc43a1f9..8aba45e5e5 100644
--- a/packages/desktop/CHANGELOG.md
+++ b/packages/desktop/CHANGELOG.md
@@ -1,5 +1,13 @@
 # @fusion/desktop
 
+## 0.56.1
+
+### Patch Changes
+
+- @fusion/core@0.56.1
+- @fusion/dashboard@0.56.1
+- @fusion/engine@0.56.1
+
 ## 0.56.0
 
 ### Patch Changes
diff --git a/packages/desktop/package.json b/packages/desktop/package.json
index 3ada770992..db9058640c 100644
--- a/packages/desktop/package.json
+++ b/packages/desktop/package.json
@@ -1,7 +1,7 @@
 {
   "name": "@fusion/desktop",
   "productName": "Fusion",
-  "version": "0.56.0",
+  "version": "0.56.1",
   "license": "MIT",
   "author": {
     "name": "Runfusion",
diff --git a/packages/droid-cli/CHANGELOG.md b/packages/droid-cli/CHANGELOG.md
index 76ed864e1f..135712e5b7 100644
--- a/packages/droid-cli/CHANGELOG.md
+++ b/packages/droid-cli/CHANGELOG.md
@@ -1,5 +1,11 @@
 # @fusion/droid-cli
 
+## 0.11.47
+
+### Patch Changes
+
+- @fusion-plugin-examples/droid-runtime@0.1.47
+
 ## 0.11.46
 
 ### Patch Changes
diff --git a/packages/droid-cli/package.json b/packages/droid-cli/package.json
index b4f78e77ce..f925155ebd 100644
--- a/packages/droid-cli/package.json
+++ b/packages/droid-cli/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@fusion/droid-cli",
-  "version": "0.11.46",
+  "version": "0.11.47",
   "description": "First-party Fusion pi extension that routes LLM calls through the Droid CLI subprocess.",
   "license": "MIT",
   "private": true,
diff --git a/packages/engine/CHANGELOG.md b/packages/engine/CHANGELOG.md
index 9a2a0641c7..f8045182da 100644
--- a/packages/engine/CHANGELOG.md
+++ b/packages/engine/CHANGELOG.md
@@ -1,5 +1,12 @@
 # @fusion/engine
 
+## 0.56.1
+
+### Patch Changes
+
+- @fusion/core@0.56.1
+- @fusion/pi-claude-cli@0.56.1
+
 ## 0.56.0
 
 ### Patch Changes
diff --git a/packages/engine/package.json b/packages/engine/package.json
index c0dbe437f9..e4098cb6d3 100644
--- a/packages/engine/package.json
+++ b/packages/engine/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@fusion/engine",
-  "version": "0.56.0",
+  "version": "0.56.1",
   "license": "MIT",
   "description": "Fusion engine: executor, merger, scheduler, and automation runtime for the Fusion AI coding agent.",
   "homepage": "https://github.com/Runfusion/Fusion#readme",
diff --git a/packages/i18n/CHANGELOG.md b/packages/i18n/CHANGELOG.md
index 6cca96c292..90ee12f5e0 100644
--- a/packages/i18n/CHANGELOG.md
+++ b/packages/i18n/CHANGELOG.md
@@ -1,5 +1,11 @@
 # @fusion/i18n
 
+## 0.39.21
+
+### Patch Changes
+
+- @fusion/core@0.56.1
+
 ## 0.39.20
 
 ### Patch Changes
diff --git a/packages/i18n/package.json b/packages/i18n/package.json
index 1f72dffbb0..3808b2a1f6 100644
--- a/packages/i18n/package.json
+++ b/packages/i18n/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@fusion/i18n",
-  "version": "0.39.20",
+  "version": "0.39.21",
   "license": "MIT",
   "description": "Fusion i18n: authored translation catalogs and shared i18next configuration for the Fusion dashboard and terminal UI.",
   "type": "module",
diff --git a/packages/mobile/CHANGELOG.md b/packages/mobile/CHANGELOG.md
index eb259f5e2f..c444640557 100644
--- a/packages/mobile/CHANGELOG.md
+++ b/packages/mobile/CHANGELOG.md
@@ -1,5 +1,7 @@
 # @fusion/mobile
 
+## 0.56.1
+
 ## 0.56.0
 
 ## 0.55.0
diff --git a/packages/mobile/package.json b/packages/mobile/package.json
index 9155721d9e..f21434c96c 100644
--- a/packages/mobile/package.json
+++ b/packages/mobile/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@fusion/mobile",
-  "version": "0.56.0",
+  "version": "0.56.1",
   "license": "MIT",
   "description": "Fusion mobile: Capacitor wrapper around the Fusion dashboard for iOS and Android.",
   "homepage": "https://github.com/Runfusion/Fusion#readme",
diff --git a/packages/pi-claude-cli/CHANGELOG.md b/packages/pi-claude-cli/CHANGELOG.md
index 33da4a620d..74c218d378 100644
--- a/packages/pi-claude-cli/CHANGELOG.md
+++ b/packages/pi-claude-cli/CHANGELOG.md
@@ -1,5 +1,7 @@
 # @fusion/pi-claude-cli
 
+## 0.56.1
+
 ## 0.56.0
 
 ## 0.55.0
diff --git a/packages/pi-claude-cli/package.json b/packages/pi-claude-cli/package.json
index 5492de6a46..3e0677fc62 100644
--- a/packages/pi-claude-cli/package.json
+++ b/packages/pi-claude-cli/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@fusion/pi-claude-cli",
-  "version": "0.56.0",
+  "version": "0.56.1",
   "description": "Fusion vendored fork: pi coding-agent extension that routes LLM calls through the Claude Code CLI. Forked from rchern/pi-claude-cli (MIT). See UPSTREAM.md.",
   "license": "MIT",
   "private": true,
diff --git a/packages/plugin-sdk/CHANGELOG.md b/packages/plugin-sdk/CHANGELOG.md
index 7fae7b8544..16eb15c790 100644
--- a/packages/plugin-sdk/CHANGELOG.md
+++ b/packages/plugin-sdk/CHANGELOG.md
@@ -1,5 +1,11 @@
 # @fusion/plugin-sdk
 
+## 0.56.1
+
+### Patch Changes
+
+- @fusion/core@0.56.1
+
 ## 0.56.0
 
 ### Patch Changes
diff --git a/packages/plugin-sdk/package.json b/packages/plugin-sdk/package.json
index 521758e3da..3b118d1e4f 100644
--- a/packages/plugin-sdk/package.json
+++ b/packages/plugin-sdk/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@fusion/plugin-sdk",
-  "version": "0.56.0",
+  "version": "0.56.1",
   "license": "MIT",
   "description": "Fusion plugin SDK: types and helpers for authoring third-party plugins that extend the Fusion dashboard and engine.",
   "homepage": "https://github.com/Runfusion/Fusion#readme",
diff --git a/plugins/examples/fusion-plugin-auto-label/CHANGELOG.md b/plugins/examples/fusion-plugin-auto-label/CHANGELOG.md
index 92123aac5b..42c6f49400 100644
--- a/plugins/examples/fusion-plugin-auto-label/CHANGELOG.md
+++ b/plugins/examples/fusion-plugin-auto-label/CHANGELOG.md
@@ -1,5 +1,11 @@
 # @fusion-plugin-examples/auto-label
 
+## 0.2.71
+
+### Patch Changes
+
+- @fusion/plugin-sdk@0.56.1
+
 ## 0.2.70
 
 ### Patch Changes
diff --git a/plugins/examples/fusion-plugin-auto-label/package.json b/plugins/examples/fusion-plugin-auto-label/package.json
index ac3934a24c..c1b0d827d6 100644
--- a/plugins/examples/fusion-plugin-auto-label/package.json
+++ b/plugins/examples/fusion-plugin-auto-label/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@fusion-plugin-examples/auto-label",
-  "version": "0.2.70",
+  "version": "0.2.71",
   "type": "module",
   "description": "Automatically labels tasks based on description content",
   "keywords": [
diff --git a/plugins/examples/fusion-plugin-ci-status/CHANGELOG.md b/plugins/examples/fusion-plugin-ci-status/CHANGELOG.md
index b14c0e873b..231a173dcc 100644
--- a/plugins/examples/fusion-plugin-ci-status/CHANGELOG.md
+++ b/plugins/examples/fusion-plugin-ci-status/CHANGELOG.md
@@ -1,5 +1,11 @@
 # @fusion-plugin-examples/ci-status
 
+## 0.2.71
+
+### Patch Changes
+
+- @fusion/plugin-sdk@0.56.1
+
 ## 0.2.70
 
 ### Patch Changes
diff --git a/plugins/examples/fusion-plugin-ci-status/package.json b/plugins/examples/fusion-plugin-ci-status/package.json
index 8ac8d2e1d2..52acb61b45 100644
--- a/plugins/examples/fusion-plugin-ci-status/package.json
+++ b/plugins/examples/fusion-plugin-ci-status/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@fusion-plugin-examples/ci-status",
-  "version": "0.2.70",
+  "version": "0.2.71",
   "type": "module",
   "description": "Polls CI status for branches and provides a custom API to query results",
   "keywords": [
diff --git a/plugins/examples/fusion-plugin-notification/CHANGELOG.md b/plugins/examples/fusion-plugin-notification/CHANGELOG.md
index 7b693db1b3..8826215ec9 100644
--- a/plugins/examples/fusion-plugin-notification/CHANGELOG.md
+++ b/plugins/examples/fusion-plugin-notification/CHANGELOG.md
@@ -1,5 +1,11 @@
 # @fusion-plugin-examples/notification
 
+## 0.2.71
+
+### Patch Changes
+
+- @fusion/plugin-sdk@0.56.1
+
 ## 0.2.70
 
 ### Patch Changes
diff --git a/plugins/examples/fusion-plugin-notification/package.json b/plugins/examples/fusion-plugin-notification/package.json
index 0bcc3dda54..b30599211b 100644
--- a/plugins/examples/fusion-plugin-notification/package.json
+++ b/plugins/examples/fusion-plugin-notification/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@fusion-plugin-examples/notification",
-  "version": "0.2.70",
+  "version": "0.2.71",
   "type": "module",
   "description": "Example Fusion plugin that sends webhook notifications on task lifecycle events",
   "keywords": [
diff --git a/plugins/examples/fusion-plugin-settings-demo/CHANGELOG.md b/plugins/examples/fusion-plugin-settings-demo/CHANGELOG.md
index bc00e600ca..7d1d0186dc 100644
--- a/plugins/examples/fusion-plugin-settings-demo/CHANGELOG.md
+++ b/plugins/examples/fusion-plugin-settings-demo/CHANGELOG.md
@@ -1,5 +1,11 @@
 # @fusion-plugin-examples/settings-demo
 
+## 0.2.71
+
+### Patch Changes
+
+- @fusion/plugin-sdk@0.56.1
+
 ## 0.2.70
 
 ### Patch Changes
diff --git a/plugins/examples/fusion-plugin-settings-demo/package.json b/plugins/examples/fusion-plugin-settings-demo/package.json
index c0fe1a7a18..9cf38200b1 100644
--- a/plugins/examples/fusion-plugin-settings-demo/package.json
+++ b/plugins/examples/fusion-plugin-settings-demo/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@fusion-plugin-examples/settings-demo",
-  "version": "0.2.70",
+  "version": "0.2.71",
   "type": "module",
   "description": "Example Fusion plugin demonstrating settings schema and runtime configuration",
   "keywords": [
diff --git a/plugins/fusion-plugin-acp-runtime/CHANGELOG.md b/plugins/fusion-plugin-acp-runtime/CHANGELOG.md
index 3a345fbe25..7e33187842 100644
--- a/plugins/fusion-plugin-acp-runtime/CHANGELOG.md
+++ b/plugins/fusion-plugin-acp-runtime/CHANGELOG.md
@@ -1,5 +1,12 @@
 # @fusion-plugin-examples/acp-runtime
 
+## 0.1.21
+
+### Patch Changes
+
+- @fusion/core@0.56.1
+- @fusion/plugin-sdk@0.56.1
+
 ## 0.1.20
 
 ### Patch Changes
diff --git a/plugins/fusion-plugin-acp-runtime/package.json b/plugins/fusion-plugin-acp-runtime/package.json
index 74d51139c1..871ef720fb 100644
--- a/plugins/fusion-plugin-acp-runtime/package.json
+++ b/plugins/fusion-plugin-acp-runtime/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@fusion-plugin-examples/acp-runtime",
-  "version": "0.1.20",
+  "version": "0.1.21",
   "type": "module",
   "description": "ACP (Agent Client Protocol) runtime plugin for Fusion — drives any ACP-compatible agent over JSON-RPC/stdio",
   "keywords": [
diff --git a/plugins/fusion-plugin-agent-browser/CHANGELOG.md b/plugins/fusion-plugin-agent-browser/CHANGELOG.md
index a505b9593b..8ebc9bf9f5 100644
--- a/plugins/fusion-plugin-agent-browser/CHANGELOG.md
+++ b/plugins/fusion-plugin-agent-browser/CHANGELOG.md
@@ -1,5 +1,11 @@
 # @fusion-plugin-examples/agent-browser
 
+## 0.1.41
+
+### Patch Changes
+
+- @fusion/plugin-sdk@0.56.1
+
 ## 0.1.40
 
 ### Patch Changes
diff --git a/plugins/fusion-plugin-agent-browser/package.json b/plugins/fusion-plugin-agent-browser/package.json
index ad16fb8759..e8289c6c8d 100644
--- a/plugins/fusion-plugin-agent-browser/package.json
+++ b/plugins/fusion-plugin-agent-browser/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@fusion-plugin-examples/agent-browser",
-  "version": "0.1.40",
+  "version": "0.1.41",
   "type": "module",
   "description": "Agent Browser runtime and prompt/skill/workflow contributions for Fusion",
   "private": true,
diff --git a/plugins/fusion-plugin-cli-printing-press/CHANGELOG.md b/plugins/fusion-plugin-cli-printing-press/CHANGELOG.md
index b36d1e51c8..5b5a6ad18a 100644
--- a/plugins/fusion-plugin-cli-printing-press/CHANGELOG.md
+++ b/plugins/fusion-plugin-cli-printing-press/CHANGELOG.md
@@ -1,5 +1,12 @@
 # @fusion-plugin-examples/cli-printing-press
 
+## 0.1.38
+
+### Patch Changes
+
+- @fusion/core@0.56.1
+- @fusion/plugin-sdk@0.56.1
+
 ## 0.1.37
 
 ### Patch Changes
diff --git a/plugins/fusion-plugin-cli-printing-press/package.json b/plugins/fusion-plugin-cli-printing-press/package.json
index 67fb31e856..cee6385d0e 100644
--- a/plugins/fusion-plugin-cli-printing-press/package.json
+++ b/plugins/fusion-plugin-cli-printing-press/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@fusion-plugin-examples/cli-printing-press",
-  "version": "0.1.37",
+  "version": "0.1.38",
   "type": "module",
   "description": "CLI Printing Press plugin package for Fusion",
   "private": true,
diff --git a/plugins/fusion-plugin-compound-engineering/CHANGELOG.md b/plugins/fusion-plugin-compound-engineering/CHANGELOG.md
index d18283a8d3..aadb5297ee 100644
--- a/plugins/fusion-plugin-compound-engineering/CHANGELOG.md
+++ b/plugins/fusion-plugin-compound-engineering/CHANGELOG.md
@@ -1,5 +1,12 @@
 # @fusion-plugin-examples/compound-engineering
 
+## 0.1.21
+
+### Patch Changes
+
+- @fusion/core@0.56.1
+- @fusion/plugin-sdk@0.56.1
+
 ## 0.1.20
 
 ### Patch Changes
diff --git a/plugins/fusion-plugin-compound-engineering/package.json b/plugins/fusion-plugin-compound-engineering/package.json
index 6d77c79dd1..8e81d3f700 100644
--- a/plugins/fusion-plugin-compound-engineering/package.json
+++ b/plugins/fusion-plugin-compound-engineering/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@fusion-plugin-examples/compound-engineering",
-  "version": "0.1.20",
+  "version": "0.1.21",
   "type": "module",
   "description": "Compound Engineering plugin for Fusion",
   "private": true,
diff --git a/plugins/fusion-plugin-cursor-runtime/CHANGELOG.md b/plugins/fusion-plugin-cursor-runtime/CHANGELOG.md
index f9549c047a..dfc6cd1023 100644
--- a/plugins/fusion-plugin-cursor-runtime/CHANGELOG.md
+++ b/plugins/fusion-plugin-cursor-runtime/CHANGELOG.md
@@ -1,5 +1,11 @@
 # @fusion-plugin-examples/cursor-runtime
 
+## 0.1.40
+
+### Patch Changes
+
+- @fusion/plugin-sdk@0.56.1
+
 ## 0.1.39
 
 ### Patch Changes
diff --git a/plugins/fusion-plugin-cursor-runtime/package.json b/plugins/fusion-plugin-cursor-runtime/package.json
index 2e70825d3a..6d1bda08fe 100644
--- a/plugins/fusion-plugin-cursor-runtime/package.json
+++ b/plugins/fusion-plugin-cursor-runtime/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@fusion-plugin-examples/cursor-runtime",
-  "version": "0.1.39",
+  "version": "0.1.40",
   "type": "module",
   "description": "Cursor CLI runtime plugin for Fusion",
   "keywords": [
diff --git a/plugins/fusion-plugin-dependency-graph/CHANGELOG.md b/plugins/fusion-plugin-dependency-graph/CHANGELOG.md
index 525a181f64..d3bcb35875 100644
--- a/plugins/fusion-plugin-dependency-graph/CHANGELOG.md
+++ b/plugins/fusion-plugin-dependency-graph/CHANGELOG.md
@@ -1,5 +1,12 @@
 # @fusion-plugin-examples/dependency-graph
 
+## 0.1.52
+
+### Patch Changes
+
+- @fusion/core@0.56.1
+- @fusion/plugin-sdk@0.56.1
+
 ## 0.1.51
 
 ### Patch Changes
diff --git a/plugins/fusion-plugin-dependency-graph/package.json b/plugins/fusion-plugin-dependency-graph/package.json
index 16222c5d22..be38970e04 100644
--- a/plugins/fusion-plugin-dependency-graph/package.json
+++ b/plugins/fusion-plugin-dependency-graph/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@fusion-plugin-examples/dependency-graph",
-  "version": "0.1.51",
+  "version": "0.1.52",
   "type": "module",
   "description": "Dependency graph dashboard view plugin for Fusion",
   "private": true,
diff --git a/plugins/fusion-plugin-droid-runtime/CHANGELOG.md b/plugins/fusion-plugin-droid-runtime/CHANGELOG.md
index 1b22afb3d5..b2afcd23c3 100644
--- a/plugins/fusion-plugin-droid-runtime/CHANGELOG.md
+++ b/plugins/fusion-plugin-droid-runtime/CHANGELOG.md
@@ -1,5 +1,11 @@
 # Changelog
 
+## 0.1.47
+
+### Patch Changes
+
+- @fusion/plugin-sdk@0.56.1
+
 ## 0.1.46
 
 ### Patch Changes
diff --git a/plugins/fusion-plugin-droid-runtime/package.json b/plugins/fusion-plugin-droid-runtime/package.json
index 012e0f4c99..142edcfb7d 100644
--- a/plugins/fusion-plugin-droid-runtime/package.json
+++ b/plugins/fusion-plugin-droid-runtime/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@fusion-plugin-examples/droid-runtime",
-  "version": "0.1.46",
+  "version": "0.1.47",
   "type": "module",
   "description": "Droid runtime plugin for Fusion",
   "keywords": [
diff --git a/plugins/fusion-plugin-even-realities-glasses/CHANGELOG.md b/plugins/fusion-plugin-even-realities-glasses/CHANGELOG.md
index 79db7d7f80..6203767d6f 100644
--- a/plugins/fusion-plugin-even-realities-glasses/CHANGELOG.md
+++ b/plugins/fusion-plugin-even-realities-glasses/CHANGELOG.md
@@ -1,5 +1,12 @@
 # @fusion-plugin-examples/even-realities-glasses
 
+## 0.1.40
+
+### Patch Changes
+
+- @fusion/core@0.56.1
+- @fusion/plugin-sdk@0.56.1
+
 ## 0.1.39
 
 ### Patch Changes
diff --git a/plugins/fusion-plugin-even-realities-glasses/package.json b/plugins/fusion-plugin-even-realities-glasses/package.json
index 344be51f03..e8c20e82a3 100644
--- a/plugins/fusion-plugin-even-realities-glasses/package.json
+++ b/plugins/fusion-plugin-even-realities-glasses/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@fusion-plugin-examples/even-realities-glasses",
-  "version": "0.1.39",
+  "version": "0.1.40",
   "type": "module",
   "description": "Canonical Even Realities Fusion plugin with board/task cards, actions, notifications, and webhook transport",
   "keywords": [
diff --git a/plugins/fusion-plugin-hermes-runtime/CHANGELOG.md b/plugins/fusion-plugin-hermes-runtime/CHANGELOG.md
index 54429dbe28..0550886d3a 100644
--- a/plugins/fusion-plugin-hermes-runtime/CHANGELOG.md
+++ b/plugins/fusion-plugin-hermes-runtime/CHANGELOG.md
@@ -1,5 +1,11 @@
 # @fusion-plugin-examples/hermes-runtime
 
+## 0.2.71
+
+### Patch Changes
+
+- @fusion/plugin-sdk@0.56.1
+
 ## 0.2.70
 
 ### Patch Changes
diff --git a/plugins/fusion-plugin-hermes-runtime/package.json b/plugins/fusion-plugin-hermes-runtime/package.json
index af876dab32..f749733062 100644
--- a/plugins/fusion-plugin-hermes-runtime/package.json
+++ b/plugins/fusion-plugin-hermes-runtime/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@fusion-plugin-examples/hermes-runtime",
-  "version": "0.2.70",
+  "version": "0.2.71",
   "type": "module",
   "description": "Hermes AI runtime plugin for Fusion - provides AI agent execution runtime",
   "keywords": [
diff --git a/plugins/fusion-plugin-linear-import/CHANGELOG.md b/plugins/fusion-plugin-linear-import/CHANGELOG.md
index 1638eac78f..01ce0c2ac6 100644
--- a/plugins/fusion-plugin-linear-import/CHANGELOG.md
+++ b/plugins/fusion-plugin-linear-import/CHANGELOG.md
@@ -1,5 +1,12 @@
 # @fusion-plugin-examples/linear-import
 
+## 0.1.3
+
+### Patch Changes
+
+- @fusion/core@0.56.1
+- @fusion/plugin-sdk@0.56.1
+
 ## 0.1.2
 
 ### Patch Changes
diff --git a/plugins/fusion-plugin-linear-import/package.json b/plugins/fusion-plugin-linear-import/package.json
index f118732483..4919e826da 100644
--- a/plugins/fusion-plugin-linear-import/package.json
+++ b/plugins/fusion-plugin-linear-import/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@fusion-plugin-examples/linear-import",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "type": "module",
   "description": "Linear issue import plugin for Fusion",
   "private": true,
diff --git a/plugins/fusion-plugin-openclaw-runtime/CHANGELOG.md b/plugins/fusion-plugin-openclaw-runtime/CHANGELOG.md
index 921a963f1f..e8508218cd 100644
--- a/plugins/fusion-plugin-openclaw-runtime/CHANGELOG.md
+++ b/plugins/fusion-plugin-openclaw-runtime/CHANGELOG.md
@@ -1,5 +1,11 @@
 # @fusion-plugin-examples/openclaw-runtime
 
+## 0.2.71
+
+### Patch Changes
+
+- @fusion/plugin-sdk@0.56.1
+
 ## 0.2.70
 
 ### Patch Changes
diff --git a/plugins/fusion-plugin-openclaw-runtime/package.json b/plugins/fusion-plugin-openclaw-runtime/package.json
index 3dfa0f20d1..397aa87505 100644
--- a/plugins/fusion-plugin-openclaw-runtime/package.json
+++ b/plugins/fusion-plugin-openclaw-runtime/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@fusion-plugin-examples/openclaw-runtime",
-  "version": "0.2.70",
+  "version": "0.2.71",
   "type": "module",
   "description": "Provides OpenClaw runtime for Fusion AI agents",
   "keywords": [
diff --git a/plugins/fusion-plugin-paperclip-runtime/CHANGELOG.md b/plugins/fusion-plugin-paperclip-runtime/CHANGELOG.md
index d44930ff61..b01a3cd5e2 100644
--- a/plugins/fusion-plugin-paperclip-runtime/CHANGELOG.md
+++ b/plugins/fusion-plugin-paperclip-runtime/CHANGELOG.md
@@ -1,5 +1,11 @@
 # @fusion-plugin-examples/paperclip-runtime
 
+## 0.2.71
+
+### Patch Changes
+
+- @fusion/plugin-sdk@0.56.1
+
 ## 0.2.70
 
 ### Patch Changes
diff --git a/plugins/fusion-plugin-paperclip-runtime/package.json b/plugins/fusion-plugin-paperclip-runtime/package.json
index cc413d9618..a00b20d9ca 100644
--- a/plugins/fusion-plugin-paperclip-runtime/package.json
+++ b/plugins/fusion-plugin-paperclip-runtime/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@fusion-plugin-examples/paperclip-runtime",
-  "version": "0.2.70",
+  "version": "0.2.71",
   "type": "module",
   "description": "Paperclip runtime plugin for Fusion — provides AI agent web access capabilities",
   "keywords": [
diff --git a/plugins/fusion-plugin-reports/CHANGELOG.md b/plugins/fusion-plugin-reports/CHANGELOG.md
index bf9e6f7188..b29957f98d 100644
--- a/plugins/fusion-plugin-reports/CHANGELOG.md
+++ b/plugins/fusion-plugin-reports/CHANGELOG.md
@@ -1,5 +1,13 @@
 # @fusion-plugin-examples/reports
 
+## 0.1.40
+
+### Patch Changes
+
+- @fusion/core@0.56.1
+- @fusion/dashboard@0.56.1
+- @fusion/plugin-sdk@0.56.1
+
 ## 0.1.39
 
 ### Patch Changes
diff --git a/plugins/fusion-plugin-reports/package.json b/plugins/fusion-plugin-reports/package.json
index fc187bba8c..0932261506 100644
--- a/plugins/fusion-plugin-reports/package.json
+++ b/plugins/fusion-plugin-reports/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@fusion-plugin-examples/reports",
-  "version": "0.1.39",
+  "version": "0.1.40",
   "type": "module",
   "description": "Reports plugin for Fusion",
   "private": true,
diff --git a/plugins/fusion-plugin-roadmap/CHANGELOG.md b/plugins/fusion-plugin-roadmap/CHANGELOG.md
index f55491f4e1..b8d9ed1a60 100644
--- a/plugins/fusion-plugin-roadmap/CHANGELOG.md
+++ b/plugins/fusion-plugin-roadmap/CHANGELOG.md
@@ -1,5 +1,12 @@
 # @fusion-plugin-examples/roadmap
 
+## 0.1.40
+
+### Patch Changes
+
+- @fusion/core@0.56.1
+- @fusion/plugin-sdk@0.56.1
+
 ## 0.1.39
 
 ### Patch Changes
diff --git a/plugins/fusion-plugin-roadmap/package.json b/plugins/fusion-plugin-roadmap/package.json
index 6bf65b5af6..decd0bf70e 100644
--- a/plugins/fusion-plugin-roadmap/package.json
+++ b/plugins/fusion-plugin-roadmap/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@fusion-plugin-examples/roadmap",
-  "version": "0.1.39",
+  "version": "0.1.40",
   "type": "module",
   "description": "Roadmap plugin package for Fusion",
   "private": true,
diff --git a/plugins/fusion-plugin-whatsapp-chat/CHANGELOG.md b/plugins/fusion-plugin-whatsapp-chat/CHANGELOG.md
index 3afe98696f..99c956c295 100644
--- a/plugins/fusion-plugin-whatsapp-chat/CHANGELOG.md
+++ b/plugins/fusion-plugin-whatsapp-chat/CHANGELOG.md
@@ -1,5 +1,11 @@
 # @fusion-plugin-examples/whatsapp-chat
 
+## 0.1.40
+
+### Patch Changes
+
+- @fusion/plugin-sdk@0.56.1
+
 ## 0.1.39
 
 ### Patch Changes
diff --git a/plugins/fusion-plugin-whatsapp-chat/package.json b/plugins/fusion-plugin-whatsapp-chat/package.json
index b66806fbb3..fb5071968e 100644
--- a/plugins/fusion-plugin-whatsapp-chat/package.json
+++ b/plugins/fusion-plugin-whatsapp-chat/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@fusion-plugin-examples/whatsapp-chat",
-  "version": "0.1.39",
+  "version": "0.1.40",
   "type": "module",
   "description": "WhatsApp Web (Baileys) chat bridge for Fusion agents",
   "keywords": [