diff --git a/apps/api/src/storage/task-board.test.ts b/apps/api/src/storage/task-board.test.ts
index a86434b4a3..8c021204d6 100644
--- a/apps/api/src/storage/task-board.test.ts
+++ b/apps/api/src/storage/task-board.test.ts
@@ -73,15 +73,6 @@ describe("shouldAdvanceToReview", () => {
     ).toBe(false);
   });
 
-  it("advances a repo-backed task on thread-finish too (backstop for missed PR detection)", () => {
-    expect(
-      shouldAdvanceToReview({
-        status: "in_progress",
-        threads: [thread("completed")],
-      }),
-    ).toBe(true);
-  });
-
   it("only fires from in_progress, not from other lanes", () => {
     for (const status of ["triage", "todo", "in_review", "done"] as const) {
       expect(
diff --git a/apps/api/src/tools/task-board/reports-task-guards.integration.test.ts b/apps/api/src/tools/task-board/reports-task-guards.integration.test.ts
index 51409b778b..c9ea67712f 100644
--- a/apps/api/src/tools/task-board/reports-task-guards.integration.test.ts
+++ b/apps/api/src/tools/task-board/reports-task-guards.integration.test.ts
@@ -153,6 +153,34 @@ describe("reports-task guards", () => {
     expect(cleared.item.repo).toBeNull();
   });
 
+  // The CMS submit-for-review path opens the PR directly (no run), so it links the PR + advances via UPDATE — the only place these two effects happen together off a run.
+  it("links a PR and advances to In Review via UPDATE (CMS submit-for-review)", async () => {
+    const task = await taskBoard.create({
+      organizationId: ORG,
+      title: "cms review",
+      status: "in_progress",
+      by: USER,
+    });
+    const pr = {
+      url: "https://github.com/deco-sites/casaevideo/pull/7",
+      prNumber: 7,
+      repoOwner: "deco-sites",
+      repoName: "casaevideo",
+    };
+    const res = await TASK_BOARD_ITEM_UPDATE.handler(
+      { id: task.id, status: "in_review", linkPr: pr },
+      ctx,
+    );
+    expect(res.item.status).toBe("in_review");
+    expect(
+      (await taskBoard.listPrs(task.id, ORG)).map((p) => p.number),
+    ).toEqual([7]);
+
+    // Idempotent — re-linking the same PR (a retry) does not duplicate.
+    await TASK_BOARD_ITEM_UPDATE.handler({ id: task.id, linkPr: pr }, ctx);
+    expect(await taskBoard.listPrs(task.id, ORG)).toHaveLength(1);
+  });
+
   it("the paywall fires BEFORE the delegation write (no delegated-but-idle task)", async () => {
     const config = {
       enforced: true,
diff --git a/apps/api/src/tools/task-board/update.ts b/apps/api/src/tools/task-board/update.ts
index dfd498cf9b..9162000e1d 100644
--- a/apps/api/src/tools/task-board/update.ts
+++ b/apps/api/src/tools/task-board/update.ts
@@ -127,6 +127,18 @@ export const TASK_BOARD_ITEM_UPDATE = defineTool({
     tagIds: z.array(z.string()).optional(),
     /** Link an existing chat thread to this task (many-to-many, idempotent). */
     linkThreadId: z.string().optional(),
+    /** Associate an opened pull request with this task (idempotent). Used by the
+     *  CMS submit-for-review flow, which opens the PR via a direct API call
+     *  outside any agent run — so the run-based PR hooks never see it. */
+    linkPr: z
+      .object({
+        url: z.string(),
+        prNumber: z.number(),
+        repoOwner: z.string(),
+        repoName: z.string(),
+        connectionId: z.string().nullable().optional(),
+      })
+      .optional(),
   }),
   outputSchema: z.object({ item: TaskBoardItemSchema }),
   handler: async (input, ctx) => {
@@ -167,6 +179,24 @@ export const TASK_BOARD_ITEM_UPDATE = defineTool({
       );
     }
 
+    // Associate a PR opened outside a run (CMS submit-for-review) — org-verify, then idempotent insert.
+    if (input.linkPr) {
+      const target = await ctx.storage.taskBoard.getById(
+        input.id,
+        organizationId,
+      );
+      if (!target) throw new Error(`Task board item not found: ${input.id}`);
+      await ctx.storage.taskBoard.linkPr({
+        taskBoardItemId: input.id,
+        organizationId,
+        url: input.linkPr.url,
+        prNumber: input.linkPr.prNumber,
+        repoOwner: input.linkPr.repoOwner,
+        repoName: input.linkPr.repoName,
+        connectionId: input.linkPr.connectionId ?? null,
+      });
+    }
+
     const hasFieldUpdate =
       input.title !== undefined ||
       input.description !== undefined ||
diff --git a/apps/web/src/components/chat/pills/new-task-dialog.tsx b/apps/web/src/components/chat/pills/new-task-dialog.tsx
new file mode 100644
index 0000000000..3201511682
--- /dev/null
+++ b/apps/web/src/components/chat/pills/new-task-dialog.tsx
@@ -0,0 +1,91 @@
+/**
+ * "New task" entry for the task-based flow (opened from the task pill). Ask what
+ * to do: describe it and the agent runs it on a fresh task, or edit the site by
+ * hand in a new CMS environment. Presentational — the caller owns both actions.
+ */
+
+import { useState } from "react";
+import {
+  Dialog,
+  DialogContent,
+  DialogTitle,
+} from "@decocms/ui/components/dialog.tsx";
+import { Button } from "@decocms/ui/components/button.tsx";
+import { Edit05, Lightning01 } from "@untitledui/icons";
+import { useT } from "@/i18n/use-t.ts";
+
+export function NewTaskDialog({
+  open,
+  onClose,
+  onSubmitPrompt,
+  onEditManually,
+  isSubmitting,
+}: {
+  open: boolean;
+  onClose: () => void;
+  /** Describe → run on the agent. Receives the trimmed prompt. */
+  onSubmitPrompt: (text: string) => void;
+  /** New CMS environment to edit by hand. */
+  onEditManually: () => void;
+  isSubmitting?: boolean;
+}) {
+  const t = useT();
+  const [text, setText] = useState("");
+
+  const submit = () => {
+    const trimmed = text.trim();
+    if (!trimmed) return;
+    onSubmitPrompt(trimmed);
+  };
+
+  return (
+    <Dialog open={open} onOpenChange={(next) => !next && onClose()}>
+      <DialogContent className="flex flex-col gap-6 rounded-2xl p-8 sm:max-w-lg">
+        <DialogTitle className="text-xl font-medium text-foreground">
+          {t("chat.newTask.heading")}
+        </DialogTitle>
+
+        <textarea
+          value={text}
+          onChange={(e) => setText(e.target.value)}
+          onKeyDown={(e) => {
+            // Cmd/Ctrl+Enter submits; a plain Enter keeps adding lines.
+            if (e.key === "Enter" && (e.metaKey || e.ctrlKey)) {
+              e.preventDefault();
+              submit();
+            }
+          }}
+          placeholder={t("chat.newTask.placeholder")}
+          autoFocus
+          rows={5}
+          className="w-full resize-none rounded-xl border border-border bg-background p-4 text-sm text-foreground outline-none transition-colors placeholder:text-foreground/30 focus:border-foreground/30"
+        />
+
+        <Button
+          size="lg"
+          disabled={!text.trim() || isSubmitting}
+          onClick={submit}
+        >
+          <Lightning01 size={16} />
+          {t("chat.newTask.submit")}
+        </Button>
+
+        <div className="flex items-center gap-3 text-sm text-muted-foreground">
+          <span className="h-px flex-1 bg-border" />
+          {t("chat.newTask.orDivider")}
+          <span className="h-px flex-1 bg-border" />
+        </div>
+
+        <Button
+          variant="outline"
+          size="lg"
+          disabled={isSubmitting}
+          onClick={onEditManually}
+        >
+          <Edit05 size={16} />
+          {t("chat.newTask.editManually")}
+        </Button>
+      </DialogContent>
+    </Dialog>
+  );
+}
diff --git a/apps/web/src/components/chat/pills/task-pill.tsx b/apps/web/src/components/chat/pills/task-pill.tsx
new file mode 100644
index 0000000000..786537308a
--- /dev/null
+++ b/apps/web/src/components/chat/pills/task-pill.tsx
@@ -0,0 +1,335 @@
+import { useState } from "react";
+import { Button } from "@decocms/ui/components/button.tsx";
+import {
+  Command,
+  CommandEmpty,
+  CommandGroup,
+  CommandInput,
+  CommandItem,
+  CommandList,
+} from "@decocms/ui/components/command.tsx";
+import {
+  Popover,
+  PopoverContent,
+  PopoverTrigger,
+} from "@decocms/ui/components/popover.tsx";
+import {
+  Tooltip,
+  TooltipContent,
+  TooltipTrigger,
+} from "@decocms/ui/components/tooltip.tsx";
+import { Check, CheckDone01, ChevronDown, Plus } from "@untitledui/icons";
+import { useT } from "@/i18n/use-t.ts";
+import { useThreadActions } from "@/components/chat/store/hooks";
+import {
+  useTaskBoardItemActions,
+  useTaskBoardItems,
+} from "@/hooks/use-task-board-items";
+import {
+  STATUS_CONFIG,
+  STATUSES,
+  statusIconClassName,
+  type TaskBoardItem,
+  type TaskBoardItemStatus,
+  type TaskBoardItemThread,
+} from "@/layouts/task-board/config";
+import { cn } from "@decocms/ui/lib/utils.ts";
+import { useNavigate } from "@tanstack/react-router";
+import { useOptionalChatTask } from "../context";
+import { usePanelActions } from "@/layouts/shell-layout";
+import { useProjectContext, useVirtualMCP } from "@/sdk";
+import { getActiveGithubRepo } from "@/lib/github-repo";
+import {
+  branchUserLabel,
+  generateBranchName,
+} from "@decocms/shared/branch-name";
+import { writeStoredAutosend } from "@/lib/autosend";
+import { authClient } from "@/lib/auth-client";
+import { NewTaskDialog } from "./new-task-dialog";
+
+/**
+ * Task-based flow replacement for the branch picker. The TASK BOARD is the
+ * source of truth: this names the board task you're editing and switches
+ * between your board tasks for this site. Each task's work lives on a linked
+ * thread (its branch/CMS); "New task" creates a board item + a thread on this
+ * repo-bound agent, so the work shows up on the board.
+ *
+ * Rendered only when the `taskBasedFlow` org flag is on (see the branch selector
+ * in workspace-panel-group).
+ */
+export function TaskPill({ virtualMcpId }: { virtualMcpId: string }) {
+  const t = useT();
+  const [open, setOpen] = useState(false);
+  const [newTaskOpen, setNewTaskOpen] = useState(false);
+  const [starting, setStarting] = useState(false);
+  // Which board column the list is filtered to. Defaults to the current task's
+  // column each time the pill opens (see the Popover's onOpenChange).
+  const [statusFilter, setStatusFilter] =
+    useState<TaskBoardItemStatus>("triage");
+  const { items } = useTaskBoardItems();
+  const tb = useTaskBoardItemActions();
+  const { create: createThread } = useThreadActions();
+  const activeTask = useOptionalChatTask()?.activeTask ?? null;
+  const { setTaskId } = usePanelActions();
+  const navigate = useNavigate();
+  const { org, locator } = useProjectContext();
+  const { data: session } = authClient.useSession();
+  const userId = session?.user?.id;
+
+  // A brand-new branch name per task, so every task is isolated. Omitting the
+  // branch on create makes the server REUSE the most-recently-touched branch
+  // from the sandboxMap — which silently lands two tasks on one branch.
+  const freshBranch = () => generateBranchName(branchUserLabel(session?.user));
+
+  // This site's repo as the task's `repo` value (`owner/name`) — the scope. Legacy tasks (pre-repo column) fall back to a linked thread on this agent so they don't vanish.
+  const activeRepo = getActiveGithubRepo(useVirtualMCP(virtualMcpId));
+  const repoSlug = activeRepo ? `${activeRepo.owner}/${activeRepo.name}` : null;
+  const belongsToSite = (item: TaskBoardItem) =>
+    (repoSlug != null && item.repo === repoSlug) ||
+    item.threads.some((th) => th.virtualMcpId === virtualMcpId);
+
+  // The board is org-wide; scope to this site + "yours" (createdBy) client-side.
+  // Most-recently-touched first.
+  const taskItems = items
+    .filter(
+      (item) => (!userId || item.createdBy === userId) && belongsToSite(item),
+    )
+    .sort((a, b) => (a.updatedAt < b.updatedAt ? 1 : -1));
+
+  // Which board task owns the thread currently open (match by linked threadId).
+  const currentItem = activeTask
+    ? items.find((item) =>
+        item.threads.some((th) => th.threadId === activeTask.id),
+      )
+    : undefined;
+
+  // "New chat" is the app's marker for a never-titled thread — surface it as an
+  // untitled TASK, never leaking the chat vocabulary. Falls back to the thread
+  // title only when the current thread isn't a board task yet.
+  const untitled = t("chat.taskPill.untitled");
+  const currentTitle =
+    currentItem?.title ||
+    (activeTask?.title && activeTask.title !== "New chat"
+      ? activeTask.title
+      : untitled);
+  const label = t("chat.taskPill.editing", { task: currentTitle });
+
+  // Open a task's CMS: its first repo-bound (preview-capable) thread, else any
+  // thread with an agent. A task with NO environment yet (created straight on
+  // the board) gets one spun up on this site's agent and linked, so it becomes
+  // editable. Preview shows the thread's branch automatically.
+  const openItem = async (item: TaskBoardItem) => {
+    const th: TaskBoardItemThread | undefined =
+      item.threads.find((x) => x.hasPreview && x.virtualMcpId) ??
+      item.threads.find((x) => x.virtualMcpId);
+    if (th?.virtualMcpId) {
+      setTaskId(th.threadId, th.virtualMcpId, { main: "preview" });
+      return;
+    }
+    if (starting) return;
+    setStarting(true);
+    try {
+      const newId = crypto.randomUUID();
+      await createThread({
+        id: newId,
+        virtual_mcp_id: virtualMcpId,
+        branch: freshBranch(),
+      });
+      await tb.link.mutateAsync({ id: item.id, linkThreadId: newId });
+      setTaskId(newId, virtualMcpId, { main: "preview" });
+    } finally {
+      setStarting(false);
+    }
+  };
+
+  // Describe → a real board task: a fresh thread on THIS repo-bound agent (never
+  // the Super Agent — no assigneeId), a board item, the link between them, and
+  // the autosent prompt so the agent starts working on a new branch.
+  const startFromPrompt = async (prompt: string) => {
+    if (starting) return;
+    setStarting(true);
+    try {
+      const newId = crypto.randomUUID();
+      const tiptapDoc = {
+        type: "doc" as const,
+        content: [
+          { type: "paragraph", content: [{ type: "text", text: prompt }] },
+        ],
+      };
+      writeStoredAutosend(sessionStorage, locator, newId, { tiptapDoc });
+      await createThread({
+        id: newId,
+        virtual_mcp_id: virtualMcpId,
+        branch: freshBranch(),
+      });
+      const firstLine = prompt.split("\n")[0]?.trim() ?? "";
+      const { item } = await tb.create.mutateAsync({
+        title: (firstLine || prompt).slice(0, 120),
+        description: prompt,
+        repo: repoSlug,
+      });
+      await tb.link.mutateAsync({ id: item.id, linkThreadId: newId });
+      setTaskId(newId, virtualMcpId, { main: "preview", autosend: true });
+      setNewTaskOpen(false);
+    } finally {
+      setStarting(false);
+    }
+  };
+
+  // Edit manually → a fresh CMS environment only, NOT a board task (it must not
+  // clutter the board). ALWAYS a new thread on a NEW branch (never reuse a
+  // session — the point is to branch off the current, unpublished work and start
+  // clean). The thread is titled "CMS change" so the pill names it instead of
+  // showing "Untitled task". `sidepanel: 0` forces the chat closed (the
+  // repo-bound agent defaults it open); `cms: 1` opens the CMS editor.
+  const startManualEdit = async () => {
+    if (starting) return;
+    setNewTaskOpen(false);
+    setStarting(true);
+    try {
+      const newId = crypto.randomUUID();
+      const branch = freshBranch();
+      await createThread({
+        id: newId,
+        virtual_mcp_id: virtualMcpId,
+        branch,
+        title: t("chat.newTask.manualEditTitle"),
+      });
+      navigate({
+        to: "/$org/$taskId",
+        params: { org: org.slug, taskId: newId },
+        search: {
+          virtualmcpid: virtualMcpId,
+          main: "preview",
+          sidepanel: 0,
+          cms: 1,
+        },
+      });
+    } finally {
+      setStarting(false);
+    }
+  };
+
+  return (
+    <>
+      <Popover
+        open={open}
+        onOpenChange={(next) => {
+          setOpen(next);
+          // Open focused on the column the current task lives in.
+          if (next) setStatusFilter(currentItem?.status ?? "triage");
+        }}
+      >
+        <Tooltip>
+          <TooltipTrigger asChild>
+            <span className="inline-flex min-w-0 shrink">
+              <PopoverTrigger asChild>
+                <Button
+                  variant="outline"
+                  size="sm"
+                  aria-label={label}
+                  className="shrink min-w-0 max-w-[220px] gap-1.5 text-xs"
+                >
+                  <CheckDone01 className="h-3.5 w-3.5 shrink-0" />
+                  {/* Collapse to icon-only under 768px of panel header — the task
+                    name stays available via the tooltip. */}
+                  <span className="min-w-0 truncate @max-3xl/panel-header:hidden">
+                    {currentTitle}
+                  </span>
+                  <ChevronDown size={12} className="opacity-60 shrink-0" />
+                </Button>
+              </PopoverTrigger>
+            </span>
+          </TooltipTrigger>
+          <TooltipContent>{label}</TooltipContent>
+        </Tooltip>
+        <PopoverContent
+          className="w-[min(420px,calc(100vw-2rem))] p-0"
+          align="start"
+        >
+          <Command>
+            {/* Search + New task beside it. */}
+            <div className="*:data-[slot=command-input-wrapper]:flex-1 *:data-[slot=command-input-wrapper]:border-b-0 flex items-center border-b border-border pr-2">
+              <CommandInput
+                placeholder={t("chat.taskPill.searchPlaceholder")}
+              />
+              <Button
+                variant="outline"
+                size="sm"
+                className="h-7 shrink-0 gap-1"
+                onClick={() => {
+                  setOpen(false);
+                  setNewTaskOpen(true);
+                }}
+              >
+                <Plus size={14} />
+                {t("chat.taskPill.newTask")}
+              </Button>
+            </div>
+            {/* Column filter — defaults to the current task's column on open. */}
+            <div className="flex gap-1 overflow-x-auto border-b border-border px-2 py-1.5">
+              {STATUSES.map((s) => (
+                <button
+                  key={s}
+                  type="button"
+                  onClick={() => setStatusFilter(s)}
+                  className={cn(
+                    "shrink-0 rounded-md px-2 py-1 text-xs font-medium transition-colors",
+                    statusFilter === s
+                      ? "bg-muted text-foreground"
+                      : "text-muted-foreground hover:text-foreground",
+                  )}
+                >
+                  {t(STATUS_CONFIG[s].labelKey)}
+                </button>
+              ))}
+            </div>
+            <CommandList>
+              <CommandEmpty>{t("chat.taskPill.empty")}</CommandEmpty>
+              <CommandGroup>
+                {taskItems
+                  .filter((item) => item.status === statusFilter)
+                  .map((item) => {
+                    const StatusIcon = STATUS_CONFIG[item.status].icon;
+                    return (
+                      <CommandItem
+                        // Include the id so two same-named tasks stay distinct to cmdk.
+                        key={item.id}
+                        value={`${item.title} ${item.id}`}
+                        className="gap-2"
+                        onSelect={() => {
+                          setOpen(false);
+                          if (item.id !== currentItem?.id) void openItem(item);
+                        }}
+                      >
+                        <StatusIcon
+                          size={16}
+                          className={cn("shrink-0", statusIconClassName(item))}
+                        />
+                        <span className="min-w-0 flex-1 truncate">
+                          {item.title || untitled}
+                        </span>
+                        {item.id === currentItem?.id && (
+                          <Check size={14} className="shrink-0" />
+                        )}
+                      </CommandItem>
+                    );
+                  })}
+              </CommandGroup>
+            </CommandList>
+          </Command>
+        </PopoverContent>
+      </Popover>
+
+      <NewTaskDialog
+        // Remount on open so the prompt textarea resets between tasks.
+        key={newTaskOpen ? "new-task-open" : "new-task-closed"}
+        open={newTaskOpen}
+        isSubmitting={starting}
+        onClose={() => setNewTaskOpen(false)}
+        onSubmitPrompt={(text) => void startFromPrompt(text)}
+        onEditManually={startManualEdit}
+      />
+    </>
+  );
+}
diff --git a/apps/web/src/components/sandbox/preview/preview.tsx b/apps/web/src/components/sandbox/preview/preview.tsx
index 13c7362db0..ff11f0ffb9 100644
--- a/apps/web/src/components/sandbox/preview/preview.tsx
+++ b/apps/web/src/components/sandbox/preview/preview.tsx
@@ -1,6 +1,6 @@
 import { sleep } from "@decocms/shared/std";
 import { useState, useRef, useEffect } from "react";
-import { useNavigate } from "@tanstack/react-router";
+import { useNavigate, useSearch } from "@tanstack/react-router";
 import { formatCodeTabId } from "@/layouts/main-panel-tabs/tab-id";
 import { useChatTask } from "@/components/chat/context";
 import { useProjectContext } from "@/sdk";
@@ -495,10 +495,16 @@ export function PreviewContent({ virtualMcpId }: { virtualMcpId: string }) {
   // context (same source as productionUrl above). Off by default (absent /
   // null → false): Preview stays on the site until the user opens the CMS
   // manually, unless an agent opts in to auto-open.
+  // `?cms=1` forces the auto-open too (task-based flow "edit manually" lands
+  // straight in the CMS), OR'd with the per-agent Layout setting.
+  const forceCmsParam =
+    (useSearch({ strict: false }) as { cms?: number }).cms === 1;
   const cmsDefaultOpen =
-    (inset?.entity?.id === virtualMcpId
+    ((inset?.entity?.id === virtualMcpId
       ? inset.entity.metadata?.ui?.layout?.cmsDefaultOpen
-      : null) ?? false;
+      : null) ??
+      false) ||
+    forceCmsParam;
 
   // Fast Preview (opt-in switch in CMS settings): render the draft against
   // `productionUrl` instead of the published site while the sandbox boots.
diff --git a/apps/web/src/components/settings/experimental-settings.tsx b/apps/web/src/components/settings/experimental-settings.tsx
new file mode 100644
index 0000000000..613264e0b3
--- /dev/null
+++ b/apps/web/src/components/settings/experimental-settings.tsx
@@ -0,0 +1,30 @@
+import { Beaker02 } from "@untitledui/icons";
+import {
+  SettingsCard,
+  SettingsSection,
+} from "@/components/settings/settings-section";
+import { FlagToggle } from "@/components/settings/review-settings";
+import { useT } from "@/i18n/use-t.ts";
+
+/**
+ * Experimental org flags — opt-in product previews that are safe to toggle per
+ * org while they're still being built (currently the task-based flow).
+ */
+export function ExperimentalSettings() {
+  const t = useT();
+  return (
+    <SettingsSection
+      title={t("settings.experimental.title")}
+      description={t("settings.experimental.description")}
+    >
+      <SettingsCard>
+        <FlagToggle
+          flag="taskBasedFlow"
+          icon={<Beaker02 size={16} />}
+          titleKey="settings.experimental.taskBasedFlowTitle"
+          descriptionKey="settings.experimental.taskBasedFlowDescription"
+        />
+      </SettingsCard>
+    </SettingsSection>
+  );
+}
diff --git a/apps/web/src/components/settings/review-settings.tsx b/apps/web/src/components/settings/review-settings.tsx
index 5cb3e06c12..beeae7be57 100644
--- a/apps/web/src/components/settings/review-settings.tsx
+++ b/apps/web/src/components/settings/review-settings.tsx
@@ -59,7 +59,7 @@ export function ReviewSettings() {
 }
 
 /** One org flag as a switch. Shared with the other org-settings sections. */
-function FlagToggle({
+export function FlagToggle({
   flag,
   icon,
   titleKey,
diff --git a/apps/web/src/components/thread/github/header-actions.tsx b/apps/web/src/components/thread/github/header-actions.tsx
index f2f566e4e2..fc91edfd19 100644
--- a/apps/web/src/components/thread/github/header-actions.tsx
+++ b/apps/web/src/components/thread/github/header-actions.tsx
@@ -20,6 +20,9 @@ import {
 import { useChatStream } from "../../chat/chat-context.tsx";
 import { useChatTask } from "../../chat/index";
 import { usePanelActions } from "@/layouts/shell-layout";
+import { useTaskBasedFlow } from "@/hooks/use-organization-settings";
+import { useTaskForThread } from "@/hooks/use-task-for-thread";
+import { useTaskBoardItemActions } from "@/hooks/use-task-board-items";
 import { squashMergePullRequest } from "./github-pr-api.ts";
 import { MergeSplitButton } from "./merge-split-button.tsx";
 import { PublishDialog } from "./publish-dialog.tsx";
@@ -108,7 +111,14 @@ export function HeaderActions({ virtualMcpId }: Props) {
   const { org } = useProjectContext();
   const { data: session } = authClient.useSession();
   const vm = useVirtualMCP(virtualMcpId);
-  const { currentBranch: branch, setCurrentTaskBranch } = useChatTask();
+  // Task-based flow hides Git vocabulary: sync (rebase) becomes invisible/auto.
+  const taskBasedFlow = useTaskBasedFlow();
+  const { currentBranch: branch, setCurrentTaskBranch, taskId } = useChatTask();
+  // The board task this thread belongs to — the CMS opens PRs via a direct API
+  // call (outside any run), so the run-based PR hooks never link/advance it. We
+  // do it from here when a PR opens (task-based flow only).
+  const boardTaskId = useTaskForThread(taskId);
+  const taskBoardActions = useTaskBoardItemActions();
   const chat = useChatStream();
   const { openSidePanel } = usePanelActions();
   const [publishOpen, setPublishOpen] = useState(false);
@@ -305,6 +315,7 @@ export function HeaderActions({ virtualMcpId }: Props) {
   // anything a teammate pushed straight to this branch), rebase onto the
   // latest base, push.
   const showSync =
+    !taskBasedFlow &&
     vm?.metadata?.syncButtonEnabled === true &&
     Boolean(githubRepo) &&
     Boolean(githubHeadBranch);
@@ -451,6 +462,22 @@ export function HeaderActions({ virtualMcpId }: Props) {
           }
           openPullRequest={pr?.state === "open" ? pr : null}
           onPullRequestChanged={refreshPrState}
+          onPrOpened={
+            taskBasedFlow && boardTaskId
+              ? (opened) =>
+                  taskBoardActions.update.mutate({
+                    id: boardTaskId,
+                    status: "in_review",
+                    linkPr: {
+                      url: opened.url,
+                      prNumber: opened.number,
+                      repoOwner: githubRepo.owner,
+                      repoName: githubRepo.name,
+                      connectionId: githubRepo.connectionId ?? null,
+                    },
+                  })
+              : undefined
+          }
           onPublished={switchToFreshBranch}
         />
       )}
diff --git a/apps/web/src/components/thread/github/publish-dialog.tsx b/apps/web/src/components/thread/github/publish-dialog.tsx
index 42494f6b2b..54381be93d 100644
--- a/apps/web/src/components/thread/github/publish-dialog.tsx
+++ b/apps/web/src/components/thread/github/publish-dialog.tsx
@@ -95,6 +95,10 @@ export interface PublishDialogProps {
   openPullRequest?: PrSummary | null;
   /** Called after commit/push or PR open/merge so the header can refresh. */
   onPullRequestChanged?: () => void | Promise<void>;
+  /** Called with the freshly opened PR (submit-for-review) so the caller can
+   *  associate it with a task board item — this dialog opens PRs via a direct
+   *  API call, so the run-based PR hooks never see them. */
+  onPrOpened?: (pr: { number: number; url: string }) => void | Promise<void>;
   /** Called after a successful publish (squash-merge to base). */
   onPublished?: () => void | Promise<void>;
 }
@@ -136,6 +140,7 @@ function PublishDialogBody({
   headSha = null,
   openPullRequest = null,
   onPullRequestChanged,
+  onPrOpened,
   onPublished,
 }: PublishDialogProps) {
   const t = useT();
@@ -538,6 +543,7 @@ function PublishDialogBody({
         },
       );
       handleOpenChange(false);
+      await onPrOpened?.({ number: pr.number, url: pr.htmlUrl });
       await onPullRequestChanged?.();
     } catch (error) {
       setSubmitForReviewError(
diff --git a/apps/web/src/components/thread/open-in-board-button.tsx b/apps/web/src/components/thread/open-in-board-button.tsx
index c35e48313d..e916596d77 100644
--- a/apps/web/src/components/thread/open-in-board-button.tsx
+++ b/apps/web/src/components/thread/open-in-board-button.tsx
@@ -8,6 +8,7 @@ import {
 } from "@decocms/ui/components/tooltip.tsx";
 import { useChatTask } from "@/components/chat/chat-context";
 import { useTaskForThread } from "@/hooks/use-task-for-thread";
+import { useTaskBasedFlow } from "@/hooks/use-organization-settings";
 import { useT } from "@/i18n/use-t.ts";
 import { ToolbarIconButton } from "@/components/toolbar-icon-button";
 
@@ -22,8 +23,10 @@ export function OpenInBoardButton() {
   const { taskId } = useChatTask();
   const navigate = useNavigate();
   const boardTaskId = useTaskForThread(taskId);
+  // Task-based flow hides the board surface — the task pill is the entry point.
+  const taskBasedFlow = useTaskBasedFlow();
 
-  if (!boardTaskId) return null;
+  if (taskBasedFlow || !boardTaskId) return null;
 
   return (
     <TooltipProvider>
diff --git a/apps/web/src/hooks/use-organization-settings.ts b/apps/web/src/hooks/use-organization-settings.ts
index 3563fd98b5..07c3754319 100644
--- a/apps/web/src/hooks/use-organization-settings.ts
+++ b/apps/web/src/hooks/use-organization-settings.ts
@@ -240,6 +240,15 @@ export function useReportsOnly(): boolean {
   return useOrgFlag("reports_only");
 }
 
+/**
+ * Task-based flow: the UI operates entirely in terms of Tasks and hides all Git
+ * vocabulary (branches, PRs, merge, sync). Non-blocking read — used for cosmetic
+ * gating where a brief pre-resolution render is harmless.
+ */
+export function useTaskBasedFlow(): boolean {
+  return useOrgFlag("taskBasedFlow");
+}
+
 /**
  * Read one org flag from the `flags` bag (see OrgFlagsSchema in
  * @decocms/shared/organization/schema — the single place flags are defined).
diff --git a/apps/web/src/i18n/en/chat.ts b/apps/web/src/i18n/en/chat.ts
index f97b4463a2..2bbb081201 100644
--- a/apps/web/src/i18n/en/chat.ts
+++ b/apps/web/src/i18n/en/chat.ts
@@ -38,6 +38,17 @@ export const chat = {
   "chat.branchPill.lockedTooltip":
     "This chat is using branch {branch}. Start a new chat to use a different branch.",
   "chat.branchPill.noBranch": "(no branch)",
+  "chat.taskPill.editing": "Editing: {task}",
+  "chat.taskPill.untitled": "Untitled task",
+  "chat.taskPill.searchPlaceholder": "Search your tasks…",
+  "chat.taskPill.empty": "No tasks found.",
+  "chat.taskPill.newTask": "New task",
+  "chat.newTask.heading": "Describe your task",
+  "chat.newTask.placeholder": "Describe what you want to do…",
+  "chat.newTask.submit": "Create task",
+  "chat.newTask.orDivider": "or",
+  "chat.newTask.editManually": "Edit manually",
+  "chat.newTask.manualEditTitle": "CMS change",
   "chat.brandContext.brand": "Brand",
   "chat.brandContext.brandContextSet": "Brand context set",
   "chat.brandContext.brandSet": "Brand set: {name}",
diff --git a/apps/web/src/i18n/en/settings.ts b/apps/web/src/i18n/en/settings.ts
index 5cfe508687..2ecc099ccf 100644
--- a/apps/web/src/i18n/en/settings.ts
+++ b/apps/web/src/i18n/en/settings.ts
@@ -464,6 +464,12 @@ export const settings = {
   "settings.review.autoAssignReportTasksDescription":
     "Tasks created from a report are delegated to the Super Agent automatically instead of landing unassigned.",
   "settings.review.updateError": "Couldn't update the setting",
+  "settings.experimental.title": "Experimental",
+  "settings.experimental.description":
+    "Opt-in previews still under construction. Toggle them per organization to try them out.",
+  "settings.experimental.taskBasedFlowTitle": "Task-based flow",
+  "settings.experimental.taskBasedFlowDescription":
+    "Operate entirely in terms of Tasks and hide Git details (branches, PRs, sync). Every change starts a new Task.",
   "settings.orgRoleDetail.addMember": "Add Member",
   "settings.orgRoleDetail.addMembersToGrantPermissions":
     "Add members to grant them the configured permissions.",
diff --git a/apps/web/src/i18n/pt-br/chat.ts b/apps/web/src/i18n/pt-br/chat.ts
index dbce78e2f3..36242e5906 100644
--- a/apps/web/src/i18n/pt-br/chat.ts
+++ b/apps/web/src/i18n/pt-br/chat.ts
@@ -42,6 +42,17 @@ export const chat = {
   "chat.branchPill.lockedTooltip":
     "Este chat está usando a branch {branch}. Inicie um novo chat para usar uma branch diferente.",
   "chat.branchPill.noBranch": "(sem branch)",
+  "chat.taskPill.editing": "Editando: {task}",
+  "chat.taskPill.untitled": "Task sem título",
+  "chat.taskPill.searchPlaceholder": "Buscar suas tasks…",
+  "chat.taskPill.empty": "Nenhuma task encontrada.",
+  "chat.taskPill.newTask": "Nova task",
+  "chat.newTask.heading": "Descreva sua task",
+  "chat.newTask.placeholder": "Descreva o que você quer fazer…",
+  "chat.newTask.submit": "Criar task",
+  "chat.newTask.orDivider": "ou",
+  "chat.newTask.editManually": "Editar manualmente",
+  "chat.newTask.manualEditTitle": "Alteração de CMS",
   "chat.brandContext.brand": "Marca",
   "chat.brandContext.brandContextSet": "Contexto de marca definido",
   "chat.brandContext.brandSet": "Marca definida: {name}",
diff --git a/apps/web/src/i18n/pt-br/settings.ts b/apps/web/src/i18n/pt-br/settings.ts
index 5bc49a1468..fb329f1ee1 100644
--- a/apps/web/src/i18n/pt-br/settings.ts
+++ b/apps/web/src/i18n/pt-br/settings.ts
@@ -779,4 +779,10 @@ export const settings = {
     "Não foi possível iniciar o checkout: {message}",
   "settings.billing.portalError":
     "Não foi possível abrir o portal de cobrança: {message}",
+  "settings.experimental.title": "Experimental",
+  "settings.experimental.description":
+    "Prévias opcionais ainda em construção. Ligue por organização para experimentar.",
+  "settings.experimental.taskBasedFlowTitle": "Fluxo por tasks",
+  "settings.experimental.taskBasedFlowDescription":
+    "Opere inteiramente em termos de Tasks e esconda os detalhes de Git (branches, PRs, sync). Cada mudança começa uma nova Task.",
 } satisfies Record<keyof typeof settingsEn, string>;
diff --git a/apps/web/src/layouts/agent-shell-layout/workspace-panel-group.tsx b/apps/web/src/layouts/agent-shell-layout/workspace-panel-group.tsx
index 4686b043de..ca01a575a1 100644
--- a/apps/web/src/layouts/agent-shell-layout/workspace-panel-group.tsx
+++ b/apps/web/src/layouts/agent-shell-layout/workspace-panel-group.tsx
@@ -35,6 +35,9 @@ import { CmsTour } from "@/components/cms-tour/cms-tour";
 import { headerLayout } from "./header-layout";
 import { VirtualMcpHeaderInfo } from "@/views/virtual-mcp/header-info";
 import { ChatModeRow } from "@/components/chat/pills/chat-mode-row";
+import { TaskPill } from "@/components/chat/pills/task-pill";
+import { useTaskBasedFlow } from "@/hooks/use-organization-settings";
+import { getActiveGithubRepo } from "@/lib/github-repo";
 import { useOptionalChatTask } from "@/components/chat/context";
 import {
   AgentSwitcherCrumb,
@@ -157,8 +160,21 @@ export function WorkspacePanelGroup({
   // sandbox/preview runs on), shared by chat and preview alike. Renders null for
   // agents without a connected GitHub repo. Reads the branch from the task
   // context (this tree is inside Chat.ActiveTaskProvider).
+  //
+  // Task-based flow hides Git: the branch selector becomes a task selector —
+  // names the task you're on and switches between your tasks (each a branch
+  // under the hood).
+  const taskBasedFlow = useTaskBasedFlow();
   const currentBranch = useOptionalChatTask()?.currentBranch ?? null;
-  const branchSelector = (
+  // Both selectors are only meaningful for repo-bound agents (a site with a
+  // GitHub repo) — mirror ChatModeRow's own null-for-no-repo guard so the task
+  // pill doesn't show on the Super Agent / any repo-less agent.
+  const repoBound = !!getActiveGithubRepo(entity)?.connectionId;
+  const branchSelector = taskBasedFlow ? (
+    repoBound ? (
+      <TaskPill virtualMcpId={virtualMcpId} />
+    ) : null
+  ) : (
     <ChatModeRow virtualMcp={entity} currentBranch={currentBranch} />
   );
 
diff --git a/apps/web/src/router.tsx b/apps/web/src/router.tsx
index c2f9d03fc2..9f39fb75a7 100644
--- a/apps/web/src/router.tsx
+++ b/apps/web/src/router.tsx
@@ -297,6 +297,9 @@ const unifiedChatSearchSchema = z.object({
   tab: z.string().optional(),
   sidepanel: z.union([z.literal("chat"), z.literal(0)]).optional(),
   main: z.union([z.string(), z.literal(0)]).optional(),
+  /** Force the CMS editor open on landing — the task-based flow's "edit
+   *  manually" opens a new site environment straight in the CMS. */
+  cms: z.literal(1).optional(),
   /** Open the Library file-preview overlay over the chat (browse-grammar path
    *  "<volume>/<path…>"). Set by clickable org-file refs in agent messages. */
   preview: z.string().optional(),
diff --git a/apps/web/src/views/settings/org-general.tsx b/apps/web/src/views/settings/org-general.tsx
index 49171711c4..8ed0d0c0ae 100644
--- a/apps/web/src/views/settings/org-general.tsx
+++ b/apps/web/src/views/settings/org-general.tsx
@@ -3,6 +3,7 @@ import { ConnectBanner } from "@/components/connect/connect-banner";
 import { OrganizationForm } from "@/components/settings/organization-form";
 import { MainAgentSettings } from "@/components/settings/main-agent-settings";
 import { ReviewSettings } from "@/components/settings/review-settings";
+import { ExperimentalSettings } from "@/components/settings/experimental-settings";
 import { DomainSettings } from "@/components/settings/domain-settings";
 import { DeleteOrganizationSection } from "@/components/settings/delete-organization-section";
 import { SettingsPage } from "@/components/settings/settings-section";
@@ -20,6 +21,7 @@ export function OrgGeneralPage() {
             <OrganizationForm />
             <MainAgentSettings />
             <ReviewSettings />
+            <ExperimentalSettings />
             <DomainSettings />
             <DeleteOrganizationSection />
           </SettingsPage>
diff --git a/packages/shared/src/organization/schema.ts b/packages/shared/src/organization/schema.ts
index 17425abb4a..35240f2e29 100644
--- a/packages/shared/src/organization/schema.ts
+++ b/packages/shared/src/organization/schema.ts
@@ -161,6 +161,12 @@ export const OrgFlagsSchema = z.object({
     .describe(
       "When a report import creates a task board item without an assignee, delegate it to the Super Agent automatically instead of leaving it unassigned.",
     ),
+  taskBasedFlow: z
+    .boolean()
+    .optional()
+    .describe(
+      "Task-based flow: the UI operates entirely in terms of Tasks and hides all Git vocabulary (branches, PRs, merge, sync, staging/main). Every change is a new Task; branches remain an implementation detail under the hood. Targets non-technical users.",
+    ),
 });
 
 export type OrgFlags = z.infer<typeof OrgFlagsSchema>;
diff --git a/packages/shared/src/tools/tool-io.ts b/packages/shared/src/tools/tool-io.ts
index 958efe3e5e..41b267b556 100644
--- a/packages/shared/src/tools/tool-io.ts
+++ b/packages/shared/src/tools/tool-io.ts
@@ -387,6 +387,15 @@ export interface StudioToolIO {
       sortOrder?: number | undefined;
       tagIds?: string[] | undefined;
       linkThreadId?: string | undefined;
+      linkPr?:
+        | {
+            url: string;
+            prNumber: number;
+            repoOwner: string;
+            repoName: string;
+            connectionId?: string | null | undefined;
+          }
+        | undefined;
     };
     output: {
       item: {