@nextclaw/ui 0.27.0 → 0.27.2

package/src/features/chat/features/conversation/hooks/use-session-conversation-input-state.ts

@@ -1,6 +1,7 @@
 import { useCallback, useEffect, useMemo, type SetStateAction } from 'react';
 import type { ChatComposerNode } from '@nextclaw/agent-chat-ui';
 import type { NcpDraftAttachment } from '@nextclaw/ncp-react';
+import type { NcpAgentSendEnvelope } from '@nextclaw/ncp';
 
 import type { ThinkingLevel } from '@/shared/lib/api';
 import { DEFAULT_SESSION_TYPE } from '@/features/chat/features/session-type/utils/chat-session-type.utils';
@@ -10,6 +11,7 @@ import {
   resolveChatComposerDraftKey,
   useChatComposerDraftStore,
   type ChatComposerDraftSnapshot,
+  type ChatComposerSubmission,
 } from '@/features/chat/stores/chat-composer-draft.store';
 import {
   useSessionConversationPreferenceActions,
@@ -38,6 +40,7 @@ export type SessionConversationInputSnapshot = SessionConversationComposerState
   readonly pendingProjectRoot: string | null;
   readonly composerFocusRequestId: number;
   readonly sendError: string | null;
+  readonly pendingSubmission?: ChatComposerSubmission | null;
 };
 
 type SessionConversationOwnedInputSnapshot = ChatComposerDraftSnapshot;
