diff --git a/frontend/src/app/dashboard/component/user/user-workflow/user-workflow.component.html b/frontend/src/app/dashboard/component/user/user-workflow/user-workflow.component.html
index 492efc53766..d945a21d36e 100644
--- a/frontend/src/app/dashboard/component/user/user-workflow/user-workflow.component.html
+++ b/frontend/src/app/dashboard/component/user/user-workflow/user-workflow.component.html
@@ -51,6 +51,20 @@ <h2 class="page-title">Workflows</h2>
               nzTheme="outline"></i>
           </button>
         </nz-upload>
+        <button
+          *ngIf="pythonNotebookMigrationEnabled"
+          [disabled]="accessLevel === 'READ'"
+          nz-button
+          (click)="openAiGenerateModal()"
+          title="AI generate a workflow from a Python notebook"
+          nz-tooltip="AI generate a workflow from a Python notebook"
+          nzTooltipPlacement="bottom"
+          type="button">
+          <i
+            nz-icon
+            nzType="robot"
+            nzTheme="outline"></i>
+        </button>
         <button
           *ngIf="multiWorkflowsOperationButtonEnabled()"
           (click)="toggleSelection()"
diff --git a/frontend/src/app/dashboard/component/user/user-workflow/user-workflow.component.spec.ts b/frontend/src/app/dashboard/component/user/user-workflow/user-workflow.component.spec.ts
index 7b71ead98c8..d7d96b4dc87 100644
--- a/frontend/src/app/dashboard/component/user/user-workflow/user-workflow.component.spec.ts
+++ b/frontend/src/app/dashboard/component/user/user-workflow/user-workflow.component.spec.ts
@@ -67,12 +67,17 @@ import { StubSearchService } from "../../../service/user/stub-search.service";
 import { SearchResultsComponent } from "../search-results/search-results.component";
 import { delay, firstValueFrom, of, throwError } from "rxjs";
 import JSZip from "jszip";
-import { NzModalService } from "ng-zorro-antd/modal";
+import { ModalOptions, NzModalRef, NzModalService } from "ng-zorro-antd/modal";
 import { NzButtonModule } from "ng-zorro-antd/button";
 import { DownloadService } from "../../../service/user/download/download.service";
 import { commonTestProviders } from "../../../../common/testing/test-utils";
 import { Router } from "@angular/router";
 import { USER_WORKSPACE } from "../../../../app-routing.constant";
+import { GuiConfigService } from "../../../../common/service/gui-config.service";
+import { MockGuiConfigService } from "../../../../common/service/gui-config.service.mock";
+import { NotebookMigrationService } from "../../../../workspace/service/notebook-migration/notebook-migration.service";
+import { NotebookImportModalComponent } from "../../../../workspace/component/notebook-import-modal/notebook-import-modal.component";
+import { NzUploadFile } from "ng-zorro-antd/upload";
 import type { Mocked } from "vitest";
 describe("SavedWorkflowSectionComponent", () => {
   let component: UserWorkflowComponent;
@@ -340,6 +345,157 @@ describe("SavedWorkflowSectionComponent", () => {
     });
   });
 
