From e4a59f726905018a3d898a24572c97fea994507b Mon Sep 17 00:00:00 2001
From: gsxdsm <gsxdsm@users.noreply.github.com>
Date: Thu, 9 Jul 2026 10:08:17 -0700
Subject: [PATCH] fix: remove over-firing triage release-authorization gate

The triage release-authorization gate (FN-6481/FN-6469) false-flagged any
spec that merely mentioned release tooling (scripts/release.mjs, pnpm release)
and, because non-user sources made the in-band authorization marker inert,
stranded ordinary tasks in awaiting-approval with no exit.

- Delete triage-release-authorization.ts + its test and the finalizeApprovedTask
  parking block; release-class specs now flow through triage normally.
- Remove the dashboard approve/reject-plan API guards and UI gating so tasks
  still carrying the legacy awaitingApprovalReason="release-authorization" hold
  render as ordinary manual plan-approval holds and can be resolved.
- Keep the awaitingApprovalReason field + activity label for backward-compat.
- Replace the engine gate with agent instruction (AGENTS.md -> Releasing):
  agents must never run a release from inside a Fusion task.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 .../remove-release-authorization-gate.md      |   7 +
 AGENTS.md                                     |   4 +-
 packages/core/src/types.ts                    |  22 +-
 .../dashboard/app/components/TaskCard.tsx     |  12 +-
 .../app/components/TaskDetailModal.tsx        |  41 +--
 .../components/__tests__/TaskCard.test.tsx    |  29 +--
 ...askDetailModal.definition-actions.test.tsx |  18 +-
 .../src/__tests__/routes-github.test.ts       |  35 +--
 .../routes/register-task-workflow-routes.ts   |  31 +--
 .../triage-release-authorization.test.ts      | 233 ------------------
 packages/engine/src/__tests__/triage.test.ts  |  86 +------
 .../src/triage-release-authorization.ts       | 135 ----------
 packages/engine/src/triage.ts                 |  62 +----
 13 files changed, 91 insertions(+), 624 deletions(-)
 create mode 100644 .changeset/remove-release-authorization-gate.md
 delete mode 100644 packages/engine/src/__tests__/triage-release-authorization.test.ts
 delete mode 100644 packages/engine/src/triage-release-authorization.ts

diff --git a/.changeset/remove-release-authorization-gate.md b/.changeset/remove-release-authorization-gate.md
new file mode 100644
index 0000000000..0976fd085f
--- /dev/null
+++ b/.changeset/remove-release-authorization-gate.md
@@ -0,0 +1,7 @@
+---
+"@runfusion/fusion": patch
+---
+
+summary: Tasks are no longer stuck "awaiting release authorization" — the over-firing release gate was removed.
+category: fix
+dev: Removed the triage release-authorization gate (packages/engine/src/triage-release-authorization.ts + finalizeApprovedTask block) and its dashboard approve/reject-plan guards. It false-flagged specs that merely mentioned release tooling and stranded tasks in awaiting-approval with no in-band exit. Legacy `awaitingApprovalReason: "release-authorization"` rows now render as ordinary manual plan-approval holds. Releases are kept out of Fusion by agent instruction (AGENTS.md → Releasing) instead.
diff --git a/AGENTS.md b/AGENTS.md
index 0cd79cb424..38418777ea 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -67,7 +67,9 @@ A linter (`pnpm check:changesets`) validates this format and runs in the PR-chec
 
 ### Releasing
 
-Use only:
+**Never run a release from inside a Fusion task.** Do not run `pnpm release`, `changeset publish`, `pnpm publish`, `npm publish`, or cut git version tags as part of any Fusion-dispatched work (triage/executor/reviewer/merger/agent-heartbeat lanes). Releasing is an operator-only action performed by a human outside the task loop. If a task's spec appears to require a release, stop and leave it for a human operator — do not self-authorize or perform the publish. (The former engine "release authorization" gate that parked such tasks was removed because it over-fired on specs that merely *mentioned* release tooling; this instruction replaces it.)
+
+When a human operator does release, use only:
 
 ```bash
 pnpm release --yes
diff --git a/packages/core/src/types.ts b/packages/core/src/types.ts
index 1fc4093034..b505d7d6af 100644
--- a/packages/core/src/types.ts
+++ b/packages/core/src/types.ts
@@ -2526,19 +2526,15 @@ export interface Task {
    *  `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.
