@nextclaw/ui 0.13.12 → 0.14.0

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

@@ -0,0 +1,148 @@
+import { beforeEach, describe, expect, it } from 'vitest';
+import { useChatThreadStore } from '@/features/chat/stores/chat-thread.store';
+
+const chatThreadWorkspaceStorageKey = 'nextclaw.chat.workspace-panel.state';
+
+function createLocalStoragePersistStorage() {
+  return {
+    getItem: (name: string) => JSON.parse(window.localStorage.getItem(name) ?? 'null'),
+    setItem: (name: string, value: unknown) => window.localStorage.setItem(name, JSON.stringify(value)),
+    removeItem: (name: string) => window.localStorage.removeItem(name)
+  };
+}
+
+function resetChatThreadStore() {
+  useChatThreadStore.setState({
+    snapshot: {
+      ...useChatThreadStore.getState().snapshot,
+      sessionKey: null,
+      messages: [],
+      isSending: false,
+      workspacePanelParentKey: null,
+      activeWorkspacePanelKind: null,
+      childSessionTabs: [],
+      activeChildSessionKey: null,
+      workspaceFileTabs: [],
+      activeWorkspaceFileKey: null,
+      workspaceNavigationHistory: [],
+      workspaceNavigationHistoryIndex: 0,
+    },
+  });
+}
+
+describe('chat thread workspace panel persistence', () => {
+  beforeEach(() => {
+    window.localStorage.clear();
+    useChatThreadStore.persist.setOptions({
+      storage: createLocalStoragePersistStorage(),
+    });
+    resetChatThreadStore();
+    window.localStorage.clear();
+  });
+
+  it('persists only the workspace panel continuity state', () => {
+    useChatThreadStore.getState().setSnapshot({
+      sessionKey: 'session-1',
+      isSending: true,
+      workspacePanelParentKey: 'session-1',
+      activeWorkspacePanelKind: 'file',
+      workspaceFileTabs: [
+        {
+          key: 'session-1::preview::README.md',
+          parentSessionKey: 'session-1',
+          path: 'README.md',
+          label: 'README.md',
+          viewMode: 'preview',
+          rawText: '# Hello',
+          fullLines: [],
+        },
+      ],
+      activeWorkspaceFileKey: 'session-1::preview::README.md',
+      workspaceNavigationHistory: [
+        { kind: 'child-session', key: 'child-session-1' },
+        { kind: 'file', key: 'session-1::preview::README.md' },
+      ],
+      workspaceNavigationHistoryIndex: 1,
+    });
+
+    const persisted = JSON.parse(
+      window.localStorage.getItem(chatThreadWorkspaceStorageKey) ?? '{}',
+    );
+
+    expect(persisted.state.snapshot).toMatchObject({
+      workspacePanelParentKey: 'session-1',
+      activeWorkspacePanelKind: 'file',
+      activeWorkspaceFileKey: 'session-1::preview::README.md',
+      workspaceNavigationHistory: [
+        { kind: 'child-session', key: 'child-session-1' },
+        { kind: 'file', key: 'session-1::preview::README.md' },
+      ],
+      workspaceNavigationHistoryIndex: 1,
+    });
+    expect(persisted.state.snapshot.sessionKey).toBeUndefined();
+    expect(persisted.state.snapshot.isSending).toBeUndefined();
+    expect(persisted.state.snapshot.workspaceFileTabs[0].rawText).toBe('# Hello');
+    expect(persisted.state.snapshot.workspaceFileTabs[0].fullLines).toBeUndefined();
+  });
+
+  it('hydrates the workspace panel state and repairs stale active file keys', async () => {
+    window.localStorage.setItem(
+      chatThreadWorkspaceStorageKey,
+      JSON.stringify({
+        state: {
+          snapshot: {
+            workspacePanelParentKey: 'session-1',
+            activeWorkspacePanelKind: 'file',
+            activeWorkspaceFileKey: 'missing-file',
+            activeChildSessionKey: 'child-session-1',
+            workspaceNavigationHistory: [
+              { kind: 'file', key: 'missing-file' },
+              { kind: 'file', key: 'session-1::preview::README.md' },
+            ],
+            workspaceNavigationHistoryIndex: 1,
+            workspaceFileTabs: [
+              {
+                key: 'session-1::preview::README.md',
+                parentSessionKey: 'session-1',
+                path: 'README.md',
+                label: 'README.md',
+                viewMode: 'preview',
+                rawText: '# Hello',
+              },
+              {
+                key: 'invalid',
+                parentSessionKey: 'session-1',
+                path: '',
+                viewMode: 'preview',
+              },
+            ],
+          },
+        },
+        version: 2,
+      }),
+    );
+
+    await useChatThreadStore.persist.rehydrate();
+
+    expect(useChatThreadStore.getState().snapshot).toMatchObject({
+      workspacePanelParentKey: 'session-1',
+      activeWorkspacePanelKind: 'file',
+      activeWorkspaceFileKey: 'session-1::preview::README.md',
+      activeChildSessionKey: 'child-session-1',
+      workspaceNavigationHistory: [
+        { kind: 'file', key: 'session-1::preview::README.md' },
+      ],
+      workspaceNavigationHistoryIndex: 0,
+      workspaceFileTabs: [
+        {
+          key: 'session-1::preview::README.md',
+          parentSessionKey: 'session-1',
+          path: 'README.md',
+          label: 'README.md',
+          viewMode: 'preview',
+          rawText: '# Hello',
+        },
+      ],
+    });
+  });
+});

