@nextclaw/ui 0.26.5 → 0.27.1

package/src/features/chat/features/workspace/components/session-cron-job-content.tsx

@@ -1,3 +1,5 @@
+import { ACTION_FEEDBACK, ACTION_MENU_ITEM_CLASS } from '@/shared/components/ui/actions/action-feedback';
+import { Trash2 } from 'lucide-react';
 import { useState } from "react";
 import {
   CalendarClock,
@@ -9,9 +11,11 @@ import {
 } from "lucide-react";
 
 import {
-  CronJobDetailDialog,
   useCronJobActions,
 } from "@/features/cron";
+import { useAppPresenter } from "@/app/components/app-presenter-provider";
+import { useNavigate } from "react-router-dom";
+import { pageResourceFromSystemObject } from "@/features/right-panel-resources";
 import type { CronJobView } from "@/shared/lib/api";
 import { Button } from "@/shared/components/ui/button";
 import {
@@ -181,7 +185,7 @@ function SessionCronJobCard({
               </TooltipTrigger>
               <TooltipContent>{t("cronMoreActions")}</TooltipContent>
             </Tooltip>
-            <PopoverContent align="end" sideOffset={4} className="w-40 p-1">
+            <PopoverContent align="end" sideOffset={4} variant="menu">
               <button
                 type="button"
                 disabled={isPending}
@@ -189,9 +193,9 @@ function SessionCronJobCard({
                   setMenuOpen(false);
                   void cronActions.runJob(job);
                 }}
-                className="flex w-full items-center gap-2 rounded-lg px-3 py-2 text-sm text-foreground transition-colors hover:bg-[var(--interaction-hover)] disabled:cursor-not-allowed disabled:opacity-50"
+                className={`${ACTION_MENU_ITEM_CLASS} text-foreground ${ACTION_FEEDBACK.item}`}
               >
-                <Play className="h-3.5 w-3.5 text-muted-foreground" />
+                <Play className="h-4 w-4 shrink-0 text-muted-foreground" />
                 {t("cronRunNow")}
               </button>
               <button
@@ -201,8 +205,9 @@ function SessionCronJobCard({
                   setMenuOpen(false);
                   void cronActions.deleteJob(job);
                 }}
-                className="flex w-full items-center gap-2 rounded-lg px-3 py-2 text-sm text-red-600 transition-colors hover:bg-destructive/10 disabled:cursor-not-allowed disabled:opacity-50"
+                className={`${ACTION_MENU_ITEM_CLASS} ${ACTION_FEEDBACK.destructive}`}
               >
+                <Trash2 className="h-4 w-4 shrink-0" />
                 {t("delete")}
               </button>
             </PopoverContent>
@@ -224,9 +229,9 @@ export function SessionCronJobContent({
   readonly isLoading?: boolean;
   readonly onRetry?: () => void;
 }) {
-  const [selectedJobId, setSelectedJobId] = useState<string | null>(null);
+  const app = useAppPresenter();
+  const navigate = useNavigate();
   const cronActions = useCronJobActions();
-  const selectedJob = jobs.find((job) => job.id === selectedJobId) ?? null;
 
   return (
     <div className="h-full overflow-y-auto custom-scrollbar px-4 py-4">
@@ -268,29 +273,11 @@ export function SessionCronJobContent({
               key={job.id}
               cronActions={cronActions}
               job={job}
-              onOpenDetails={(item) => setSelectedJobId(item.id)}
+              onOpenDetails={(item) => app.pageResourceManager.open(pageResourceFromSystemObject("cron-job", item.id, item.name || item.id), "default", navigate)}
             />
           ))}
         </div>
       )}
-      <CronJobDetailDialog
-        job={selectedJob}
-        open={Boolean(selectedJob)}
-        onOpenChange={(open) => {
-          if (!open) {
-            setSelectedJobId(null);
-          }
-        }}
-        onDelete={(job) => {
-          void cronActions.deleteJob(job, () => setSelectedJobId(null));
-        }}
-        onRun={(job) => {
-          void cronActions.runJob(job);
-        }}
-        onToggle={(job, enabled) => {
-          void cronActions.toggleJob(job, enabled);
-        }}
-      />
       <cronActions.ConfirmDialog />
     </div>
   );

package/src/features/chat/index.ts

@@ -39,3 +39,4 @@ export { ChatSessionWorkspaceFilePreview } from './features/workspace/components
 export { createWorkspaceFileTab, createWorkspaceFileViewerTab } from './features/workspace/utils/chat-workspace-file-tab.utils';
 export { WORKSPACE_FILE_PANEL_KIND, resolveFileResourceTarget, createWorkspaceFilePanelTarget, readWorkspaceFilePanelView } from './features/workspace/utils/workspace-file-panel-route.utils';
 export { resolveAlternateWorkspaceFileViewer } from './features/workspace/utils/chat-workspace-file-viewer.utils';
+export { WORKSPACE_TEXT_EXCERPT_MAX_CHARACTERS, type WorkspaceTextExcerpt } from './features/workspace/utils/workspace-text-excerpt.utils';

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(