+   * FNXC:ReleaseAuthorizationGate 2026-07-09-00:00:
+   * DEPRECATED — the triage release-authorization gate that set this field was removed
+   * (it over-fired on AI-authored specs that merely mention release tooling and stranded
+   * ordinary tasks in "awaiting-approval" with no in-band exit). No code writes
+   * "release-authorization" anymore; releases are kept out of Fusion by agent instruction
+   * (AGENTS.md → "Releasing"), not an engine gate. The field is retained only so existing
+   * task rows persisted with the legacy value still deserialize; the dashboard now treats
+   * any such hold as an ordinary manual plan-approval hold (Approve/Reject Plan render
+   * normally). Undefined means either no hold or a manual-approval hold.
    */
   awaitingApprovalReason?: "release-authorization";
   /*
diff --git a/packages/dashboard/app/components/TaskCard.tsx b/packages/dashboard/app/components/TaskCard.tsx
index b25933b3d1..42f68a0ab0 100644
--- a/packages/dashboard/app/components/TaskCard.tsx
+++ b/packages/dashboard/app/components/TaskCard.tsx
@@ -1271,14 +1271,12 @@ function TaskCardComponent({
   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.
+   * FNXC:ReleaseAuthorizationGate 2026-07-09-00:00:
+   * The triage release-authorization gate was removed; a legacy release-authorization
+   * hold is now just an ordinary manual plan-approval hold and no longer gets a
+   * distinct badge.
    */
-  const isReleaseAuthorizationHold = isAwaitingApproval && task.awaitingApprovalReason === "release-authorization";
+  const isReleaseAuthorizationHold = false;
   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));
