@nextclaw/ui 0.27.0 → 0.27.2

package/src/features/chat/pages/__tests__/ncp-chat-page.test.ts

@@ -7,7 +7,7 @@ import {
 import type { SessionEntryView, ThinkingLevel } from '@/shared/lib/api';
 import type { ChatModelOption } from '@/features/chat/types/chat-input.types';
 import {
-  resolveRecentSessionPreferredValue,
+  resolveRecentSessionPreferenceSnapshot,
   resolveSelectedModelValue,
   resolveSelectedThinkingLevelValue
 } from '@/features/chat/features/session/utils/chat-session-preference-governance.utils';
@@ -461,50 +461,54 @@ describe('shouldClearPendingProjectRootOverride', () => {
   });
 });
 
-describe('resolveRecentSessionPreferredModel', () => {
-  it('returns the most recent preferred model from the same runtime', () => {
+describe('resolveRecentSessionPreferenceSnapshot', () => {
+  it('returns the model and thinking level from the same recent runtime session', () => {
     const sessions = [
       createSession({
         key: 'native-1',
         sessionType: 'native',
         preferredModel: 'anthropic/claude-sonnet-4',
+        preferredThinking: 'low',
         updatedAt: '2026-03-18T01:00:00.000Z'
       }),
       createSession({
         key: 'codex-1',
         sessionType: 'codex',
         preferredModel: 'openai/gpt-5',
+        preferredThinking: 'high',
         updatedAt: '2026-03-18T03:00:00.000Z'
       }),
       createSession({
         key: 'codex-2',
         sessionType: 'codex',
         preferredModel: 'anthropic/claude-sonnet-4',
+        preferredThinking: 'medium',
         updatedAt: '2026-03-18T02:00:00.000Z'
       })
     ];
 
     expect(
-      resolveRecentSessionPreferredValue<string>({
+      resolveRecentSessionPreferenceSnapshot({
         sessions,
         selectedSessionKey: 'draft',
-        sessionType: 'codex',
-        readPreference: (session) => session.preferredModel?.trim() || undefined
+        sessionType: 'codex'
       })
-    ).toBe('openai/gpt-5');
+    ).toEqual({ model: 'openai/gpt-5', thinking: 'high' });
   });
 
-  it('ignores the currently selected session and sessions without preferred models', () => {
+  it('ignores the current session and does not borrow thinking from an older model', () => {
     const sessions = [
       createSession({
         key: 'codex-current',
         sessionType: 'codex',
         preferredModel: 'openai/gpt-5',
+        preferredThinking: 'high',
         updatedAt: '2026-03-18T03:00:00.000Z'
       }),
       createSession({
-        key: 'codex-empty',
+        key: 'codex-thinking-only',
         sessionType: 'codex',
+        preferredThinking: 'high',
         updatedAt: '2026-03-18T04:00:00.000Z'
       }),
       createSession({
@@ -512,17 +516,37 @@ describe('resolveRecentSessionPreferredModel', () => {
         sessionType: 'codex',
         preferredModel: 'anthropic/claude-sonnet-4',
         updatedAt: '2026-03-18T02:00:00.000Z'
+      }),
+      createSession({
+        key: 'codex-older-thinking',
+        sessionType: 'codex',
+        preferredModel: 'openai/gpt-5',
+        preferredThinking: 'medium',
+        updatedAt: '2026-03-18T01:00:00.000Z'
       })
     ];
 
     expect(
-      resolveRecentSessionPreferredValue<string>({
+      resolveRecentSessionPreferenceSnapshot({
         sessions,
         selectedSessionKey: 'codex-current',
-        sessionType: 'codex',
-        readPreference: (session) => session.preferredModel?.trim() || undefined
+        sessionType: 'codex'
       })
-    ).toBe('anthropic/claude-sonnet-4');
+    ).toEqual({ model: 'anthropic/claude-sonnet-4' });
+  });
+
+  it('returns no fallback when the runtime has no persisted model', () => {
+    expect(
+      resolveRecentSessionPreferenceSnapshot({
+        sessions: [createSession({
+          key: 'codex-thinking-only',
+          sessionType: 'codex',
+          preferredThinking: 'high'
+        })],
+        selectedSessionKey: 'draft',
+        sessionType: 'codex'
+      })
+    ).toBeUndefined();
   });
 });
 
@@ -587,37 +611,3 @@ describe('resolveSelectedThinkingLevelValue', () => {
     ).toBe('medium');
   });
 });
-
-describe('resolveRecentSessionPreferredThinking', () => {
-  it('returns the most recent preferred thinking from the same runtime', () => {
-    const sessions = [
-      createSession({
-        key: 'native-1',
-        sessionType: 'native',
-        preferredThinking: 'low',
-        updatedAt: '2026-03-18T01:00:00.000Z'
-      }),
-      createSession({
-        key: 'codex-1',
-        sessionType: 'codex',
-        preferredThinking: 'high',
-        updatedAt: '2026-03-18T03:00:00.000Z'
-      }),
-      createSession({
-        key: 'codex-2',
-        sessionType: 'codex',
-        preferredThinking: 'medium',
-        updatedAt: '2026-03-18T02:00:00.000Z'
-      })
-    ];
-
-    expect(
-      resolveRecentSessionPreferredValue<ThinkingLevel>({
-        sessions,
-        selectedSessionKey: 'draft',
-        sessionType: 'codex',
-        readPreference: (session) => session.preferredThinking ?? undefined
-      })
-    ).toBe('high');
-  });
-});

package/src/features/chat/pages/ncp-chat-page.tsx

@@ -1,4 +1,4 @@
-import { useParams } from "react-router-dom";
+import { useLocation } from "react-router-dom";
 import {
   ChatPageLayout,
   type ChatPageProps,
@@ -10,9 +10,9 @@ import { useUiShowContentEvent } from "@/features/chat/features/ncp/hooks/use-ui
 
 export function NcpChatPage({ view }: ChatPageProps) {
   const presenter = usePresenter();
-  const { sessionId } = useParams<{ sessionId?: string }>();
+  const { pathname } = useLocation();
   useChatSessionSync({
-    routeSessionKey: parseSessionKeyFromRoute(sessionId),
+    routeSessionKey: parseSessionKeyFromRoute(pathname.startsWith('/chat/') ? pathname.slice('/chat/'.length) : undefined),
     syncRouteSessionSelection: presenter.chatSessionListManager.syncRouteSessionSelection,
   });
   useUiShowContentEvent();

package/src/features/chat/stores/__tests__/chat-composer-draft.store.test.ts

@@ -26,7 +26,73 @@ const EMPTY_DRAFT: ChatComposerDraftSnapshot = {
 describe('chat composer draft store', () => {
   beforeEach(() => {
     window.localStorage.clear();
-    useChatComposerDraftStore.setState({ drafts: {} });
+    useChatComposerDraftStore.setState({ drafts: {}, submissions: {}, recentSubmittedNodes: {} });
+  });
+
+  const submittedNodes = [{ id: 'text-1', type: 'text' as const, text: 'sent text' }];
+  const submission = {
+    envelope: {
+      sessionId: 'session-a',
+      idempotencyKey: 'user-one',
+      message: {
+        id: 'user-one', sessionId: 'session-a', role: 'user' as const,
+        status: 'final' as const, timestamp: '2026-09-24T00:00:00.000Z',
+        parts: [{ type: 'text' as const, text: 'sent text' }],
+      },
+    },
+    composer: { text: 'sent text', nodes: submittedNodes, attachments: [], selectedSkills: [], skillRecords: [] },
+    status: 'sending' as const,
+  };
+
+  it('keeps submitted text out of the draft across late editor updates and acceptance', () => {
+    const store = useChatComposerDraftStore.getState();
+    const key = 'session:session-a';
+    store.updateDraft(key, EMPTY_DRAFT, (draft) => ({ ...draft, ...submission.composer }));
+    store.beginSubmission(key, EMPTY_DRAFT, submission);
+    expect(useChatComposerDraftStore.getState().drafts[key]?.text).toBe('');
+    store.updateDraft(key, EMPTY_DRAFT, (draft) => ({
+      ...draft, nodes: [{ ...submittedNodes[0]!, text: '' }], text: '',
+    }));
+    store.updateDraft(key, EMPTY_DRAFT, (draft) => ({ ...draft, ...submission.composer }));
+    expect(useChatComposerDraftStore.getState().drafts[key]?.text).toBe('');
+    store.acceptSubmission(key, 'user-one');
+    store.updateDraft(key, EMPTY_DRAFT, (draft) => ({ ...draft, ...submission.composer }));
+    expect(useChatComposerDraftStore.getState().drafts[key]?.text).toBe('');
+    store.updateDraft(key, EMPTY_DRAFT, (draft) => ({
+      ...draft, text: 'new input', nodes: [{ ...submittedNodes[0]!, text: 'new input' }],
+    }));
+    expect(useChatComposerDraftStore.getState().drafts[key]?.text).toBe('new input');
+  });
+
+  it('persists an interrupted send separately from the composer draft', async () => {
+    const store = useChatComposerDraftStore.getState();
+    const key = 'session:session-a';
+    store.beginSubmission(key, EMPTY_DRAFT, submission);
+    const persisted = window.localStorage.getItem(STORAGE_KEY)!;
+    useChatComposerDraftStore.setState({ drafts: {}, submissions: {}, recentSubmittedNodes: {} });
+    window.localStorage.setItem(STORAGE_KEY, persisted);
+    await useChatComposerDraftStore.persist.rehydrate();
+    const restored = useChatComposerDraftStore.getState();
+    expect(restored.drafts[key]?.text).toBe('');
+    expect(restored.submissions[key]?.status).toBe('uncertain');
+    expect(restored.submissions[key]?.envelope.message.id).toBe('user-one');
+  });
+
+  it('restores a rejected send only when it cannot overwrite newer input', () => {
+    const store = useChatComposerDraftStore.getState();
+    const key = 'session:session-a';
+    store.beginSubmission(key, EMPTY_DRAFT, submission);
+    store.failSubmission(key, 'user-one', 'rejected', 'rejected');
+    expect(useChatComposerDraftStore.getState().drafts[key]?.text).toBe('sent text');
+    expect(useChatComposerDraftStore.getState().submissions[key]).toBeUndefined();
+
+    store.beginSubmission(key, EMPTY_DRAFT, submission);
+    store.updateDraft(key, EMPTY_DRAFT, (draft) => ({
+      ...draft, text: 'new input', nodes: [{ ...submittedNodes[0]!, text: 'new input' }],
+    }));
+    store.failSubmission(key, 'user-one', 'rejected', 'rejected');
+    expect(useChatComposerDraftStore.getState().drafts[key]?.text).toBe('new input');
+    expect(useChatComposerDraftStore.getState().submissions[key]?.status).toBe('rejected');
   });
 
   it('uses one fixed partition for the uncreated session', () => {

package/src/features/chat/stores/chat-composer-draft.store.ts

@@ -1,11 +1,12 @@
-import type { ChatComposerNode } from '@nextclaw/agent-chat-ui';
-import type { NcpDraftAttachment } from '@nextclaw/ncp-react';
-import { create } from 'zustand';
-import { createJSONStorage, persist } from 'zustand/middleware';
+import type { ChatComposerNode } from "@nextclaw/agent-chat-ui";
+import type { NcpDraftAttachment } from "@nextclaw/ncp-react";
+import type { NcpAgentSendEnvelope } from "@nextclaw/ncp";
+import { create, type StoreApi } from "zustand";
+import { createJSONStorage, persist } from "zustand/middleware";
 
-import type { ThinkingLevel } from '@/shared/lib/api';
+import type { ThinkingLevel } from "@/shared/lib/api";
 
-export const CHAT_NEW_SESSION_DRAFT_KEY = 'new-session';
+export const CHAT_NEW_SESSION_DRAFT_KEY = "new-session";
 
 type ChatComposerDraftSkillSelection = {
   readonly ref: string;
@@ -26,21 +27,57 @@ export type ChatComposerDraftSnapshot = {
   readonly sendError: string | null;
 };
 
+export type ChatComposerSubmission = {
+  readonly envelope: NcpAgentSendEnvelope;
+  readonly composer: Pick<
+    ChatComposerDraftSnapshot,
+    "text" | "nodes" | "selectedSkills" | "skillRecords" | "attachments"
+  >;
+  readonly status: "sending" | "uncertain" | "rejected";
+};
+
 type ChatComposerDraftStore = {
   drafts: Record<string, ChatComposerDraftSnapshot>;
-  ensureDraft: (draftKey: string, initialSnapshot: ChatComposerDraftSnapshot) => void;
+  submissions: Record<string, ChatComposerSubmission>;
+  recentSubmittedNodes: Record<string, string>;
+  ensureDraft: (
+    draftKey: string,
+    initialSnapshot: ChatComposerDraftSnapshot,
+  ) => void;
   updateDraft: (
     draftKey: string,
     initialSnapshot: ChatComposerDraftSnapshot,
-    update: (
-      snapshot: ChatComposerDraftSnapshot,
-    ) => ChatComposerDraftSnapshot,
+    update: (snapshot: ChatComposerDraftSnapshot) => ChatComposerDraftSnapshot,
   ) => void;
+  beginSubmission: (
+    draftKey: string,
+    initialSnapshot: ChatComposerDraftSnapshot,
+    submission: ChatComposerSubmission,
+  ) => void;
+  acceptSubmission: (draftKey: string, messageId: string) => void;
+  failSubmission: (
+    draftKey: string,
+    messageId: string,
+    status: "uncertain" | "rejected",
+    message: string,
+  ) => void;
+  restoreSubmission: (draftKey: string, messageId: string) => void;
+  discardSubmission: (draftKey: string, messageId: string) => void;
 };
 
-const CHAT_COMPOSER_DRAFT_STORAGE_KEY = 'nextclaw.chat.composer-drafts';
+const CHAT_COMPOSER_DRAFT_STORAGE_KEY = "nextclaw.chat.composer-drafts";
 const CHAT_COMPOSER_DRAFT_STORAGE_VERSION = 1;
 
+const isComposerEmpty = (draft: ChatComposerDraftSnapshot): boolean =>
+  draft.attachments.length === 0 &&
+  draft.selectedSkills.length === 0 &&
+  !draft.text.trim();
+
+const restoreComposer = (
+  draft: ChatComposerDraftSnapshot,
+  submission: ChatComposerSubmission,
+): ChatComposerDraftSnapshot => ({ ...draft, ...submission.composer });
+
 export function resolveChatComposerDraftKey(sessionKey: string | null): string {
   const normalizedSessionKey = sessionKey?.trim();
   return normalizedSessionKey
@@ -48,28 +85,180 @@ export function resolveChatComposerDraftKey(sessionKey: string | null): string {
     : CHAT_NEW_SESSION_DRAFT_KEY;
 }
 
+class ChatComposerDraftActions {
+  constructor(
+    private readonly set: StoreApi<ChatComposerDraftStore>["setState"],
+  ) {}
+
+  ensureDraft: ChatComposerDraftStore["ensureDraft"] = (
+    draftKey,
+    initialSnapshot,
+  ) => {
+    this.set((state) =>
+      state.drafts[draftKey]
+        ? state
+        : {
+            drafts: {
+              ...state.drafts,
+              [draftKey]: initialSnapshot,
+            },
+          },
+    );
+  };
+
+  updateDraft: ChatComposerDraftStore["updateDraft"] = (
+    draftKey,
+    initialSnapshot,
+    update,
+  ) => {
+    this.set((state) => {
+      const current = state.drafts[draftKey] ?? initialSnapshot;
+      const next = update(current);
+      const submittedNodes = state.recentSubmittedNodes[draftKey];
+      if (
+        submittedNodes &&
+        isComposerEmpty(current) &&
+        !isComposerEmpty(next) &&
+        JSON.stringify(next.nodes) === submittedNodes
+      ) {
+        return state;
+      }
+      return {
+        drafts: { ...state.drafts, [draftKey]: next },
+        recentSubmittedNodes:
+          submittedNodes && !isComposerEmpty(next)
+            ? Object.fromEntries(
+                Object.entries(state.recentSubmittedNodes).filter(
+                  ([key]) => key !== draftKey,
+                ),
+              )
+            : state.recentSubmittedNodes,
+      };
+    });
+  };
+
+  beginSubmission: ChatComposerDraftStore["beginSubmission"] = (
+    draftKey,
+    initialSnapshot,
+    submission,
+  ) => {
+    this.set((state) => ({
+      drafts: {
+        ...state.drafts,
+        [draftKey]: {
+          ...(state.drafts[draftKey] ?? initialSnapshot),
+          text: "",
+          nodes: [],
+          selectedSkills: [],
+          skillRecords: [],
+          attachments: [],
+          sendError: null,
+        },
+      },
+      submissions: { ...state.submissions, [draftKey]: submission },
+      recentSubmittedNodes: {
+        ...state.recentSubmittedNodes,
+        [draftKey]: JSON.stringify(submission.composer.nodes),
+      },
+    }));
+  };
+
+  acceptSubmission: ChatComposerDraftStore["acceptSubmission"] = (
+    draftKey,
+    messageId,
+  ) => {
+    this.set((state) => {
+      if (state.submissions[draftKey]?.envelope.message.id !== messageId)
+        return state;
+      const submissions = { ...state.submissions };
+      delete submissions[draftKey];
+      return { submissions };
+    });
+  };
+
+  failSubmission: ChatComposerDraftStore["failSubmission"] = (
+    draftKey,
+    messageId,
+    status,
+    message,
+  ) => {
+    this.set((state) => {
+      const submission = state.submissions[draftKey];
+      if (!submission || submission.envelope.message.id !== messageId)
+        return state;
+      const draft = state.drafts[draftKey];
+      if (!draft) return state;
+      const shouldRestore = status === "rejected" && isComposerEmpty(draft);
+      const submissions = { ...state.submissions };
+      if (shouldRestore) delete submissions[draftKey];
+      else submissions[draftKey] = { ...submission, status };
+      const recentSubmittedNodes = { ...state.recentSubmittedNodes };
+      if (shouldRestore) delete recentSubmittedNodes[draftKey];
+      return {
+        submissions,
+        recentSubmittedNodes,
+        drafts: {
+          ...state.drafts,
+          [draftKey]: {
+            ...(shouldRestore ? restoreComposer(draft, submission) : draft),
+            sendError: message,
+          },
+        },
+      };
+    });
+  };
+
+  restoreSubmission: ChatComposerDraftStore["restoreSubmission"] = (
+    draftKey,
+    messageId,
+  ) => {
+    this.set((state) => {
+      const submission = state.submissions[draftKey];
+      const draft = state.drafts[draftKey];
+      if (
+        !submission ||
+        submission.status !== "rejected" ||
+        submission.envelope.message.id !== messageId ||
+        !draft ||
+        !isComposerEmpty(draft)
+      )
+        return state;
+      const submissions = { ...state.submissions };
+      delete submissions[draftKey];
+      const recentSubmittedNodes = { ...state.recentSubmittedNodes };
+      delete recentSubmittedNodes[draftKey];
+      return {
+        submissions,
+        recentSubmittedNodes,
+        drafts: {
+          ...state.drafts,
+          [draftKey]: restoreComposer(draft, submission),
+        },
+      };
+    });
+  };
+
+  discardSubmission: ChatComposerDraftStore["discardSubmission"] = (
+    draftKey,
+    messageId,
+  ) => {
+    this.set((state) => {
+      if (state.submissions[draftKey]?.envelope.message.id !== messageId)
+        return state;
+      const submissions = { ...state.submissions };
+      delete submissions[draftKey];
+      return { submissions };
+    });
+  };
+}
+
 export const useChatComposerDraftStore = create<ChatComposerDraftStore>()(
   persist(
     (set) => ({
       drafts: {},
-      ensureDraft: (draftKey, initialSnapshot) => {
-        set((state) => state.drafts[draftKey]
-          ? state
-          : {
-              drafts: {
-                ...state.drafts,
-                [draftKey]: initialSnapshot,
-              },
-            });
-      },
-      updateDraft: (draftKey, initialSnapshot, update) => {
-        set((state) => ({
-          drafts: {
-            ...state.drafts,
-            [draftKey]: update(state.drafts[draftKey] ?? initialSnapshot),
-          },
-        }));
-      },
+      submissions: {},
+      recentSubmittedNodes: {},
+      ...new ChatComposerDraftActions(set),
     }),
     {
       name: CHAT_COMPOSER_DRAFT_STORAGE_KEY,
@@ -86,6 +275,18 @@ export const useChatComposerDraftStore = create<ChatComposerDraftStore>()(
             },
           ]),
         ),
+        submissions: Object.fromEntries(
+          Object.entries(state.submissions).map(([draftKey, submission]) => [
+            draftKey,
+            {
+              ...submission,
+              status:
+                submission.status === "sending"
+                  ? "uncertain"
+                  : submission.status,
+            },
+          ]),
+        ),
       }),
     },
   ),

package/src/features/cron/components/__tests__/cron-config.test.tsx

@@ -7,8 +7,10 @@ import type { CronJobView } from "@/shared/lib/api";
 import { setLanguage } from "@/shared/lib/i18n";
 import { buildSessionPath } from "@/features/chat";
 import { CronConfig } from "@/features/cron";
+import { CronJobResource } from "@/features/cron/components/cron-job-resource";
 
 const mocks = vi.hoisted(() => ({
+  openResource: vi.fn(),
   confirm: vi.fn(async () => true),
   createSession: vi.fn(),
   deleteJob: vi.fn(),
@@ -26,6 +28,7 @@ const mocks = vi.hoisted(() => ({
     isLoading: false,
   },
 }));
+vi.mock("@/app/components/app-presenter-provider", () => ({ useAppPresenter: () => ({ pageResourceManager: { open: mocks.openResource } }) }));
 
 vi.mock("@/features/chat", async () => {
   const routeUtils = await vi.importActual<{
@@ -275,12 +278,15 @@ describe("CronConfig", () => {
 
   it("exposes the bound session destination from task details", async () => {
     const user = userEvent.setup();
-    renderCronConfig();
+    const view = renderCronConfig();
 
     await user.click(
       screen.getByRole("button", { name: "查看任务详情 Agent 产品雷达" }),
     );
-    expect(screen.getByRole("dialog")).toBeTruthy();
+    expect(mocks.openResource).toHaveBeenCalled();
+    view.unmount();
+    render(<MemoryRouter><CronJobResource jobId="agent-radar" /></MemoryRouter>);
+    expect(screen.getByTestId("cron-job-detail")).toBeTruthy();
     expect(screen.getByText("当前系统只保存最近一次执行快照。")).toBeTruthy();
 
     expect(

package/src/features/cron/components/cron-config.tsx

@@ -11,7 +11,9 @@ import {
 
 import { PageHeader, PageLayout } from "@/app/components/layout/page-layout";
 import { usePresenter } from "@/features/chat";
-import { CronJobDetailDialog } from "@/features/cron/components/cron-job-detail-dialog";
+import { useAppPresenter } from "@/app/components/app-presenter-provider";
+import { useNavigate } from "react-router-dom";
+import { pageResourceFromSystemObject } from "@/features/right-panel-resources";
 import { CronJobRow } from "@/features/cron/components/cron-job-row";
 import {
   CronTaskComposer,
@@ -146,12 +148,13 @@ function CronPagination({
 }
 
 export function CronConfig() {
+  const app = useAppPresenter();
+  const navigate = useNavigate();
   const [composerPrompt, setComposerPrompt] = useState("");
   const [query, setQuery] = useState("");
   const [status, setStatus] = useState<CronListStatus>("all");
   const [page, setPage] = useState(0);
   const [expandedJobId, setExpandedJobId] = useState<string | null>(null);
-  const [selectedJobId, setSelectedJobId] = useState<string | null>(null);
   const deferredQuery = useDeferredValue(query.trim());
   const composerRef = useRef<HTMLInputElement>(null);
   const presenter = usePresenter();
@@ -166,7 +169,6 @@ export function CronConfig() {
   const jobs = cronQuery.data?.jobs ?? [];
   const total = cronQuery.data?.total ?? 0;
   const summary = cronQuery.data?.summary;
-  const selectedJob = jobs.find((job) => job.id === selectedJobId) ?? null;
 
   const startDraftConversation = () => {
     const prompt = composerPrompt.trim();
@@ -185,7 +187,6 @@ export function CronConfig() {
   const handleDelete = (job: CronJobView) => {
     void cronActions.deleteJob(job, () => {
       setExpandedJobId(null);
-      setSelectedJobId(null);
       if (jobs.length === 1 && page > 0) {
         setPage(page - 1);
       }
@@ -333,7 +334,7 @@ export function CronConfig() {
                       expanded={expandedJobId === job.id}
                       job={job}
                       onDelete={handleDelete}
-                      onEdit={(item) => setSelectedJobId(item.id)}
+                      onEdit={(item) => app.pageResourceManager.open(pageResourceFromSystemObject("cron-job", item.id, item.name || item.id), "default", navigate)}
                       onRun={handleRun}
                       onToggleExpanded={handleToggleExpanded}
                       onToggle={handleToggle}
@@ -409,18 +410,6 @@ export function CronConfig() {
         </>
       )}
 
-      <CronJobDetailDialog
-        job={selectedJob}
-        open={Boolean(selectedJob)}
-        onOpenChange={(open) => {
-          if (!open) {
-            setSelectedJobId(null);
-          }
-        }}
-        onDelete={handleDelete}
-        onRun={handleRun}
-        onToggle={handleToggle}
-      />
       <cronActions.ConfirmDialog />
     </PageLayout>
   );