@@ -49,7 +52,11 @@ export type SessionConversationInputPatch =
 export type SessionConversationInputActions = {
   readonly update: (patch: SessionConversationInputPatch) => void;
   readonly syncComposer: (composer: SessionConversationComposerState) => void;
-  readonly resetComposer: () => void;
+  readonly beginSubmission: (envelope: NcpAgentSendEnvelope, composer: ChatComposerSubmission['composer']) => void;
+  readonly acceptSubmission: (messageId: string) => void;
+  readonly failSubmission: (messageId: string, status: 'uncertain' | 'rejected', message: string) => void;
+  readonly restoreSubmission: (messageId: string) => void;
+  readonly discardSubmission: (messageId: string) => void;
   readonly restoreComposer: (
     composer: SessionConversationComposerState & {
       readonly attachments?: readonly NcpDraftAttachment[];
@@ -176,6 +183,7 @@ function usePersistedConversationInputSnapshot(
   const snapshot = useChatComposerDraftStore(
     (state) => state.drafts[draftKey] ?? initialSnapshot,
   );
+  const pendingSubmission = useChatComposerDraftStore((state) => state.submissions[draftKey] ?? null);
 
   useEffect(() => {
     useChatComposerDraftStore.getState().ensureDraft(draftKey, initialSnapshot);
@@ -196,7 +204,35 @@ function usePersistedConversationInputSnapshot(
     });
   }, [draftKey, initialSnapshot]);
 
-  return { draftKey, snapshot, update };
+  const beginSubmission = useCallback((
+    envelope: NcpAgentSendEnvelope,
+    composer: ChatComposerSubmission['composer'],
+  ) => {
+    useChatComposerDraftStore.getState().beginSubmission(draftKey, snapshot, {
+      envelope, composer, status: 'sending',
+    });
+  }, [draftKey, snapshot]);
+  const acceptSubmission = useCallback((messageId: string) => {
+    useChatComposerDraftStore.getState().acceptSubmission(draftKey, messageId);
+  }, [draftKey]);
+  const failSubmission = useCallback((
+    messageId: string,
+    status: 'uncertain' | 'rejected',
+    message: string,
+  ) => {
+    useChatComposerDraftStore.getState().failSubmission(draftKey, messageId, status, message);
+  }, [draftKey]);
+  const restoreSubmission = useCallback((messageId: string) => {
+    useChatComposerDraftStore.getState().restoreSubmission(draftKey, messageId);
+  }, [draftKey]);
+  const discardSubmission = useCallback((messageId: string) => {
+    useChatComposerDraftStore.getState().discardSubmission(draftKey, messageId);
+  }, [draftKey]);
+
+  return {
+    draftKey, snapshot, pendingSubmission, update,
+    beginSubmission, acceptSubmission, failSubmission, restoreSubmission, discardSubmission,
+  };
 }
 
 export const useSessionConversationInputState = (
@@ -204,7 +240,10 @@ export const useSessionConversationInputState = (
   sessionKey: string | null = null,
 ) => {
   const pendingProjectRoot = useChatThreadStore((state) => state.snapshot.draftProjectRoot);
-  const { draftKey, snapshot, update } = usePersistedConversationInputSnapshot(
+  const {
+    draftKey, snapshot, pendingSubmission, update,
+    beginSubmission, acceptSubmission, failSubmission, restoreSubmission, discardSubmission,
+  } = usePersistedConversationInputSnapshot(
     initialPrompt,
     sessionKey,
   );
@@ -219,14 +258,6 @@ export const useSessionConversationInputState = (
     });
   }, [update]);
 
-  const resetComposer = useCallback(() => {
-    update({
-      ...EMPTY_COMPOSER_STATE,
-      attachments: [],
-      sendError: null,
-    });
-  }, [update]);
-
   const restoreComposer = useCallback((
     composer: SessionConversationComposerState & {
       readonly attachments?: readonly NcpDraftAttachment[];
@@ -309,7 +340,11 @@ export const useSessionConversationInputState = (
   const actions = useMemo<SessionConversationInputActions>(() => ({
     update,
     syncComposer,
-    resetComposer,
+    beginSubmission,
+    acceptSubmission,
+    failSubmission,
+    restoreSubmission,
+    discardSubmission,
     restoreComposer,
     applyPromptSuggestion,
     requestComposerFocusAtEnd,
@@ -325,7 +360,11 @@ export const useSessionConversationInputState = (
   }), [
     update,
     syncComposer,
-    resetComposer,
+    beginSubmission,
+    acceptSubmission,
+    failSubmission,
+    restoreSubmission,
+    discardSubmission,
     restoreComposer,
     applyPromptSuggestion,
     requestComposerFocusAtEnd,
@@ -344,6 +383,7 @@ export const useSessionConversationInputState = (
     inputSnapshot: {
       ...snapshot,
       pendingProjectRoot,
+      pendingSubmission,
     },
     inputActions: actions,
   };

package/src/features/chat/features/conversation/hooks/use-session-submission-recovery.ts

@@ -0,0 +1,83 @@
+import { useCallback, useEffect, useRef } from 'react';
+import type { NcpAgentSendEnvelope, NcpRunHandle } from '@nextclaw/ncp';
+import { NcpHttpSendError } from '@nextclaw/ncp-http-agent-client';
+import { fetchNcpSessionMessages } from '@/shared/lib/api';
+import { t } from '@/shared/lib/i18n';
+import type { ChatComposerSubmission } from '@/features/chat/stores/chat-composer-draft.store';
+
+async function hasAcceptedSubmission(submission: ChatComposerSubmission): Promise<boolean> {
+  const sessionId = submission.envelope.sessionId?.trim();
+  if (!sessionId) return false;
+  try {
+    const response = await fetchNcpSessionMessages(sessionId, { limit: 100 });
+    return response.messages.some((message) => message.id === submission.envelope.message.id);
+  } catch {
+    return false;
+  }
+}
+
+export function useSessionSubmissionRecovery(params: {
+  readonly agent: { send: (envelope: NcpAgentSendEnvelope) => Promise<NcpRunHandle | null> };
+  readonly submission?: ChatComposerSubmission | null;
+  readonly sessionKey: string | null;
+  readonly onSessionMaterialized?: (sessionKey: string) => void;
+  readonly acceptSubmission: (messageId: string) => void;
+  readonly failSubmission: (messageId: string, status: 'uncertain' | 'rejected', message: string) => void;
+  readonly restoreSubmission: (messageId: string) => void;
+  readonly discardSubmission: (messageId: string) => void;
+  readonly setSendError: (message: string | null) => void;
+}) {
+  const {
+    agent, submission, sessionKey, onSessionMaterialized,
+    acceptSubmission, failSubmission, restoreSubmission, discardSubmission, setSendError,
+  } = params;
+  const retryPendingSubmission = useCallback(async () => {
+    if (!submission || submission.status !== 'uncertain') return;
+    const { envelope } = submission;
+    if (await hasAcceptedSubmission(submission)) {
+      acceptSubmission(envelope.message.id);
+      if (!sessionKey && envelope.sessionId) onSessionMaterialized?.(envelope.sessionId);
+      return;
+    }
+    if (!envelope.sessionId) {
+      setSendError(t('chatSendResultUnknownChild'));
+      return;
+    }
+    try {
+      const handle = await agent.send(envelope);
+      if (!handle) throw new Error(t('chatSendFailed'));
+      acceptSubmission(envelope.message.id);
+      if (!sessionKey) onSessionMaterialized?.(handle.sessionId);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      failSubmission(envelope.message.id,
+        error instanceof NcpHttpSendError && error.sendRejected ? 'rejected' : 'uncertain',
+        message);
+    }
+  }, [acceptSubmission, agent, failSubmission, onSessionMaterialized, sessionKey, setSendError, submission]);
+
+  const checkedSubmissionRef = useRef<string | null>(null);
+  useEffect(() => {
+    if (!submission || submission.status !== 'uncertain' ||
+      checkedSubmissionRef.current === submission.envelope.message.id) return;
+    checkedSubmissionRef.current = submission.envelope.message.id;
+    void hasAcceptedSubmission(submission).then((accepted) => {
+      if (accepted) {
+        acceptSubmission(submission.envelope.message.id);
+        if (!sessionKey && submission.envelope.sessionId) {
+          onSessionMaterialized?.(submission.envelope.sessionId);
+        }
+      }
+    });
+  }, [acceptSubmission, onSessionMaterialized, sessionKey, submission]);
+
+  return {
+    retryPendingSubmission,
+    restorePendingSubmission: () => {
+      if (submission) restoreSubmission(submission.envelope.message.id);
+    },
+    discardPendingSubmission: () => {
+      if (submission?.status === 'rejected') discardSubmission(submission.envelope.message.id);
+    },
+  };
+}

package/src/features/chat/features/conversation/types/session-conversation-input.types.ts

@@ -0,0 +1,38 @@
+import type { ChatContextWindowIndicator } from '@nextclaw/agent-chat-ui';
+import type { SessionConversationQueuedInput } from '@/features/chat/features/conversation/hooks/use-session-conversation-controller';
+import type { useSessionConversationInputQuery } from '@/features/chat/features/conversation/hooks/use-session-conversation-input-query';
+import type {
+  SessionConversationInputActions,
+  SessionConversationInputSnapshot,
+} from '@/features/chat/features/conversation/hooks/use-session-conversation-input-state';
+
+export type SessionConversationInputController = {
+  readonly canEditQueuedInput: boolean;
+  readonly canStopGeneration: boolean;
+  readonly deleteQueuedInput: (id: string) => void;
+  readonly editQueuedInput: (id: string) => void;
+  readonly isSending: boolean;
+  readonly queuedInputs: readonly SessionConversationQueuedInput[];
+  readonly primaryAction: 'continue' | 'send';
+  readonly sendDisabled: boolean;
+  readonly stopDisabled: boolean;
+  readonly send: () => Promise<void> | void;
+  readonly sendSteering: () => Promise<void> | void;
+  readonly sendPresetMessage: (message: string) => Promise<void> | void;
+  readonly retryPendingSubmission: () => Promise<void> | void;
+  readonly restorePendingSubmission: () => void;
+  readonly discardPendingSubmission: () => void;
+  readonly stop: () => Promise<void> | void;
+  readonly steerQueuedInput: (id: string) => void;
+};
+
+export type SessionConversationInputProps = {
+  readonly contextWindow: ChatContextWindowIndicator | null;
+  readonly controller: SessionConversationInputController;
+  readonly inputActions: SessionConversationInputActions;
+  readonly inputQuery: ReturnType<typeof useSessionConversationInputQuery>;
+  readonly inputSnapshot: SessionConversationInputSnapshot;
+  readonly onContextCompactingChange?: (sessionId: string, isCompacting: boolean) => void;
+  readonly placeholder?: string;
+  readonly surface?: 'default' | 'embedded';
+};

package/src/features/chat/features/input/utils/__tests__/ncp-chat-input-availability.utils.test.ts

@@ -23,7 +23,7 @@ function createSnapshot(overrides: Partial<AvailabilitySnapshot> = {}): Availabi
 }
 
 describe('ncp-chat-input-availability.utils', () => {
-  it('keeps the composer editable during cold start while runtime blocking still prevents send', () => {
+  it('keeps editing and sending available when runtime readiness is misreported', () => {
     const snapshot = createSnapshot({
       isProviderStateResolved: false,
       modelOptions: [],
@@ -35,25 +35,7 @@ describe('ncp-chat-input-availability.utils', () => {
     expect(isNcpChatComposerDisabled(snapshot)).toBe(false);
     expect(
       isNcpChatSendDisabled({
-        snapshot,
         hasSendableDraft: true,
-        isRuntimeBlocked: true,
-      })
-    ).toBe(true);
-  });
-
-  it('does not block send only because model options have not loaded yet', () => {
-    const snapshot = createSnapshot({
-      isProviderStateResolved: false,
-      modelOptions: [],
-      sessionTypeUnavailable: false,
-    });
-
-    expect(
-      isNcpChatSendDisabled({
-        snapshot,
-        hasSendableDraft: true,
-        isRuntimeBlocked: false,
       })
     ).toBe(false);
   });
@@ -81,25 +63,15 @@ describe('ncp-chat-input-availability.utils', () => {
     expect(isNcpChatComposerDisabled(snapshot)).toBe(false);
     expect(
       isNcpChatSendDisabled({
-        snapshot,
         hasSendableDraft: true,
-        isRuntimeBlocked: false,
       })
     ).toBe(false);
   });
 
   it('blocks send when there is no sendable draft', () => {
-    const snapshot = createSnapshot({
-      isProviderStateResolved: true,
-      modelOptions: [],
-      sessionTypeUnavailable: true,
-    });
-
     expect(
       isNcpChatSendDisabled({
-        snapshot,
         hasSendableDraft: false,
-        isRuntimeBlocked: false,
       })
     ).toBe(true);
   });

package/src/features/chat/features/input/utils/ncp-chat-input-availability.utils.ts

@@ -30,13 +30,6 @@ export function isNcpChatComposerDisabled(
 
 export function isNcpChatSendDisabled(params: {
   hasSendableDraft: boolean;
-  snapshot: ChatInputAvailabilitySnapshot;
-  isRuntimeBlocked: boolean;
 }): boolean {
-  const { hasSendableDraft, isRuntimeBlocked } = params;
-
-  return (
-    isRuntimeBlocked ||
-    !hasSendableDraft
-  );
+  return !params.hasSendableDraft;
 }

package/src/features/chat/features/message/components/__tests__/chat-message-list-skill-preview.container.test.tsx

@@ -23,6 +23,8 @@ function ChatMessageListContainer({
 }
 
 const captures = vi.hoisted(() => ({
+  resolveResource: vi.fn(),
+  openResource: vi.fn(),
   renders: [] as Array<{
     onInlineTokenClick?: (token: unknown) => void;
   }>,
@@ -98,6 +100,8 @@ vi.mock("@/shared/lib/i18n", () => ({
 }));
 
 beforeEach(() => {
+  captures.resolveResource.mockReset();
+  captures.openResource.mockReset();
   captures.renders = [];
   captures.openFilePreview.mockReset();
   captures.fetchSessionSkills.mockReset();
@@ -116,6 +120,15 @@ function clickSkill(token: Record<string, unknown>, sessionKey?: string): void {
   captures.renders[captures.renders.length - 1]?.onInlineTokenClick?.(token);
 }
 
+it("opens a quoted object through the resource opener instead of treating its URI as a local path", () => {
+  const page = { uri: "nextclaw://objects/agent/philosopher" };
+  captures.resolveResource.mockReturnValue(page);
+  clickSkill({ kind: "workspace_excerpt", path: page.uri, excerpt: "Description", label: "Philosopher", startLine: null, endLine: null });
+  expect(captures.resolveResource).toHaveBeenCalledWith(page.uri);
+  expect(captures.openResource).toHaveBeenCalledWith(page, "default", expect.any(Function));
+  expect(captures.openFilePreview).not.toHaveBeenCalled();
+});
+
 it("opens a persisted skill path without consulting the session catalog", () => {
   clickSkill({
     kind: "skill", ref: "global:/skills/review", name: "review", source: "global",
@@ -170,4 +183,4 @@ it("shows an error when a persisted v1 skill is no longer resolvable", async ()
 });
 
 vi.mock("react-router-dom", async (importOriginal) => ({ ...(await importOriginal<object>()), useNavigate: () => vi.fn() }));
-vi.mock("@/app/components/app-presenter-provider", () => ({ useAppPresenter: () => ({ pageResourceManager: { resolve: vi.fn(), open: vi.fn() } }) }));
+vi.mock("@/app/components/app-presenter-provider", () => ({ useAppPresenter: () => ({ pageResourceManager: { resolve: captures.resolveResource, open: captures.openResource } }) }));

package/src/features/chat/features/message/hooks/use-chat-inline-token-actions.ts

@@ -30,8 +30,13 @@ export function useChatInlineTokenActions(params: {
   const projectRoot = selectedSession?.projectRoot ?? selectedSession?.workingDir;
 
   const handleInlineTokenClick = useCallback((token: ChatInlineTokenViewModel) => {
-    if ((token.kind === CHAT_UI_RESOURCE_TOKEN_KIND || token.kind === CHAT_SYSTEM_OBJECT_TOKEN_KIND) && "key" in token) {
-      const page = appPresenter.pageResourceManager.resolve(token.key);
+    const resourceUri = (token.kind === CHAT_UI_RESOURCE_TOKEN_KIND || token.kind === CHAT_SYSTEM_OBJECT_TOKEN_KIND) && "key" in token
+      ? token.key
+      : token.kind === CHAT_WORKSPACE_EXCERPT_TOKEN_KIND && "excerpt" in token && token.path.startsWith("nextclaw://")
+        ? token.path
+        : null;
+    if (resourceUri) {
+      const page = appPresenter.pageResourceManager.resolve(resourceUri);
       if (page) appPresenter.pageResourceManager.open(page, 'default', navigate);
       return;
     }

package/src/features/chat/features/session/utils/__tests__/chat-session-route.utils.test.ts

@@ -1,11 +1,37 @@
 import { describe, expect, it } from 'vitest';
 import {
   CHAT_DRAFT_SESSION_PATH,
+  buildSessionPanelUrl,
+  parseSessionKeyFromPanelUrl,
+  encodeSessionRouteId,
   buildSessionPath,
   parseSessionKeyFromRoute,
 } from '@/features/chat/features/session/utils/chat-session-route.utils';
 
 describe('chat session route utils', () => {
+  it.each(['ncp-mu2x4zdy-9wzl0otb', 'agent:main:会话/一 %2F', 'sid_literal', 'draft'])(
+    'round-trips resource and browser links for %s', (id) => {
+      expect(buildSessionPanelUrl(id)).toBe(`nextclaw://sessions/${encodeURIComponent(id)}`);
+      expect(parseSessionKeyFromPanelUrl(buildSessionPanelUrl(id))).toBe(id);
+      expect(parseSessionKeyFromRoute(buildSessionPath(id).slice('/chat/'.length))).toBe(id);
+      expect(parseSessionKeyFromPanelUrl(`nextclaw://chat-session/${encodeSessionRouteId(id)}`)).toBe(id);
+    },
+  );
+  it('keeps ordinary IDs readable in the address bar', () => {
+    expect(buildSessionPath('ncp-mu2x4zdy-9wzl0otb')).toBe('/chat/ncp-mu2x4zdy-9wzl0otb');
+  });
+  it.each(['sessions', 'chat-session', 'objects/chat-session', 'objects/chat-sessions'])(
+    'recovers already delivered %s links', (namespace) => {
+      expect(parseSessionKeyFromPanelUrl(`nextclaw://${namespace}/ncp-mu2x4zdy-9wzl0otb`)).toBe('ncp-mu2x4zdy-9wzl0otb');
+    },
+  );
+  it.each(['nextclaw://sessions/', 'nextclaw://sessions/a/b', 'nextclaw://sessions/%ZZ',
+    'nextclaw://sessions/%20', 'nextclaw://chat-session/sid_%%%','nextclaw://sessions/a?other=b',
+    'https://sessions/a', 'nextclaw://user@sessions/a', 'nextclaw://objects/project/a'])(
+    'rejects malformed or unrelated session links: %s', (uri) => {
+      expect(parseSessionKeyFromPanelUrl(uri)).toBeNull();
+    },
+  );
   it('keeps the draft route separate from real session keys', () => {
     expect(CHAT_DRAFT_SESSION_PATH).toBe('/chat/draft');
     expect(parseSessionKeyFromRoute('draft')).toBeNull();

package/src/features/chat/features/session/utils/chat-session-preference-governance.utils.ts

@@ -129,15 +129,17 @@ export function resolveSelectedThinkingLevelValue(params: {
   });
 }
 
-export function resolveRecentSessionPreferredValue<T>(params: {
+export function resolveRecentSessionPreferenceSnapshot(params: {
   sessions: readonly SessionEntryView[];
   selectedSessionKey?: string | null;
   sessionType?: string | null;
-  readPreference: (session: SessionEntryView) => T | null | undefined;
-}): T | undefined {
-  const { sessions, selectedSessionKey, sessionType, readPreference } = params;
+}): {
+  model: string;
+  thinking?: ThinkingLevel;
+} | undefined {
+  const { sessions, selectedSessionKey, sessionType } = params;
   const targetSessionType = normalizeSessionType(sessionType);
-  let bestValue: T | undefined;
+  let bestValue: { model: string; thinking?: ThinkingLevel } | undefined;
   let bestTimestamp = Number.NEGATIVE_INFINITY;
   for (const session of sessions) {
     if (session.key === selectedSessionKey) {
@@ -146,14 +148,18 @@ export function resolveRecentSessionPreferredValue<T>(params: {
     if (normalizeSessionType(session.sessionType) !== targetSessionType) {
       continue;
     }
-    const value = readPreference(session);
-    if (value === null || value === undefined) {
+    const model = session.preferredModel?.trim() || undefined;
+    const thinking = session.preferredThinking ?? undefined;
+    if (model === undefined) {
       continue;
     }
     const updatedAtTimestamp = Date.parse(session.updatedAt);
     const comparableTimestamp = Number.isFinite(updatedAtTimestamp) ? updatedAtTimestamp : Number.NEGATIVE_INFINITY;
     if (bestValue === undefined || comparableTimestamp > bestTimestamp) {
-      bestValue = value;
+      bestValue = {
+        model,
+        ...(thinking ? { thinking } : {}),
+      };
       bestTimestamp = comparableTimestamp;
     }
   }

package/src/features/chat/features/session/utils/chat-session-route.utils.ts

@@ -1,16 +1,9 @@
+import { createSessionResourceUri, parseSessionResourceUri } from '@nextclaw/shared';
+
 const SESSION_ROUTE_PREFIX = 'sid_';
 export const CHAT_SESSION_PANEL_KIND = 'chat-session';
-const SESSION_PANEL_PREFIX = 'nextclaw://chat-session/';
-
-export function buildSessionPanelUrl(sessionKey: string): string {
-  return SESSION_PANEL_PREFIX + encodeSessionRouteId(sessionKey);
-}
-
-export function parseSessionKeyFromPanelUrl(url: string): string | null {
-  return url.startsWith(SESSION_PANEL_PREFIX)
-    ? decodeSessionRouteId(url.slice(SESSION_PANEL_PREFIX.length))
-    : null;
-}
+export const buildSessionPanelUrl = createSessionResourceUri;
+export const parseSessionKeyFromPanelUrl = parseSessionResourceUri;
 export const CHAT_DRAFT_SESSION_PATH = '/chat/draft';
 const DRAFT_SESSION_ROUTE_ID = CHAT_DRAFT_SESSION_PATH.slice('/chat/'.length);
 
@@ -55,5 +48,9 @@ export function parseSessionKeyFromRoute(routeValue?: string): string | null {
 }
 
 export function buildSessionPath(sessionKey: string): string {
-  return `/chat/${encodeSessionRouteId(sessionKey)}`;
+  // Keep reserved historical route tokens unambiguous; ordinary IDs stay readable.
+  const routeId = sessionKey === DRAFT_SESSION_ROUTE_ID || sessionKey.startsWith(SESSION_ROUTE_PREFIX)
+    ? encodeSessionRouteId(sessionKey)
+    : encodeURIComponent(sessionKey);
+  return `/chat/${routeId}`;
 }

package/src/features/chat/features/workspace/components/__tests__/chat-session-workspace-file-preview.selection.test.tsx

@@ -1,6 +1,6 @@
 import type { ReactNode } from "react";
-import { fireEvent, render, screen } from "@testing-library/react";
-import { describe, expect, it, vi } from "vitest";
+import { cleanup, fireEvent, render, screen } from "@testing-library/react";
+import { afterEach, describe, expect, it, vi } from "vitest";
 import { ChatSessionWorkspaceFilePreview } from "@/features/chat/features/workspace/components/chat-session-workspace-file-preview";
 
 const onTextExcerptAdd = vi.fn();
@@ -37,6 +37,18 @@ vi.mock("@nextclaw/agent-chat-ui", () => ({
 }));
 
 describe("ChatSessionWorkspaceFilePreview selection", () => {
+  afterEach(cleanup);
+
+  it("does not offer an action when no composer callback is connected", () => {
+    render(<ChatSessionWorkspaceFilePreview
+      file={{ key: "boot", parentSessionKey: null, path: "BOOT.md", label: "BOOT.md", viewMode: "preview" }}
+      sessionProjectRoot={null}
+      sessionWorkingDir={null}
+      onFileOpen={vi.fn()}
+    />);
+    expect(screen.queryByRole("button", { name: "select excerpt" })).toBeNull();
+  });
+
   it("uses the resolved absolute path when a shell-style workspace root cannot be compared in the browser", () => {
     render(
       <ChatSessionWorkspaceFilePreview

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

@@ -8,10 +8,14 @@ import { setLanguage } from "@/shared/lib/i18n";
 import { SessionCronJobContent } from "@/features/chat/features/workspace/components/session-cron-job-content";
 
 const mocks = vi.hoisted(() => ({
+  openResource: vi.fn(),
   deleteJob: vi.fn(),
   runJob: vi.fn(),
   toggleJob: vi.fn(),
 }));
+vi.mock("@/app/components/app-presenter-provider", () => ({ useAppPresenter: () => ({ pageResourceManager: { open: mocks.openResource } }) }));
+vi.mock("react-router-dom", () => ({ useNavigate: () => vi.fn() }));
+vi.mock("@/features/right-panel-resources", () => ({ pageResourceFromSystemObject: (type: string, id: string) => ({ uri: `nextclaw://objects/${type}/${id}` }) }));
 
 vi.mock("@/features/cron", () => ({
   CronJobDetailDialog: ({ job, open }: { job: CronJobView | null; open: boolean }) => (
@@ -73,6 +77,6 @@ describe("SessionCronJobContent", () => {
     expect(mocks.runJob).toHaveBeenCalledWith(job);
 
     await user.click(screen.getByRole("button", { name: "查看任务详情" }));
-    expect(screen.getByRole("dialog").textContent).toContain(job.payload.message);
+    expect(mocks.openResource).toHaveBeenCalledWith({ uri: "nextclaw://objects/cron-job/paint-daily" }, "default", expect.any(Function));
   });
 });

package/src/features/chat/features/workspace/components/chat-session-workspace-file-preview.tsx

@@ -455,7 +455,7 @@ export function ChatSessionWorkspaceFilePreview({
       <div className="flex-1 min-h-0 overflow-hidden">
         {file.viewMode === 'diff' ? (
           <WorkspaceDiffBody diffBlock={diffBlock} fileKey={file.key} />
-        ) : excerptPath && previewText ? (
+        ) : excerptPath && previewText && onTextExcerptAdd ? (
           <WorkspaceTextSelectionMenu
             fileLabel={file.label?.trim() || excerptPath.split('/').at(-1) || excerptPath}
             filePath={excerptPath}

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

@@ -11,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 {
@@ -227,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">
@@ -271,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';