diff --git a/packages/dashboard/app/components/TaskDetailModal.tsx b/packages/dashboard/app/components/TaskDetailModal.tsx
index ceb8a9afdd..c60a9c579c 100644
--- a/packages/dashboard/app/components/TaskDetailModal.tsx
+++ b/packages/dashboard/app/components/TaskDetailModal.tsx
@@ -2668,16 +2668,13 @@ export function TaskDetailContent({
 
   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.
+   * FNXC:ReleaseAuthorizationGate 2026-07-09-00:00:
+   * The triage release-authorization gate was removed. Any task still carrying the
+   * legacy awaitingApprovalReason === "release-authorization" is now treated as an
+   * ordinary manual plan-approval hold so it shows Approve/Reject Plan and is not
+   * stranded with no resolvable affordance.
    */
   const isAwaitingApproval = task.column === "triage" && task.status === "awaiting-approval";
-  const isReleaseAuthorizationHold = isAwaitingApproval && task.awaitingApprovalReason === "release-authorization";
 
   const handleTogglePause = useCallback(async () => {
     try {
@@ -5667,10 +5664,10 @@ export function TaskDetailContent({
             </>
           ) : (
             <>
-              {/* 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 && (
+              {/* Approve/Reject Plan buttons for manual plan-approval holds.
+                  FNXC:ReleaseAuthorizationGate 2026-07-09-00:00: the release-authorization
+                  gate was removed, so legacy release-authorization holds render these too. */}
+              {isAwaitingApproval && workingTask.prompt && (
                 <>
                   <button className="btn btn-primary btn-sm" onClick={handleApprovePlan}>
                     {t("taskDetail.plan.approveBtn", "Approve Plan")}
@@ -5681,26 +5678,10 @@ 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. 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 && (
+                  no quick way to delete a freshly-created task otherwise. */}
+              {task.column === "triage" && !isAwaitingApproval && !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 c9442c1020..841d85b1d4 100644
--- a/packages/dashboard/app/components/__tests__/TaskCard.test.tsx
+++ b/packages/dashboard/app/components/__tests__/TaskCard.test.tsx
@@ -1948,25 +1948,12 @@ describe("TaskCard", () => {
   });
 
   /*
-   * 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.
+   * FNXC:ReleaseAuthorizationGate 2026-07-09-00:00: the triage release-authorization
+   * gate was removed. A legacy release-authorization hold now renders the generic
+   * "Awaiting Approval" badge like any manual plan-approval hold — no distinct
+   * release-authorization label or badge class.
    */
-  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();
-
+  it("renders the generic Awaiting Approval badge for a legacy release-authorization hold", () => {
     const { container: releaseContainer } = render(
       <TaskCard
         task={makeTask({ column: "triage", status: "awaiting-approval", awaitingApprovalReason: "release-authorization" } as any)}
@@ -1974,10 +1961,10 @@ describe("TaskCard", () => {
         addToast={noop}
       />,
     );
-    expect(within(releaseContainer).getByText("Awaiting Release Authorization")).toBeDefined();
-    expect(within(releaseContainer).queryByText("Awaiting Approval")).toBeNull();
+    expect(within(releaseContainer).getByText("Awaiting Approval")).toBeDefined();
+    expect(within(releaseContainer).queryByText("Awaiting Release Authorization")).toBeNull();
     const releaseBadge = releaseContainer.querySelector(".card-status-badge") as HTMLElement;
-    expect(releaseBadge.className).toContain("awaiting-release-authorization");
+    expect(releaseBadge.className).not.toContain("awaiting-release-authorization");
   });
 
   it("renders stalled badge with visible reason when stalledReview is set", () => {
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 b14129ed92..7ec163ae24 100644
--- a/packages/dashboard/app/components/__tests__/TaskDetailModal.definition-actions.test.tsx
+++ b/packages/dashboard/app/components/__tests__/TaskDetailModal.definition-actions.test.tsx
@@ -454,14 +454,12 @@ describe("TaskDetailModal", () => {
     });
 
     /*
-     * 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.
+     * FNXC:ReleaseAuthorizationGate 2026-07-09-00:00: the triage release-authorization
+     * gate was removed. A task still carrying the legacy release-authorization hold is
+     * now treated as an ordinary manual plan-approval hold and renders Approve/Reject
+     * Plan normally instead of a distinct, unresolvable reason string.
      */
-    it("shows a distinct release-authorization reason instead of Approve/Reject Plan buttons", () => {
+    it("shows Approve/Reject Plan for a legacy release-authorization hold", () => {
       render(
         <TaskDetailModal
           task={makeTask({
@@ -480,9 +478,9 @@ describe("TaskDetailModal", () => {
         />,
       );
 
-      expect(screen.queryByText("Approve Plan")).toBeNull();
-      expect(screen.queryByText("Reject Plan")).toBeNull();
-      expect(screen.getByText(/Awaiting release authorization/i)).toBeTruthy();
+      expect(screen.getByText("Approve Plan")).toBeTruthy();
+      expect(screen.getByText("Reject Plan")).toBeTruthy();
+      expect(screen.queryByText(/Awaiting release authorization/i)).toBeNull();
     });
 
     it("does not show approval buttons when task is not in triage", () => {
diff --git a/packages/dashboard/src/__tests__/routes-github.test.ts b/packages/dashboard/src/__tests__/routes-github.test.ts
index f20b802264..01f1aead55 100644
--- a/packages/dashboard/src/__tests__/routes-github.test.ts
+++ b/packages/dashboard/src/__tests__/routes-github.test.ts
@@ -2042,25 +2042,26 @@ describe("POST /tasks/:id/approve-plan", () => {
     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 () => {
+  // FNXC:ReleaseAuthorizationGate 2026-07-09-00:00: the release-authorization gate
+  // and its approve-plan guard were removed. A task still carrying the legacy
+  // awaitingApprovalReason === "release-authorization" (parked by the old gate) must
+  // now approve normally instead of being stranded with a 400 and no exit.
+  it("approves a task carrying the legacy release-authorization hold", async () => {
     const releaseHoldTask = {
       ...FAKE_TASK_DETAIL,
       column: "triage" as const,
       status: "awaiting-approval" as const,
       awaitingApprovalReason: "release-authorization" as const,
     };
+    const movedTask = { ...FAKE_TASK_DETAIL, column: "todo" as const };
     (store.getTask as ReturnType<typeof vi.fn>).mockResolvedValue(releaseHoldTask);
+    (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(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();
+    expect(res.status).toBe(200);
+    expect(store.moveTask).toHaveBeenCalledWith("FN-001", "todo");
   });
 
   // Passthrough: an ordinary manual-approval hold (no awaitingApprovalReason)
@@ -2202,24 +2203,24 @@ describe("POST /tasks/:id/reject-plan", () => {
     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 () => {
+  // FNXC:ReleaseAuthorizationGate 2026-07-09-00:00: with the gate removed, a task
+  // still carrying the legacy release-authorization hold must reject normally rather
+  // than returning 400 — the old reject-plan guard was removed alongside the gate.
+  it("rejects a task carrying the legacy release-authorization hold", async () => {
     const releaseHoldTask = {
       ...FAKE_TASK_DETAIL,
       column: "triage" as const,
       status: "awaiting-approval" as const,
       awaitingApprovalReason: "release-authorization" as const,
     };
+    const updatedTask = { ...FAKE_TASK_DETAIL, column: "triage" as const, status: undefined };
     (store.getTask as ReturnType<typeof vi.fn>).mockResolvedValue(releaseHoldTask);
+    (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(400);
-    expect(res.body.error).toContain("release authorization");
-    expect(res.body.error).toContain("Release Authorized By User");
-    expect(store.updateTask).not.toHaveBeenCalled();
+    expect(res.status).toBe(200);
+    expect(store.updateTask).toHaveBeenCalledWith("FN-001", { status: undefined, approvedPlanFingerprint: null });
   });
 
   // Passthrough: an ordinary manual-approval hold (no awaitingApprovalReason)
diff --git a/packages/dashboard/src/routes/register-task-workflow-routes.ts b/packages/dashboard/src/routes/register-task-workflow-routes.ts
index 84d99b8be8..3bdae6eece 100644
--- a/packages/dashboard/src/routes/register-task-workflow-routes.ts
+++ b/packages/dashboard/src/routes/register-task-workflow-routes.ts
@@ -3280,19 +3280,11 @@ 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.",
-        );
-      }
+      // FNXC:ReleaseAuthorizationGate 2026-07-09-00:00:
+      // The triage release-authorization gate was removed (it over-fired and stranded
+      // ordinary tasks). The approve-plan guard that refused any task carrying the legacy
+      // awaitingApprovalReason === "release-authorization" is gone too, so tasks parked by
+      // the old gate can now be approved normally instead of staying stuck with no exit.
 
       // Log the approval
       await scopedStore.logEntry(task.id, "Plan approved by user");
@@ -3348,16 +3340,9 @@ 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.",
-        );
-      }
+      // FNXC:ReleaseAuthorizationGate 2026-07-09-00:00:
+      // Release-authorization gate removed — see the approve-plan handler above. A task
+      // carrying the legacy release-authorization hold can now be rejected normally.
 
       // Log the rejection
       await scopedStore.logEntry(task.id, "Plan rejected by user", "Specification will be regenerated");
diff --git a/packages/engine/src/__tests__/triage-release-authorization.test.ts b/packages/engine/src/__tests__/triage-release-authorization.test.ts
deleted file mode 100644
index 8e43a08b23..0000000000
--- a/packages/engine/src/__tests__/triage-release-authorization.test.ts
+++ /dev/null
@@ -1,233 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  classifyReleaseTask,
-  evaluateReleaseAuthorizationGate,
-  isUserAuthoredSource,
-  parseReleaseAuthorizationMarker,
-  stripNegatedReleaseClauses,
-} from "../triage-release-authorization.js";
-
-const releasePrompt = `# Task: FN-6469 - Release @runfusion/fusion patch
-
-## Mission
-Publish @runfusion/fusion to npm using the release process.
-
-## Steps
-- Run pnpm release --yes
-- Verify scripts/release.mjs completed
-`;
-
-const marker = "**Release Authorized By User:** yes";
-
-describe("triage release authorization gate", () => {
-  it("blocks the FN-6469 incident shape before auto-dispatch", () => {
-    const decision = evaluateReleaseAuthorizationGate({
-      sourceType: "agent_heartbeat",
-      title: "Release @runfusion/fusion patch",
-      description: "Release the package",
-      promptText: releasePrompt,
-    });
-
-    expect(decision.action).toBe("block");
-    expect(decision.isReleaseClass).toBe(true);
-    expect(decision.signals).toContain("pnpm release");
-  });
-
-  it("blocks agent-authored release tasks even when PROMPT.md contains the marker", () => {
-    const decision = evaluateReleaseAuthorizationGate({
-      sourceType: "agent_heartbeat",
-      title: "Release @runfusion/fusion patch",
-      promptText: `${releasePrompt}\n${marker}\n`,
-    });
-
-    expect(decision.action).toBe("block");
-    expect(decision.reason).toMatch(/non-user-authored source/);
-  });
-
-  it("allows user-authored dashboard release tasks with the marker", () => {
-    expect(evaluateReleaseAuthorizationGate({
-      sourceType: "dashboard_ui",
-      title: "Release @runfusion/fusion patch",
-      promptText: `${releasePrompt}\n${marker}\n`,
-    }).action).toBe("allow");
-  });
-
-  it("allows user-authored CLI release tasks with the marker", () => {
-    expect(evaluateReleaseAuthorizationGate({
-      sourceType: "cli",
-      title: "Release @runfusion/fusion patch",
-      promptText: `${releasePrompt}\n  **Release Authorized By User:** YES  \n`,
-    }).action).toBe("allow");
-  });
-
-  it("blocks user-authored release tasks without the marker", () => {
-    const decision = evaluateReleaseAuthorizationGate({
-      sourceType: "quick_chat",
-      title: "Release @runfusion/fusion patch",
-      promptText: releasePrompt,
-    });
-
-    expect(decision.action).toBe("block");
-    expect(decision.reason).toMatch(/missing/);
-  });
-
-  it("blocks api-sourced release tasks even when the marker is present", () => {
-    const decision = evaluateReleaseAuthorizationGate({
-      sourceType: "api",
-      title: "Release @runfusion/fusion patch",
-      promptText: `${releasePrompt}\n${marker}\n`,
-    });
-
-    expect(decision.action).toBe("block");
-    expect(decision.reason).toMatch(/non-user-authored source 'api'/);
-  });
-
-  it("blocks derived/internal release tasks even when the marker is present", () => {
-    for (const sourceType of ["task_refine", "github_import"] as const) {
-      expect(evaluateReleaseAuthorizationGate({
-        sourceType,
-        title: "Release @runfusion/fusion patch",
-        promptText: `${releasePrompt}\n${marker}\n`,
-      }).action).toBe("block");
-    }
-  });
-
-  it("allows non-release tasks without changing dispatch behavior", () => {
-    const decision = evaluateReleaseAuthorizationGate({
-      sourceType: "agent_heartbeat",
-      title: "Fix dashboard layout bug",
-      description: "Adjust CSS for the task card footer.",
-      promptText: "## Mission\nFix a dashboard layout bug without publishing anything.",
-    });
-
-    expect(decision.action).toBe("allow");
-    expect(decision.isReleaseClass).toBe(false);
-    expect(decision.signals).toEqual([]);
-  });
-
-  it("classifies all documented release signal surfaces", () => {
-    const cases = [
-      ["pnpm release --yes", "pnpm release"],
-      ["node scripts/release.mjs --yes", "scripts/release.mjs"],
-      ["pnpm changeset publish", "changeset publish"],
-      ["npm publish ./dist for @runfusion/fusion", "npm publish @runfusion/fusion"],
-      ["pnpm publish @runfusion/fusion", "pnpm publish @runfusion/fusion"],
-      ["publish the package to npm", "publish to npm"],
-      ["git tag v1.2.3", "git tag v<semver>"],
-      ["create a version bump release commit for v1.2.3", "version-bump release commit"],
-    ] as const;
-
-    for (const [promptText, expectedSignal] of cases) {
-      const classification = classifyReleaseTask({ promptText });
-      expect(classification.isReleaseClass, promptText).toBe(true);
-      expect(classification.signals, promptText).toContain(expectedSignal);
-    }
-  });
-
-  /*
-   * 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");
-    expect(parseReleaseAuthorizationMarker("")).toBe(false);
-  });
-
-  it("only treats the four explicit user-authored source types as user authored", () => {
-    const userAuthored = ["dashboard_ui", "quick_chat", "chat_session", "cli"];
-    const nonUserAuthored = [
-      "agent_heartbeat",
-      "automation",
-      "cron",
-      "workflow_step",
-      "recovery",
-      "research",
-      "unknown",
-      "github_import",
-      "task_refine",
-      "task_duplicate",
-      "api",
-      undefined,
-      null,
-      "future_source",
-    ];
-
-    for (const sourceType of userAuthored) {
-      expect(isUserAuthoredSource(sourceType), sourceType).toBe(true);
-    }
-    for (const sourceType of nonUserAuthored) {
-      expect(isUserAuthoredSource(sourceType), String(sourceType)).toBe(false);
-    }
-  });
-});
diff --git a/packages/engine/src/__tests__/triage.test.ts b/packages/engine/src/__tests__/triage.test.ts
index 9224c2fa3a..481bbb7f44 100644
--- a/packages/engine/src/__tests__/triage.test.ts
+++ b/packages/engine/src/__tests__/triage.test.ts
@@ -2768,15 +2768,15 @@ describe("requirePlanApproval setting", () => {
   });
 
   /*
-   * FNXC:PlanApproval 2026-07-04-12:28:
-   * FN-7526 — auto-approve-all must NOT bypass the independent release-authorization
-   * gate. Both gates set status: "awaiting-approval", so this asserts the release
-   * gate's own activity/log evidence (recordActivity type
-   * "task:release-authorization-required", distinct log copy) fires instead of the
-   * ordinary manual-approval log line, proving the release gate — not the manual
-   * gate — is what parked the task.
+   * FNXC:ReleaseAuthorizationGate 2026-07-09-00:00:
+   * The triage release-authorization gate was removed (it over-fired on AI-authored
+   * specs that merely mention release tooling and stranded ordinary tasks in
+   * awaiting-approval). A release-class spec now flows through triage like any other
+   * task; releases are kept out of Fusion by agent instruction, not an engine gate.
+   * Two former gate regression tests (release-class parks under auto-approve-all;
+   * release-vs-manual awaitingApprovalReason distinction) were deleted with it.
    */
-  it("release-authorization gate still parks a release-class task even when auto-approve-all is on", async () => {
+  it("does not park a release-class task in awaiting-approval when auto-approve-all is on", async () => {
     const task = createTriageTask({
       id: "FN-RELEASE",
       title: "Release @runfusion/fusion patch",
@@ -2798,74 +2798,8 @@ describe("requirePlanApproval setting", () => {
       { requirePlanApproval: false, planApprovalMode: "auto-approve-all" } as Settings,
     );
 
-    /*
-     * 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(
-      "FN-RELEASE",
-      "Release authorization required — leaving task in triage awaiting release authorization",
-      expect.any(String),
-    );
-  });
-
-  /*
-   * 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 });
+    expect(store.updateTask).not.toHaveBeenCalledWith("FN-RELEASE", expect.objectContaining({ awaitingApprovalReason: "release-authorization" }));
+    expect(recordActivity).not.toHaveBeenCalledWith(expect.objectContaining({ type: "task:release-authorization-required" }));
   });
 
   /*
diff --git a/packages/engine/src/triage-release-authorization.ts b/packages/engine/src/triage-release-authorization.ts
deleted file mode 100644
index c7e98307f8..0000000000
--- a/packages/engine/src/triage-release-authorization.ts
+++ /dev/null
@@ -1,135 +0,0 @@
-/*
-FNXC:ReleaseAuthorizationGate 2026-06-15-02:41:
-FN-6481 closes the FN-6469 policy gap: release-class triage specs must not auto-dispatch unless the task was created from a user-authored surface and its PROMPT.md carries an explicit user authorization marker.
-Agents and automation can write PROMPT.md, so the marker is ignored for every non-user SourceType; unknown or future source values fail closed by being treated as non-user-authored.
-*/
-
-const USER_AUTHORED_SOURCE_TYPES = new Set(["dashboard_ui", "quick_chat", "chat_session", "cli"]);
-
-export interface ReleaseTaskClassificationInput {
-  title?: string;
-  description?: string;
-  promptText?: string;
-}
-
-export interface ReleaseTaskClassification {
-  isReleaseClass: boolean;
-  signals: string[];
-}
-
-export interface ReleaseAuthorizationGateInput extends ReleaseTaskClassificationInput {
-  sourceType: string | null | undefined;
-}
-
-export interface ReleaseAuthorizationGateDecision extends ReleaseTaskClassification {
-  action: "allow" | "block";
-  reason: string;
-}
-
-interface ReleaseSignalPattern {
-  label: string;
-  pattern: RegExp;
-}
-
-const RELEASE_SIGNAL_PATTERNS: ReleaseSignalPattern[] = [
-  { label: "pnpm release", pattern: /\bpnpm\s+release\b/i },
-  { label: "scripts/release.mjs", pattern: /(?:^|[^\w.-])scripts\/release\.mjs\b/i },
-  { label: "changeset publish", pattern: /\b(?:pnpm\s+)?changeset\s+publish\b/i },
-  { label: "npm publish @runfusion/fusion", pattern: /\bnpm\s+publish\b[\s\S]{0,240}@runfusion\/fusion\b|@runfusion\/fusion\b[\s\S]{0,240}\bnpm\s+publish\b/i },
-  { label: "pnpm publish @runfusion/fusion", pattern: /\bpnpm\s+publish\b[\s\S]{0,240}@runfusion\/fusion\b|@runfusion\/fusion\b[\s\S]{0,240}\bpnpm\s+publish\b/i },
-  { label: "publish to npm", pattern: /\bpublish\b[\s\S]{0,160}\b(?:to|on)\s+npm\b|\bnpm\b[\s\S]{0,160}\bpublish\b/i },
-  { label: "git tag v<semver>", pattern: /\b(?:git\s+)?tag\s+v\d+\.\d+\.\d+(?:[-+][0-9a-z.-]+)?\b/i },
-  { 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 rawText = [input.title, input.description, input.promptText]
-    .filter((value): value is string => typeof value === "string" && value.length > 0)
-    .join("\n\n");
-
-  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)) {
-      signals.push(label);
-    }
-  }
-
-  return { isReleaseClass: signals.length > 0, signals };
-}
-
-export function parseReleaseAuthorizationMarker(promptText: string): boolean {
-  return /^\s*\*\*Release Authorized By User:\*\*\s*yes\s*$/im.test(promptText);
-}
-
-export function evaluateReleaseAuthorizationGate(input: ReleaseAuthorizationGateInput): ReleaseAuthorizationGateDecision {
-  const classification = classifyReleaseTask(input);
-  if (!classification.isReleaseClass) {
-    return {
-      action: "allow",
-      ...classification,
-      reason: "Task does not contain release/publish intent signals.",
-    };
-  }
-
-  const userAuthored = isUserAuthoredSource(input.sourceType);
-  const hasMarker = parseReleaseAuthorizationMarker(input.promptText ?? "");
-  if (userAuthored && hasMarker) {
-    return {
-      action: "allow",
-      ...classification,
-      reason: "Release-class task was created from a user-authored source and includes an explicit user authorization marker.",
-    };
-  }
-
-  const sourceLabel = input.sourceType ?? "unknown";
-  return {
-    action: "block",
-    ...classification,
-    reason: userAuthored
-      ? `Release-class task from user-authored source '${sourceLabel}' is missing **Release Authorized By User:** yes.`
-      : `Release-class task from non-user-authored source '${sourceLabel}' requires operator review; PROMPT.md markers are ignored for this source.`,
-  };
-}
diff --git a/packages/engine/src/triage.ts b/packages/engine/src/triage.ts
index 7341ba7aa3..b82ef1fae2 100644
--- a/packages/engine/src/triage.ts
+++ b/packages/engine/src/triage.ts
@@ -139,7 +139,6 @@ import {
   isResearchToolSurfaceEnabled,
 } from "./tool-availability.js";
 import { runGhostBugPreflight } from "./triage-preflight.js";
-import { evaluateReleaseAuthorizationGate } from "./triage-release-authorization.js";
 import { archiveAsGhostBug } from "./self-healing.js";
 import { createRunAuditor, generateSyntheticRunId } from "./run-audit.js";
 import { resolveAndEmitGoalContext } from "./goal-injection-diagnostics.js";
@@ -2513,63 +2512,10 @@ export class TriageProcessor {
       planLog.warn(`${task.id}: failed to re-read task before planning transition (${message}); proceeding with original task snapshot`);
       latestTransitionTask = task;
     }
-    try {
-      /**
-       * FNXC:ReleaseAuthorizationGate 2026-06-15-02:47:
-       * FN-6469 showed that agent-authored release specs can otherwise flow from triage directly to execution and publish npm packages. FN-6481 parks release-class tasks before every final triage dispatch branch unless a user-authored source supplied the explicit authorization marker.
-       */
-      const releaseGateDecision = evaluateReleaseAuthorizationGate({
-        sourceType: latestTransitionTask?.sourceType ?? task.sourceType,
-        title: latestTransitionTask?.title ?? task.title ?? "",
-        description: latestTransitionTask?.description ?? task.description ?? "",
-        promptText: written,
-      });
-      if (releaseGateDecision.action === "block") {
-        /*
-         * 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;
-        }
-        const signals = releaseGateDecision.signals.length > 0
-          ? releaseGateDecision.signals.join(", ")
-          : "release intent";
-        const details = `${releaseGateDecision.reason} Matched signals: ${signals}.`;
-        await this.store.updateTask(task.id, approvalUpdates);
-        await this.store.logEntry(
-          task.id,
-          "Release authorization required — leaving task in triage awaiting release authorization",
-          details,
-        );
-        try {
-          await this.store.recordActivity({
-            type: "task:release-authorization-required",
-            taskId: task.id,
-            taskTitle: promptDeclaredTitle ?? latestTransitionTask?.title ?? task.title ?? "",
-            details,
-            metadata: {
-              reason: releaseGateDecision.reason,
-              signals: releaseGateDecision.signals,
-              sourceType: latestTransitionTask?.sourceType ?? task.sourceType ?? "unknown",
-            },
-          });
-        } catch (activityError: unknown) {
-          const message = activityError instanceof Error ? activityError.message : String(activityError);
-          planLog.warn(`${task.id}: failed to record release-authorization-required activity (${message})`);
-        }
-        planLog.log(`${task.id} release authorization required — leaving in triage awaiting release authorization (${signals})`);
-        return;
-      }
-    } catch (error: unknown) {
-      const message = error instanceof Error ? error.message : String(error);
-      planLog.warn(`${task.id}: release-authorization gate failed open: ${message}`);
-    }
-
+    /*
+    FNXC:ReleaseAuthorizationGate 2026-07-09-00:00:
+    Removed the triage release-authorization gate (FN-6481/FN-6469). It over-fired: AI-authored specs routinely mention release tooling (`scripts/release.mjs`, `pnpm release`) in disclaimers and file-scope notes, and every non-user source made the in-band authorization marker inert, so ordinary revert/UI/refactor tasks were stranded in awaiting-approval with no exit (see FN-7560, FN-7525, FN-7554, FN-7556). Releases are now kept out of Fusion by agent instruction (AGENTS.md → "Releasing") instead of an engine gate: agents must never run `pnpm release`/publish from inside a Fusion task.
+    */
     if (latestTransitionTask?.paused === true || latestTransitionTask?.userPaused === true) {
       const restoreStatus = options.isReplan ? "needs-replan" : null;
       await this.store.updateTask(task.id, { status: restoreStatus });