package/src/features/chat/stores/chat-input.store.ts

@@ -1,9 +1,10 @@
 import { create } from 'zustand';
 import type { ChatComposerNode } from '@nextclaw/agent-chat-ui';
 import type { NcpDraftAttachment } from '@nextclaw/ncp-react';
+import type { RuntimeModelSelectionMode } from '@nextclaw/shared';
 import type { SessionSkillEntryView, SessionTypeIconView, ThinkingLevel } from '@/shared/lib/api';
 import type { ChatModelOption } from '@/features/chat/types/chat-input.types';
-import { createInitialChatComposerNodes } from '@/features/chat/utils/chat-composer-state.utils';
+import { createInitialChatComposerNodes } from '@/features/chat/features/input/utils/chat-composer-state.utils';
 
 export type ChatInputSnapshot = {
   isProviderStateResolved: boolean;
@@ -30,6 +31,7 @@ export type ChatInputSnapshot = {
     reasonMessage?: string | null;
     supportedModels?: string[];
     recommendedModel?: string | null;
+    modelSelectionMode?: RuntimeModelSelectionMode;
     cta?: {
       kind: string;
       label?: string;
@@ -41,6 +43,7 @@ export type ChatInputSnapshot = {
   stopReason?: string;
   canEditSessionType: boolean;
   sessionTypeUnavailable: boolean;
+  sessionTypeUnavailableMessage: string | null;
   skillRecords: SessionSkillEntryView[];
   isSkillsLoading: boolean;
   selectedSkills: string[];
@@ -74,6 +77,7 @@ const initialSnapshot: ChatInputSnapshot = {
   stopReason: undefined,
   canEditSessionType: false,
   sessionTypeUnavailable: false,
+  sessionTypeUnavailableMessage: null,
   skillRecords: [],
   isSkillsLoading: false,
   selectedSkills: [],

package/src/features/chat/stores/chat-thread.store.ts

@@ -1,13 +1,11 @@
 import { create } from 'zustand';
-import type { MutableRefObject } from 'react';
+import { createJSONStorage, persist } from 'zustand/middleware';
 import type { NcpMessage } from '@nextclaw/ncp';
 import type { ChatFileOperationLineViewModel } from '@nextclaw/agent-chat-ui';
 import type {
-  AgentProfileView,
   SessionContextWindowView,
   SessionTypeIconView
 } from '@/shared/lib/api';
-import type { ChatModelOption } from '@/features/chat/types/chat-input.types';
 
 export type ChatChildSessionTab = {
   sessionKey: string;
@@ -33,25 +31,30 @@ export type ChatWorkspaceFileTab = {
   fullLines?: ChatFileOperationLineViewModel[];
 };
 
+export type ChatWorkspaceNavigationEntry =
+  | {
+      kind: 'child-session';
+      key: string;
+    }
+  | {
+      kind: 'file';
+      key: string;
+    }
+  | {
+      kind: 'cron';
+    };
+
 export type ChatThreadSnapshot = {
-  isProviderStateResolved: boolean;
-  modelOptions: ChatModelOption[];
-  sessionTypeUnavailable: boolean;
-  sessionTypeUnavailableMessage?: string | null;
   sessionTypeLabel?: string | null;
   sessionTypeIcon?: SessionTypeIconView | null;
   sessionKey: string | null;
   agentId?: string | null;
-  agentDisplayName?: string | null;
-  agentAvatarUrl?: string | null;
-  availableAgents?: AgentProfileView[];
   sessionDisplayName?: string;
   sessionProjectRoot?: string | null;
   sessionWorkingDir?: string | null;
   sessionProjectName?: string | null;
   canDeleteSession: boolean;
   isDeletePending: boolean;
-  threadRef: MutableRefObject<HTMLDivElement | null> | null;
   isHistoryLoading: boolean;
   messages: readonly NcpMessage[];
   isSending: boolean;
@@ -65,33 +68,54 @@ export type ChatThreadSnapshot = {
   activeChildSessionKey?: string | null;
   workspaceFileTabs: ChatWorkspaceFileTab[];
   activeWorkspaceFileKey?: string | null;
+  workspaceNavigationHistory: ChatWorkspaceNavigationEntry[];
+  workspaceNavigationHistoryIndex: number;
   contextWindow?: SessionContextWindowView | null;
 };
 
+const CHAT_THREAD_WORKSPACE_STORAGE_KEY = 'nextclaw.chat.workspace-panel.state';
+const CHAT_THREAD_WORKSPACE_STORAGE_VERSION = 2;
+const CHAT_THREAD_MAX_PERSISTED_WORKSPACE_FILE_TABS = 8;
+
 type ChatThreadStore = {
   snapshot: ChatThreadSnapshot;
   setSnapshot: (patch: Partial<ChatThreadSnapshot>) => void;
 };
 
+type PersistedChatThreadStore = {
+  snapshot?: {
+    workspacePanelParentKey?: unknown;
+    activeWorkspacePanelKind?: unknown;
+    activeChildSessionKey?: unknown;
+    workspaceFileTabs?: unknown;
+    activeWorkspaceFileKey?: unknown;
+    workspaceNavigationHistory?: unknown;
+    workspaceNavigationHistoryIndex?: unknown;
+  };
+};
+
+type PersistedChatWorkspaceSnapshot = Pick<
+  ChatThreadSnapshot,
+  | 'workspacePanelParentKey'
+  | 'activeWorkspacePanelKind'
+  | 'activeChildSessionKey'
+  | 'workspaceFileTabs'
+  | 'activeWorkspaceFileKey'
+  | 'workspaceNavigationHistory'
+  | 'workspaceNavigationHistoryIndex'
+>;
+
 const initialSnapshot: ChatThreadSnapshot = {
-  isProviderStateResolved: false,
-  modelOptions: [],
-  sessionTypeUnavailable: false,
-  sessionTypeUnavailableMessage: null,
   sessionTypeLabel: null,
   sessionTypeIcon: null,
   sessionKey: null,
   agentId: null,
-  agentDisplayName: null,
-  agentAvatarUrl: null,
-  availableAgents: [],
   sessionDisplayName: undefined,
   sessionProjectRoot: null,
   sessionWorkingDir: null,
   sessionProjectName: null,
   canDeleteSession: false,
   isDeletePending: false,
-  threadRef: null,
   isHistoryLoading: false,
   messages: [],
   isSending: false,
@@ -105,16 +129,251 @@ const initialSnapshot: ChatThreadSnapshot = {
   activeChildSessionKey: null,
   workspaceFileTabs: [],
   activeWorkspaceFileKey: null,
+  workspaceNavigationHistory: [],
+  workspaceNavigationHistoryIndex: 0,
   contextWindow: null
 };
 
-export const useChatThreadStore = create<ChatThreadStore>((set) => ({
-  snapshot: initialSnapshot,
-  setSnapshot: (patch) =>
-    set((state) => ({
-      snapshot: {
-        ...state.snapshot,
-        ...patch
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return !!value && typeof value === 'object';
+}
+
+function normalizeOptionalString(value: unknown): string | null {
+  return typeof value === 'string' && value.trim().length > 0
+    ? value.trim()
+    : null;
+}
+
+function normalizeOptionalNumber(value: unknown): number | null {
+  return typeof value === 'number' && Number.isFinite(value)
+    ? value
+    : null;
+}
+
+function normalizeHistoryIndex(value: unknown, maxIndex: number): number {
+  return typeof value === 'number' && Number.isInteger(value)
+    ? Math.min(Math.max(0, value), maxIndex)
+    : maxIndex;
+}
+
+function isWorkspacePanelKind(
+  value: unknown,
+): value is NonNullable<ChatThreadSnapshot['activeWorkspacePanelKind']> {
+  return value === 'child-session' || value === 'file' || value === 'cron';
+}
+
+function normalizePersistedWorkspaceNavigationEntry(
+  value: unknown,
+): ChatWorkspaceNavigationEntry | null {
+  if (!isRecord(value)) {
+    return null;
+  }
+  if (value.kind === 'cron') {
+    return { kind: 'cron' };
+  }
+  const key = normalizeOptionalString(value.key);
+  if (!key || (value.kind !== 'child-session' && value.kind !== 'file')) {
+    return null;
+  }
+  return {
+    kind: value.kind,
+    key,
+  };
+}
+
+function createWorkspaceNavigationEntryFromSnapshot({
+  activeChildSessionKey,
+  activeWorkspaceFileKey,
+  activeWorkspacePanelKind,
+}: {
+  activeWorkspacePanelKind: ChatThreadSnapshot['activeWorkspacePanelKind'];
+  activeChildSessionKey: string | null;
+  activeWorkspaceFileKey: string | null;
+}): ChatWorkspaceNavigationEntry | null {
+  if (activeWorkspacePanelKind === 'cron') {
+    return { kind: 'cron' };
+  }
+  if (activeWorkspacePanelKind === 'child-session' && activeChildSessionKey) {
+    return {
+      kind: 'child-session',
+      key: activeChildSessionKey,
+    };
+  }
+  if (activeWorkspacePanelKind === 'file' && activeWorkspaceFileKey) {
+    return {
+      kind: 'file',
+      key: activeWorkspaceFileKey,
+    };
+  }
+  return null;
+}
+
+function normalizeOptionalText(value: unknown): string | null {
+  return typeof value === 'string' ? value : null;
+}
+
+function normalizePersistedWorkspaceFileTab(
+  value: unknown,
+): ChatWorkspaceFileTab | null {
+  if (
+    !isRecord(value)
+    || typeof value.key !== 'string'
+    || typeof value.path !== 'string'
+    || (value.viewMode !== 'preview' && value.viewMode !== 'diff')
+  ) {
+    return null;
+  }
+  const key = value.key.trim();
+  const path = value.path.trim();
+  if (!key || !path) {
+    return null;
+  }
+  return {
+    key,
+    parentSessionKey: normalizeOptionalString(value.parentSessionKey),
+    path,
+    label: normalizeOptionalString(value.label),
+    viewMode: value.viewMode,
+    line: normalizeOptionalNumber(value.line),
+    column: normalizeOptionalNumber(value.column),
+    rawText: normalizeOptionalText(value.rawText),
+    beforeText: normalizeOptionalText(value.beforeText),
+    afterText: normalizeOptionalText(value.afterText),
+    patchText: normalizeOptionalText(value.patchText),
+    oldStartLine: normalizeOptionalNumber(value.oldStartLine),
+    newStartLine: normalizeOptionalNumber(value.newStartLine),
+  };
+}
+
+function toPersistedWorkspaceFileTab(
+  tab: ChatWorkspaceFileTab,
+): ChatWorkspaceFileTab {
+  return {
+    key: tab.key,
+    parentSessionKey: tab.parentSessionKey,
+    path: tab.path,
+    label: tab.label,
+    viewMode: tab.viewMode,
+    line: tab.line,
+    column: tab.column,
+    rawText: tab.rawText,
+    beforeText: tab.beforeText,
+    afterText: tab.afterText,
+    patchText: tab.patchText,
+    oldStartLine: tab.oldStartLine,
+    newStartLine: tab.newStartLine,
+  };
+}
+
+function normalizePersistedWorkspaceSnapshot(
+  value: unknown,
+): PersistedChatWorkspaceSnapshot | null {
+  if (!isRecord(value)) {
+    return null;
+  }
+  const workspaceFileTabs = Array.isArray(value.workspaceFileTabs)
+    ? value.workspaceFileTabs
+      .map(normalizePersistedWorkspaceFileTab)
+      .filter((tab): tab is ChatWorkspaceFileTab => tab !== null)
+      .slice(-CHAT_THREAD_MAX_PERSISTED_WORKSPACE_FILE_TABS)
+    : [];
+  const activeWorkspaceFileKey = normalizeOptionalString(value.activeWorkspaceFileKey);
+  const resolvedActiveWorkspaceFileKey =
+    activeWorkspaceFileKey && workspaceFileTabs.some((tab) => tab.key === activeWorkspaceFileKey)
+      ? activeWorkspaceFileKey
+      : workspaceFileTabs[0]?.key ?? null;
+  const activeWorkspacePanelKind = isWorkspacePanelKind(value.activeWorkspacePanelKind)
+    ? value.activeWorkspacePanelKind
+    : null;
+  const resolvedActiveWorkspacePanelKind =
+    activeWorkspacePanelKind === 'file' && !resolvedActiveWorkspaceFileKey
+      ? null
+      : activeWorkspacePanelKind;
+  const activeChildSessionKey = normalizeOptionalString(value.activeChildSessionKey);
+  const fallbackHistoryEntry = createWorkspaceNavigationEntryFromSnapshot({
+    activeWorkspacePanelKind: resolvedActiveWorkspacePanelKind,
+    activeChildSessionKey,
+    activeWorkspaceFileKey: resolvedActiveWorkspaceFileKey,
+  });
+  const normalizedNavigationHistory = Array.isArray(value.workspaceNavigationHistory)
+    ? value.workspaceNavigationHistory
+      .map(normalizePersistedWorkspaceNavigationEntry)
+      .filter((entry): entry is ChatWorkspaceNavigationEntry => entry !== null)
+      .filter((entry) =>
+        entry.kind !== 'file' || workspaceFileTabs.some((tab) => tab.key === entry.key),
+      )
+    : [];
+  const workspaceNavigationHistory =
+    normalizedNavigationHistory.length > 0
+      ? normalizedNavigationHistory
+      : fallbackHistoryEntry
+        ? [fallbackHistoryEntry]
+        : [];
+  const workspaceNavigationHistoryIndex =
+    workspaceNavigationHistory.length > 0
+      ? normalizeHistoryIndex(
+        value.workspaceNavigationHistoryIndex,
+        workspaceNavigationHistory.length - 1,
+      )
+      : 0;
+
+  return {
+    workspacePanelParentKey: normalizeOptionalString(value.workspacePanelParentKey),
+    activeWorkspacePanelKind: resolvedActiveWorkspacePanelKind,
+    activeChildSessionKey,
+    workspaceFileTabs,
+    activeWorkspaceFileKey: resolvedActiveWorkspaceFileKey,
+    workspaceNavigationHistory,
+    workspaceNavigationHistoryIndex,
+  };
+}
+
+export const useChatThreadStore = create<ChatThreadStore>()(
+  persist(
+    (set) => ({
+      snapshot: initialSnapshot,
+      setSnapshot: (patch) =>
+        set((state) => ({
+          snapshot: {
+            ...state.snapshot,
+            ...patch
+          }
+        }))
+    }),
+    {
+      name: CHAT_THREAD_WORKSPACE_STORAGE_KEY,
+      version: CHAT_THREAD_WORKSPACE_STORAGE_VERSION,
+      storage: createJSONStorage(() => window.localStorage),
+      partialize: (state): PersistedChatThreadStore => ({
+        snapshot: {
+          workspacePanelParentKey: state.snapshot.workspacePanelParentKey,
+          activeWorkspacePanelKind: state.snapshot.activeWorkspacePanelKind,
+          activeChildSessionKey: state.snapshot.activeChildSessionKey,
+          workspaceFileTabs: state.snapshot.workspaceFileTabs
+            .slice(-CHAT_THREAD_MAX_PERSISTED_WORKSPACE_FILE_TABS)
+            .map(toPersistedWorkspaceFileTab),
+          activeWorkspaceFileKey: state.snapshot.activeWorkspaceFileKey,
+          workspaceNavigationHistory: state.snapshot.workspaceNavigationHistory,
+          workspaceNavigationHistoryIndex: state.snapshot.workspaceNavigationHistoryIndex,
+        }
+      }),
+      merge: (persistedState, currentState) => {
+        const persistedSnapshot = isRecord(persistedState)
+          ? persistedState.snapshot
+          : null;
+        const workspaceSnapshot =
+          normalizePersistedWorkspaceSnapshot(persistedSnapshot);
+        if (!workspaceSnapshot) {
+          return currentState;
+        }
+        return {
+          ...currentState,
+          snapshot: {
+            ...currentState.snapshot,
+            ...workspaceSnapshot
+          }
+        };
       }
-    }))
-}));
+    }
+  )
+);

package/src/features/chat/stores/ncp-chat-query.store.ts

@@ -0,0 +1,25 @@
+import { create } from 'zustand';
+import type { UseQueryResult } from '@tanstack/react-query';
+import type { ChatSessionTypesView, ConfigView, NcpSessionSkillsView, NcpSessionsListView, ProviderTemplatesView, ProvidersView } from '@/shared/lib/api';
+
+type Query<TData> = UseQueryResult<TData, Error>;
+
+export type ChatQuerySnapshot = Partial<{
+  configQuery: Query<ConfigView> | null;
+  providersQuery: Query<ProvidersView> | null;
+  providerTemplatesQuery: Query<ProviderTemplatesView> | null;
+  sessionsQuery: Query<NcpSessionsListView> | null;
+  sessionTypesQuery: Query<ChatSessionTypesView> | null;
+  sessionSkillsSessionId: string | null;
+  sessionSkillsQuery: Query<NcpSessionSkillsView> | null;
+}>;
+
+type ChatQueryStore = {
+  snapshot: ChatQuerySnapshot;
+  setSnapshot: (patch: Partial<ChatQuerySnapshot>) => void;
+};
+
+export const useChatQueryStore = create<ChatQueryStore>((set) => ({
+  snapshot: {},
+  setSnapshot: (patch) => set(({ snapshot }) => ({ snapshot: { ...snapshot, ...patch } })),
+}));

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

@@ -9,6 +9,7 @@ export type ChatModelOption = {
   value: string;
   modelLabel: string;
   providerLabel: string;
+  isRuntimeDefault?: boolean;
   thinkingCapability?: ChatModelThinkingCapability | null;
 };
 

package/src/features/chat/types/chat-message.types.ts

@@ -17,6 +17,7 @@ export type ChatMessageAdapterTexts = {
   toolStatusCompletedLabel: string;
   toolStatusFailedLabel: string;
   toolStatusCancelledLabel: string;
+  showContentActionLabel?: string;
   imageAttachmentLabel: string;
   fileAttachmentLabel: string;
   unknownPartLabel: string;

package/src/features/chat/types/chat-run.types.ts

@@ -0,0 +1,41 @@
+import type { ChatComposerNode } from '@nextclaw/agent-chat-ui';
+import type {
+  NcpAgentSendEnvelope,
+  NcpMessage,
+  NcpMessagePart,
+  NcpRunHandle,
+} from '@nextclaw/ncp';
+import type { NcpDraftAttachment } from '@nextclaw/ncp-react';
+import type { SessionContextWindowView, ThinkingLevel } from '@/shared/lib/api';
+
+export type SendMessageParams = {
+  message: string;
+  sessionKey?: string;
+  agentId: string;
+  sessionType?: string;
+  model?: string;
+  thinkingLevel?: ThinkingLevel;
+  projectRoot?: string | null;
+  requestedSkills?: string[];
+  attachments?: NcpDraftAttachment[];
+  parts?: NcpMessagePart[];
+  composerNodes?: ChatComposerNode[];
+};
+
+export type ChatRunRuntime = {
+  sessionKey: string | null;
+  sendEnvelope: (envelope: NcpAgentSendEnvelope) => Promise<NcpRunHandle | null>;
+  abortCurrentRun: () => Promise<void>;
+  resumeCurrentSessionRun: () => Promise<void>;
+};
+
+export type ChatRunSnapshot = {
+  routeSessionKey: string | null;
+  isHydrating: boolean;
+  isSending: boolean;
+  isRunning: boolean;
+  visibleMessages: readonly NcpMessage[];
+  contextWindow: SessionContextWindowView | null;
+  sendErrorMessage: string | null;
+  materializedSessionKey: string | null;
+};

package/src/{shared → features/cron}/components/cron-config.tsx

@@ -6,7 +6,7 @@ import {
   useDeleteCronJob,
   useToggleCronJob,
   useRunCronJob,
-} from "@/shared/hooks/use-config";
+} from "@/features/cron/hooks/use-cron-jobs";
 import { Button } from "@/shared/components/ui/button";
 import { Input } from "@/shared/components/ui/input";
 import { Switch } from "@/shared/components/ui/switch";