+  describe("AI generate workflow (dashboard entry point)", () => {
+    const ipynbFile = { name: "analysis.ipynb" } as NzUploadFile;
+    const AI_BUTTON_SELECTOR = 'button[title="AI generate a workflow from a Python notebook"]';
+
+    // Opens the modal and returns the requestImport callback the component handed to it; calling
+    // it drives the create-new-workflow decision (true => close modal, false => keep it open).
+    function getRequestImport(): (file: NzUploadFile, model: string) => Promise<boolean> {
+      const modalService = TestBed.inject(NzModalService);
+      const createSpy = vi.spyOn(modalService, "create").mockReturnValue({} as unknown as NzModalRef);
+      component.openAiGenerateModal();
+      const config = createSpy.mock.calls[0][0] as ModalOptions;
+      return (config.nzData as { requestImport: (file: NzUploadFile, model: string) => Promise<boolean> })
+        .requestImport;
+    }
+
+    it("openAiGenerateModal opens the NotebookImportModalComponent with a requestImport callback and no footer", () => {
+      const modalService = TestBed.inject(NzModalService);
+      const createSpy = vi.spyOn(modalService, "create").mockReturnValue({} as unknown as NzModalRef);
+
+      component.openAiGenerateModal();
+
+      expect(createSpy).toHaveBeenCalledTimes(1);
+      const config = createSpy.mock.calls[0][0] as ModalOptions;
+      expect(config.nzContent).toBe(NotebookImportModalComponent);
+      expect(config.nzFooter).toBeNull();
+      expect(typeof (config.nzData as { requestImport: unknown }).requestImport).toBe("function");
+    });
+
+    it("creates a new workflow, stashes the notebook handoff for its wid, navigates, and resolves true", async () => {
+      const router = TestBed.inject(Router);
+      const navigateSpy = vi.spyOn(router, "navigate").mockResolvedValue(true);
+      const persist = TestBed.inject(WorkflowPersistService) as any;
+      persist.createWorkflow = vi.fn().mockReturnValue(of({ workflow: { wid: 99 } }));
+      const setPendingSpy = vi.spyOn(TestBed.inject(NotebookMigrationService), "setPendingGeneration");
+      component.pid = undefined;
+
+      const proceed = await getRequestImport()(ipynbFile, "gpt-4");
+
+      expect(persist.createWorkflow).toHaveBeenCalledTimes(1);
+      // The workspace picks up this handoff keyed by the newly created wid.
+      expect(setPendingSpy).toHaveBeenCalledWith(ipynbFile, "gpt-4", 99);
+      expect(navigateSpy).toHaveBeenCalledWith([USER_WORKSPACE, 99]);
+      expect(proceed).toBe(true);
+    });
+
+    it("resolves false, clears the handoff, and errors when navigation is blocked", async () => {
+      const router = TestBed.inject(Router);
+      const navigateSpy = vi.spyOn(router, "navigate").mockResolvedValue(false);
+      const persist = TestBed.inject(WorkflowPersistService) as any;
+      persist.createWorkflow = vi.fn().mockReturnValue(of({ workflow: { wid: 99 } }));
+      const migration = TestBed.inject(NotebookMigrationService);
+      const setPendingSpy = vi.spyOn(migration, "setPendingGeneration");
+      const consumeSpy = vi.spyOn(migration, "consumePendingGeneration");
+      const errorSpy = vi.spyOn(TestBed.inject(NotificationService), "error").mockImplementation(() => {});
+      component.pid = undefined;
+
+      const proceed = await getRequestImport()(ipynbFile, "gpt-4");
+
+      expect(setPendingSpy).toHaveBeenCalledWith(ipynbFile, "gpt-4", 99);
+      expect(navigateSpy).toHaveBeenCalledWith([USER_WORKSPACE, 99]);
+      // The stranded handoff is cleared and the failure is surfaced; the modal stays open (false).
+      expect(consumeSpy).toHaveBeenCalledWith(99);
+      expect(errorSpy).toHaveBeenCalledWith("Could not open a new workflow.");
+      expect(proceed).toBe(false);
+    });
+
+    it("rejects a non-ipynb file: errors, resolves false, and creates nothing", async () => {
+      const persist = TestBed.inject(WorkflowPersistService) as any;
+      persist.createWorkflow = vi.fn();
+      const setPendingSpy = vi.spyOn(TestBed.inject(NotebookMigrationService), "setPendingGeneration");
+      const errorSpy = vi.spyOn(TestBed.inject(NotificationService), "error").mockImplementation(() => {});
+
+      const proceed = await getRequestImport()({ name: "data.txt" } as NzUploadFile, "gpt-4");
+
+      // Resolving false keeps the modal open with the selection preserved; nothing was created.
+      expect(proceed).toBe(false);
+      expect(errorSpy).toHaveBeenCalledWith("Please upload a valid Jupyter Notebook (.ipynb) file.");
+      expect(persist.createWorkflow).not.toHaveBeenCalled();
+      expect(setPendingSpy).not.toHaveBeenCalled();
+    });
+
+    it("shows the button only when the migration flag is enabled", () => {
+      // The default mock config has the flag off, so the button is absent.
+      expect(fixture.nativeElement.querySelector(AI_BUTTON_SELECTOR)).toBeNull();
+
+      (TestBed.inject(GuiConfigService) as unknown as MockGuiConfigService).setConfig({
+        pythonNotebookMigrationEnabled: true,
+      });
+      fixture.detectChanges();
+
+      expect(fixture.nativeElement.querySelector(AI_BUTTON_SELECTOR)).not.toBeNull();
+    });
+
+    it("clicking the toolbar button opens the AI generate modal", () => {
+      (TestBed.inject(GuiConfigService) as unknown as MockGuiConfigService).setConfig({
+        pythonNotebookMigrationEnabled: true,
+      });
+      fixture.detectChanges();
+      const openSpy = vi.spyOn(component, "openAiGenerateModal").mockImplementation(() => {});
+
+      const button = fixture.nativeElement.querySelector(AI_BUTTON_SELECTOR) as HTMLButtonElement;
+      button.click();
+
+      expect(openSpy).toHaveBeenCalled();
+    });
+
+    it("adds the new workflow to the current project when opened inside one, then navigates", async () => {
+      const router = TestBed.inject(Router);
+      const navigateSpy = vi.spyOn(router, "navigate").mockResolvedValue(true);
+      const persist = TestBed.inject(WorkflowPersistService) as any;
+      persist.createWorkflow = vi.fn().mockReturnValue(of({ workflow: { wid: 99 } }));
+      const projectService = TestBed.inject(UserProjectService) as any;
+      const addSpy = vi.spyOn(projectService, "addWorkflowToProject").mockReturnValue(of(undefined));
+      vi.spyOn(TestBed.inject(NotebookMigrationService), "setPendingGeneration").mockImplementation(() => {});
+      component.pid = 5;
+
+      const proceed = await getRequestImport()(ipynbFile, "gpt-4");
+
+      expect(addSpy).toHaveBeenCalledWith(5, 99);
+      expect(navigateSpy).toHaveBeenCalledWith([USER_WORKSPACE, 99]);
+      expect(proceed).toBe(true);
+    });
+
+    it("errors and resolves false when creation returns no wid, stashing nothing", async () => {
+      const persist = TestBed.inject(WorkflowPersistService) as any;
+      // A created workflow with no wid trips the guard, which throws into the same failure path.
+      persist.createWorkflow = vi.fn().mockReturnValue(of({ workflow: {} }));
+      const setPendingSpy = vi.spyOn(TestBed.inject(NotebookMigrationService), "setPendingGeneration");
+      const errorSpy = vi.spyOn(TestBed.inject(NotificationService), "error").mockImplementation(() => {});
+
+      const proceed = await getRequestImport()(ipynbFile, "gpt-4");
+
+      expect(proceed).toBe(false);
+      expect(errorSpy).toHaveBeenCalledWith("Workflow creation failed");
+      expect(setPendingSpy).not.toHaveBeenCalled();
+    });
+
+    it("errors and resolves false when workflow creation fails, stashing nothing", async () => {
+      const persist = TestBed.inject(WorkflowPersistService) as any;
+      persist.createWorkflow = vi.fn().mockReturnValue(throwError(() => new Error("boom")));
+      const setPendingSpy = vi.spyOn(TestBed.inject(NotebookMigrationService), "setPendingGeneration");
+      const errorSpy = vi.spyOn(TestBed.inject(NotificationService), "error").mockImplementation(() => {});
+
+      const proceed = await getRequestImport()(ipynbFile, "gpt-4");
+
+      expect(proceed).toBe(false);
+      expect(errorSpy).toHaveBeenCalledWith("Workflow creation failed");
+      expect(setPendingSpy).not.toHaveBeenCalled();
+    });
+  });
+
   it("downloads checked files", async () => {
     // If multiple workflows in a single batch download have name conflicts, rename them as workflow-1, workflow-2, etc.
     component.searchResultsComponent.entries = component.searchResultsComponent.entries.concat(
diff --git a/frontend/src/app/dashboard/component/user/user-workflow/user-workflow.component.ts b/frontend/src/app/dashboard/component/user/user-workflow/user-workflow.component.ts
index 0c5149eab9f..7b1178e9adc 100644
--- a/frontend/src/app/dashboard/component/user/user-workflow/user-workflow.component.ts
+++ b/frontend/src/app/dashboard/component/user/user-workflow/user-workflow.component.ts
@@ -46,6 +46,11 @@ import { DashboardWorkflow } from "../../../type/dashboard-workflow.interface";
 import { DownloadService } from "../../../service/user/download/download.service";
 import { USER_WORKSPACE } from "../../../../app-routing.constant";
 import { GuiConfigService } from "../../../../common/service/gui-config.service";
+import { NotebookMigrationService } from "../../../../workspace/service/notebook-migration/notebook-migration.service";
+import {
+  NotebookImportModalComponent,
+  NotebookImportModalData,
+} from "../../../../workspace/component/notebook-import-modal/notebook-import-modal.component";
 import { NzCardComponent } from "ng-zorro-antd/card";
 import { NzSpaceCompactItemDirective, NzSpaceCompactComponent } from "ng-zorro-antd/space";
 import { NzButtonComponent } from "ng-zorro-antd/button";
@@ -157,7 +162,8 @@ export class UserWorkflowComponent implements AfterViewInit {
     private router: Router,
     private downloadService: DownloadService,
     private searchService: SearchService,
-    private config: GuiConfigService
+    private config: GuiConfigService,
+    private notebookMigrationService: NotebookMigrationService
   ) {
     this.userService
       .userChanged()
@@ -312,6 +318,92 @@ export class UserWorkflowComponent implements AfterViewInit {
       });
   }
 
+  public get pythonNotebookMigrationEnabled(): boolean {
+    return this.config.env.pythonNotebookMigrationEnabled;
+  }
+
+  /**
+   * Open the AI-generate import modal from the dashboard. This is the same modal the canvas
+   * toolbar uses (notebook upload and model selection); it hands the selection back through the
+   * requestImport callback. Unlike the canvas entry point there is no open workflow to overwrite,
+   * so the callback always creates and opens a new workflow.
+   */
+  public openAiGenerateModal(): void {
+    this.modalService.create<NotebookImportModalComponent, NotebookImportModalData>({
+      nzTitle: "AI Generate Workflow from Python Notebook",
+      nzContent: NotebookImportModalComponent,
+      nzWidth: 700,
+      nzFooter: null,
+      nzCentered: true,
+      nzData: {
+        requestImport: (file, model) => this.startAiGeneratedWorkflow(file, model),
+        // The dashboard always creates a new workflow, so there is nothing to overwrite.
+        showOverwriteWarning: false,
+      },
+    });
+  }
+
+  /**
+   * Create the new workflow the generation will fill, record the notebook file and model for the
+   * workspace to pick up, and navigate to the new workflow. The workspace menu consumes the
+   * handoff once the workflow loads and runs the shared generation pipeline (generate, auto
+   * layout, open the Jupyter panel). Resolves true so the modal closes, or false (leaving the
+   * modal open with the selection intact) when the file is not a notebook or creation fails.
+   */
+  private startAiGeneratedWorkflow(file: NzUploadFile, model: string): Promise<boolean> {
+    // Reject a non-notebook file before creating anything, so we never leave an empty workflow
+    // behind on a no-op import. The workspace pipeline validates the extension again downstream.
+    const fileExtension = file.name.split(".").pop()?.toLowerCase();
+    if (fileExtension !== "ipynb") {
+      this.notificationService.error("Please upload a valid Jupyter Notebook (.ipynb) file.");
+      return Promise.resolve(false);
+    }
+    const emptyWorkflowContent: WorkflowContent = {
+      operators: [],
+      commentBoxes: [],
+      links: [],
+      operatorPositions: {},
+      settings: {
+        dataTransferBatchSize: this.config.env.defaultDataTransferBatchSize,
+        executionMode: this.config.env.defaultExecutionMode,
+      },
+    };
+    const localPid = this.pid;
+    return firstValueFrom(
+      this.workflowPersistService.createWorkflow(emptyWorkflowContent, DEFAULT_WORKFLOW_NAME).pipe(
+        tap(createdWorkflow => {
+          if (!createdWorkflow.workflow.wid) {
+            throw new Error("Workflow creation failed.");
+          }
+        }),
+        mergeMap(createdWorkflow => {
+          const wid = createdWorkflow.workflow.wid!;
+          // Mirror the create-workflow path: add to the current project when inside one.
+          if (localPid) {
+            return this.userProjectService.addWorkflowToProject(localPid, wid).pipe(map(() => wid));
+          }
+          return of(wid);
+        }),
+        untilDestroyed(this)
+      )
+    )
+      .then(wid => {
+        this.notebookMigrationService.setPendingGeneration(file, model, wid);
+        return this.router.navigate([USER_WORKSPACE, wid]).then(navigated => {
+          if (!navigated) {
+            // Navigation was blocked or cancelled: clear the stranded handoff and surface an error
+            this.notebookMigrationService.consumePendingGeneration(wid);
+            this.notificationService.error("Could not open a new workflow.");
+          }
+          return navigated;
+        });
+      })
+      .catch(() => {
+        this.notificationService.error("Workflow creation failed");
+        return false;
+      });
+  }
+
   /**
    * duplicate the current workflow. A new record will appear in frontend
    * workflow list and backend database.
diff --git a/frontend/src/app/workspace/component/menu/menu.component.spec.ts b/frontend/src/app/workspace/component/menu/menu.component.spec.ts
index f35cea2ac12..6553c9a3053 100644
--- a/frontend/src/app/workspace/component/menu/menu.component.spec.ts
+++ b/frontend/src/app/workspace/component/menu/menu.component.spec.ts
@@ -1312,4 +1312,67 @@ describe("MenuComponent", () => {
       expect(persistSpy).not.toHaveBeenCalled();
     });
   });
+
+  // The dashboard AI-generate entry point creates the workflow, stashes the notebook file and
+  // model in NotebookMigrationService, and navigates here. Once this workflow becomes modifiable
+  // (loaded), the menu consumes the handoff and runs the same import pipeline the toolbar uses.
+  describe("dashboard-deferred generation trigger", () => {
+    let notebookMigrationService: NotebookMigrationService;
+
+    beforeEach(() => {
+      notebookMigrationService = TestBed.inject(NotebookMigrationService);
+      (TestBed.inject(GuiConfigService) as unknown as MockGuiConfigService).setConfig({
+        pythonNotebookMigrationEnabled: true,
+      });
+    });
+
+    it("runs onClickImportNotebook when a pending generation matches the loaded workflow's wid", () => {
+      const file = { name: "x.ipynb" } as NzUploadFile;
+      vi.spyOn(workflowActionService, "getWorkflowModificationEnabledStream").mockReturnValue(of(true));
+      vi.spyOn(workflowActionService, "getWorkflowMetadata").mockReturnValue({ wid: 7 } as any);
+      const consumeSpy = vi
+        .spyOn(notebookMigrationService, "consumePendingGeneration")
+        .mockReturnValue({ file, model: "gpt-4" });
+      const importSpy = vi.spyOn(component, "onClickImportNotebook").mockReturnValue(false);
+
+      (component as any).registerWorkflowModifiableChangedHandler();
+
+      expect(consumeSpy).toHaveBeenCalledWith(7);
+      expect(importSpy).toHaveBeenCalledWith(file, "gpt-4");
+    });
+
+    it("does nothing when there is no pending generation for the loaded workflow", () => {
+      vi.spyOn(workflowActionService, "getWorkflowModificationEnabledStream").mockReturnValue(of(true));
+      vi.spyOn(workflowActionService, "getWorkflowMetadata").mockReturnValue({ wid: 7 } as any);
+      vi.spyOn(notebookMigrationService, "consumePendingGeneration").mockReturnValue(null);
+      const importSpy = vi.spyOn(component, "onClickImportNotebook").mockReturnValue(false);
+
+      (component as any).registerWorkflowModifiableChangedHandler();
+
+      expect(importSpy).not.toHaveBeenCalled();
+    });
+
+    it("does not consume the handoff when the loaded workflow has no wid", () => {
+      vi.spyOn(workflowActionService, "getWorkflowModificationEnabledStream").mockReturnValue(of(true));
+      vi.spyOn(workflowActionService, "getWorkflowMetadata").mockReturnValue({ wid: undefined } as any);
+      const consumeSpy = vi.spyOn(notebookMigrationService, "consumePendingGeneration");
+      const importSpy = vi.spyOn(component, "onClickImportNotebook").mockReturnValue(false);
+
+      (component as any).registerWorkflowModifiableChangedHandler();
+
+      expect(consumeSpy).not.toHaveBeenCalled();
+      expect(importSpy).not.toHaveBeenCalled();
+    });
+
+    it("does not consume the handoff while the workflow is not yet modifiable", () => {
+      vi.spyOn(workflowActionService, "getWorkflowModificationEnabledStream").mockReturnValue(of(false));
+      const consumeSpy = vi.spyOn(notebookMigrationService, "consumePendingGeneration");
+      const importSpy = vi.spyOn(component, "onClickImportNotebook").mockReturnValue(false);
+
+      (component as any).registerWorkflowModifiableChangedHandler();
+
+      expect(consumeSpy).not.toHaveBeenCalled();
+      expect(importSpy).not.toHaveBeenCalled();
+    });
+  });
 });
diff --git a/frontend/src/app/workspace/component/menu/menu.component.ts b/frontend/src/app/workspace/component/menu/menu.component.ts
index 8930d9d0bba..2818204ac85 100644
--- a/frontend/src/app/workspace/component/menu/menu.component.ts
+++ b/frontend/src/app/workspace/component/menu/menu.component.ts
@@ -999,7 +999,22 @@ export class MenuComponent implements OnInit, OnDestroy {
     this.workflowActionService
       .getWorkflowModificationEnabledStream()
       .pipe(untilDestroyed(this))
-      .subscribe(modifiable => (this.isWorkflowModifiable = modifiable));
+      .subscribe(modifiable => {
+        this.isWorkflowModifiable = modifiable;
+        // A generation started from the workflow dashboard has no canvas to run on, so the
+        // dashboard defers it here: once this freshly created workflow is loaded and editable,
+        // pick up the handoff and run the same pipeline the toolbar button uses. consumePending-
+        // Generation guards by wid and clears on consume, so this fires once for its workflow.
+        if (modifiable && this.pythonNotebookMigrationEnabled) {
+          const wid = this.workflowActionService.getWorkflowMetadata().wid;
+          if (wid !== undefined) {
+            const pending = this.notebookMigrationService.consumePendingGeneration(wid);
+            if (pending) {
+              this.onClickImportNotebook(pending.file, pending.model);
+            }
+          }
+        }
+      });
   }
 
   private registerWorkflowIdUpdateHandler(): void {
diff --git a/frontend/src/app/workspace/component/notebook-import-modal/notebook-import-modal.component.html b/frontend/src/app/workspace/component/notebook-import-modal/notebook-import-modal.component.html
index 4e6a3d60378..2e104129cae 100644
--- a/frontend/src/app/workspace/component/notebook-import-modal/notebook-import-modal.component.html
+++ b/frontend/src/app/workspace/component/notebook-import-modal/notebook-import-modal.component.html
@@ -30,6 +30,7 @@
   </div>
 
   <nz-alert
+    *ngIf="showOverwriteWarning"
     class="import-modal-warning"
     nzType="warning"
     nzShowIcon
diff --git a/frontend/src/app/workspace/component/notebook-import-modal/notebook-import-modal.component.spec.ts b/frontend/src/app/workspace/component/notebook-import-modal/notebook-import-modal.component.spec.ts
index eb6d199bd17..209ecf292c9 100644
--- a/frontend/src/app/workspace/component/notebook-import-modal/notebook-import-modal.component.spec.ts
+++ b/frontend/src/app/workspace/component/notebook-import-modal/notebook-import-modal.component.spec.ts
@@ -37,12 +37,13 @@ describe("NotebookImportModalComponent", () => {
   let requestImport: ReturnType<typeof vi.fn>;
 
   // Configures the modal with the given models$ stream, then creates and renders it.
-  async function createWith(models$: unknown): Promise<void> {
+  // extraData is merged into NZ_MODAL_DATA so tests can supply flags like showOverwriteWarning.
+  async function createWith(models$: unknown, extraData: Record<string, unknown> = {}): Promise<void> {
     await TestBed.configureTestingModule({
       imports: [NotebookImportModalComponent, HttpClientTestingModule, NoopAnimationsModule],
       providers: [
         { provide: NzModalRef, useValue: modalRef },
-        { provide: NZ_MODAL_DATA, useValue: { requestImport } },
+        { provide: NZ_MODAL_DATA, useValue: { requestImport, ...extraData } },
         ...commonTestProviders,
       ],
     }).compileComponents();
@@ -69,6 +70,11 @@ describe("NotebookImportModalComponent", () => {
     expect(root.textContent).toContain("Select a model");
   });
 
+  it("hides the overwrite warning when the opener sets showOverwriteWarning false (dashboard entry point)", async () => {
+    await createWith(of([{ name: "gpt-4" }]), { showOverwriteWarning: false });
+    expect((fixture.nativeElement as HTMLElement).querySelector(".import-modal-warning")).toBeNull();
+  });
+
   it("shows the disabled 'no models available' select when the list is empty", async () => {
     await createWith(of([]));
     expect((fixture.nativeElement as HTMLElement).textContent).toContain("No models available");
diff --git a/frontend/src/app/workspace/component/notebook-import-modal/notebook-import-modal.component.ts b/frontend/src/app/workspace/component/notebook-import-modal/notebook-import-modal.component.ts
index 70ee5745d1e..302587d7a4d 100644
--- a/frontend/src/app/workspace/component/notebook-import-modal/notebook-import-modal.component.ts
+++ b/frontend/src/app/workspace/component/notebook-import-modal/notebook-import-modal.component.ts
@@ -36,6 +36,11 @@ import { NotebookMigrationService } from "../../service/notebook-migration/noteb
 // import has started), false to keep it open with the user's selection intact.
 export interface NotebookImportModalData {
   requestImport: (file: NzUploadFile, model: string) => Promise<boolean>;
+  // Whether to show the "generating overwrites your current workflow" warning. Relevant only
+  // when the modal is opened over an existing workflow (the canvas menu). The dashboard entry
+  // point always creates a new workflow, so it sets this false to hide the warning. Defaults to
+  // showing it when unset, keeping the canvas behavior unchanged.
+  showOverwriteWarning?: boolean;
 }
 
 /**
@@ -70,6 +75,11 @@ export class NotebookImportModalComponent {
   private readonly notebookMigrationService = inject(NotebookMigrationService);
   private readonly data: NotebookImportModalData = inject(NZ_MODAL_DATA);
 
+  // Show the overwrite warning unless the opener explicitly turns it off (the dashboard does).
+  public get showOverwriteWarning(): boolean {
+    return this.data.showOverwriteWarning !== false;
+  }
+
   public readonly importForm: FormGroup = this.fb.group({
     file: [null, Validators.required],
     model: ["", Validators.required],
diff --git a/frontend/src/app/workspace/service/notebook-migration/notebook-migration.service.spec.ts b/frontend/src/app/workspace/service/notebook-migration/notebook-migration.service.spec.ts
index 6570e47a00d..573437a1782 100644
--- a/frontend/src/app/workspace/service/notebook-migration/notebook-migration.service.spec.ts
+++ b/frontend/src/app/workspace/service/notebook-migration/notebook-migration.service.spec.ts
@@ -343,4 +343,28 @@ describe("NotebookMigrationService", () => {
       httpMock.expectNone(req => req.url.includes("/notebook-migration/delete-notebook-and-mapping"));
     });
   });
+
+  // pendingGeneration handoff (used by the dashboard AI-generate entry point)
+  describe("pendingGeneration", () => {
+    const file = { name: "analysis.ipynb" } as any;
+
+    it("consumePendingGeneration returns the file and model when the wid matches, then clears", () => {
+      service.setPendingGeneration(file, "gpt-4", 42);
+      expect(service.consumePendingGeneration(42)).toEqual({ file, model: "gpt-4" });
+      // A second consume for the same wid returns null: the slot was cleared.
+      expect(service.consumePendingGeneration(42)).toBeNull();
+    });
+
+    it("consumePendingGeneration returns null for a different wid and clears the slot so a stale handoff can't fire later", () => {
+      service.setPendingGeneration(file, "gpt-4", 42);
+      expect(service.consumePendingGeneration(7)).toBeNull();
+      // The mismatched consume cleared the slot: opening a different workflow drops the stale
+      // handoff, so the original target no longer fires on a later reopen.
+      expect(service.consumePendingGeneration(42)).toBeNull();
+    });
+
+    it("consumePendingGeneration returns null when nothing is pending", () => {
+      expect(service.consumePendingGeneration(1)).toBeNull();
+    });
+  });
 });
diff --git a/frontend/src/app/workspace/service/notebook-migration/notebook-migration.service.ts b/frontend/src/app/workspace/service/notebook-migration/notebook-migration.service.ts
index 3d6600c2a2e..eecb2f27e24 100644
--- a/frontend/src/app/workspace/service/notebook-migration/notebook-migration.service.ts
+++ b/frontend/src/app/workspace/service/notebook-migration/notebook-migration.service.ts
@@ -25,6 +25,7 @@ import { NotificationService } from "src/app/common/service/notification/notific
 import { GuiConfigService } from "../../../common/service/gui-config.service";
 import { WorkflowUtilService } from "../workflow-graph/util/workflow-util.service";
 import { catchError, firstValueFrom, map, Observable, of } from "rxjs";
+import { NzUploadFile } from "ng-zorro-antd/upload";
 
 interface LiteLLMModel {
   id: string;
@@ -60,6 +61,13 @@ interface DeleteNotebookResponse {
 export class NotebookMigrationService {
   private mapping: { [key: string]: MappingContent } = {};
 
+  // Handoff slot for starting an AI-generate flow from the workflow dashboard, where there is no
+  // open canvas to run the generation on. The dashboard creates the new workflow, records the
+  // selected notebook file and model here keyed by that workflow's wid, and navigates to it. The
+  // workspace menu consumes the slot once the matching workflow is loaded and runs the same
+  // generation pipeline the canvas button uses.
+  private pendingGeneration: { file: NzUploadFile; model: string; wid: number } | null = null;
+
   constructor(
     private http: HttpClient,
     private notificationService: NotificationService,
@@ -246,4 +254,23 @@ export class NotebookMigrationService {
   public deleteMapping(id: string): void {
     delete this.mapping[id];
   }
+
+  // Records a notebook file and model to be generated into the given (already created) workflow
+  // once its workspace loads. Used by the dashboard AI-generate entry point.
+  public setPendingGeneration(file: NzUploadFile, model: string, wid: number): void {
+    this.pendingGeneration = { file, model, wid };
+  }
+
+  // Returns the pending generation when it targets the given workflow. Clears the slot on any
+  // call, including a wid mismatch: reaching a different workflow's load proves the user opened
+  // something other than the handoff target, so a handoff that missed its window cannot survive
+  // the session and fire on a later reopen (which would overwrite with no confirm).
+  public consumePendingGeneration(wid: number): { file: NzUploadFile; model: string } | null {
+    const pending = this.pendingGeneration;
+    this.pendingGeneration = null;
+    if (!pending || pending.wid !== wid) {
+      return null;
+    }
+    return { file: pending.file, model: pending.model };
+  }
 }