@nextclaw/ui 0.12.19 → 0.12.20-beta.1

package/src/features/chat/managers/ncp-chat-input.manager.ts

@@ -22,6 +22,7 @@ import type { ChatUiManager } from '@/features/chat/managers/chat-ui.manager';
 import type { ChatSessionListManager } from '@/features/chat/managers/chat-session-list.manager';
 import { ChatSessionPreferenceSync } from '@/features/chat/managers/chat-session-preference-sync.manager';
 import { isNcpChatSendDisabled } from '@/features/chat/utils/ncp-chat-input-availability.utils';
+import { isNcpChatRuntimeBlocked } from '@/features/chat/utils/ncp-chat-runtime-availability.utils';
 import { chatRecentModelsManager } from '@/features/chat/managers/chat-recent-models.manager';
 import { chatRecentSkillsManager } from '@/features/chat/managers/chat-recent-skills.manager';
 import type { ChatModelOption } from '@/features/chat/types/chat-input.types';
@@ -67,6 +68,9 @@ export class NcpChatInputManager {
   private isSameStringArray = (left: string[], right: string[]): boolean =>
     left.length === right.length && left.every((value, index) => value === right[index]);
 
+  private isRuntimeBlockedForSend = (): boolean =>
+    isNcpChatRuntimeBlocked(systemStatusManager.getStatusView());
+
   private syncComposerSnapshot = (nodes: ChatComposerNode[]) => {
     const currentAttachments = useChatInputStore.getState().snapshot.attachments;
     const attachments = pruneComposerAttachments(nodes, currentAttachments);
@@ -184,7 +188,7 @@ export class NcpChatInputManager {
       isNcpChatSendDisabled({
         snapshot: inputSnapshot,
         hasSendableDraft: hasSendableContent,
-        isRuntimeBlocked: systemStatusManager.isChatInteractionBlocked(),
+        isRuntimeBlocked: this.isRuntimeBlockedForSend(),
       })
     ) {
       return;

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

@@ -2,8 +2,7 @@ import { describe, expect, it } from 'vitest';
 import type { SessionEntryView, ThinkingLevel } from '@/shared/lib/api';
 import type { ChatModelOption } from '@/features/chat/types/chat-input.types';
 import {
-  resolveRecentSessionPreferredModel,
-  resolveRecentSessionPreferredThinking,
+  resolveRecentSessionPreferredValue,
   resolveSelectedModelValue,
   resolveSelectedThinkingLevelValue
 } from '@/features/chat/utils/chat-session-preference-governance.utils';
@@ -25,6 +24,18 @@ const modelOptions: ChatModelOption[] = [
     modelLabel: 'gpt-5',
     providerLabel: 'OpenAI',
     thinkingCapability: null
+  },
+  {
+    value: 'minimax/MiniMax-M2.7',
+    modelLabel: 'MiniMax-M2.7',
+    providerLabel: 'MiniMax',
+    thinkingCapability: null
+  },
+  {
+    value: 'deepseek/deepseek-v4-flash',
+    modelLabel: 'deepseek-v4-flash',
+    providerLabel: 'DeepSeek',
+    thinkingCapability: null
   }
 ];
 
@@ -270,10 +281,11 @@ describe('resolveRecentSessionPreferredModel', () => {
     ];
 
     expect(
-      resolveRecentSessionPreferredModel({
+      resolveRecentSessionPreferredValue<string>({
         sessions,
         selectedSessionKey: 'draft',
-        sessionType: 'codex'
+        sessionType: 'codex',
+        readPreference: (session) => session.preferredModel?.trim() || undefined
       })
     ).toBe('openai/gpt-5');
   });
@@ -300,10 +312,11 @@ describe('resolveRecentSessionPreferredModel', () => {
     ];
 
     expect(
-      resolveRecentSessionPreferredModel({
+      resolveRecentSessionPreferredValue<string>({
         sessions,
         selectedSessionKey: 'codex-current',
-        sessionType: 'codex'
+        sessionType: 'codex',
+        readPreference: (session) => session.preferredModel?.trim() || undefined
       })
     ).toBe('anthropic/claude-sonnet-4');
   });
@@ -384,10 +397,11 @@ describe('resolveRecentSessionPreferredThinking', () => {
     ];
 
     expect(
-      resolveRecentSessionPreferredThinking({
+      resolveRecentSessionPreferredValue<ThinkingLevel>({
         sessions,
         selectedSessionKey: 'draft',
-        sessionType: 'codex'
+        sessionType: 'codex',
+        readPreference: (session) => session.preferredThinking ?? undefined
       })
     ).toBe('high');
   });

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

@@ -32,10 +32,8 @@ import { useChatSessionListStore } from "@/features/chat/stores/chat-session-lis
 import { useConfirmDialog } from "@/shared/hooks/use-confirm-dialog";
 import { useAgents } from "@/shared/hooks/use-agents";
 import { normalizeRequestedSkills } from "@/features/chat/utils/chat-runtime.utils";
-import {
-  systemStatusManager,
-  useChatRuntimeAvailability,
-} from "@/features/system-status";
+import { useSystemStatus } from "@/features/system-status";
+import { isNcpChatRuntimeBlocked, resolveNcpChatSendErrorMessage } from "@/features/chat/utils/ncp-chat-runtime-availability.utils";
 import {
   getSessionProjectName,
   normalizeSessionProjectRootValue,
@@ -126,7 +124,8 @@ function useNcpChatPageBaseState(presenter: NcpChatPresenter) {
   const currentSelectedModel = useChatInputStore(
     (state) => state.snapshot.selectedModel,
   );
-  const runtimeAvailability = useChatRuntimeAvailability();
+  const systemStatus = useSystemStatus();
+  const isRuntimeBlocked = isNcpChatRuntimeBlocked(systemStatus);
   const agentsQuery = useAgents();
   const { confirm, ConfirmDialog } = useConfirmDialog();
   const location = useLocation();
@@ -163,7 +162,8 @@ function useNcpChatPageBaseState(presenter: NcpChatPresenter) {
     selectedAgentId,
     pendingProjectRoot,
     pendingProjectRootSessionKey,
-    runtimeAvailability,
+    systemStatus,
+    isRuntimeBlocked,
     agentsQuery,
     confirm,
     ConfirmDialog,
@@ -186,7 +186,8 @@ function useNcpChatPageState(presenter: NcpChatPresenter) {
     agentsQuery,
     hasSessionProjectRootOverride,
     pendingProjectRoot,
-    runtimeAvailability,
+    isRuntimeBlocked,
+    systemStatus,
     selectedAgentId,
     selectedSession,
     selectedSessionType,
@@ -204,7 +205,7 @@ function useNcpChatPageState(presenter: NcpChatPresenter) {
   const rawLastSendError =
     agent.hydrateError?.message ?? agent.snapshot.error?.message ?? null;
   const filteredLastSendError =
-    runtimeAvailability.phase === "ready" &&
+    systemStatus.phase === "ready" &&
     isNcpAgentStartupUnavailableErrorMessage(rawLastSendError)
       ? null
       : rawLastSendError;
@@ -231,11 +232,14 @@ function useNcpChatPageState(presenter: NcpChatPresenter) {
     canStopCurrentRun: agent.isRunning,
     stopDisabledReason: agent.isRunning ? null : "__preparing__",
     lastSendError:
-      runtimeAvailability.isBlocked
+      isRuntimeBlocked
         ? null
-        : runtimeAvailability.phase === "ready"
+        : systemStatus.phase === "ready"
         ? filteredLastSendError
-        : systemStatusManager.getDisplayMessage(filteredLastSendError),
+        : resolveNcpChatSendErrorMessage({
+            message: filteredLastSendError,
+            status: systemStatus,
+          }),
     ...derivedState,
   };
 }

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

@@ -2,7 +2,11 @@ import { create } from 'zustand';
 import type { MutableRefObject } from 'react';
 import type { NcpMessage } from '@nextclaw/ncp';
 import type { ChatFileOperationLineViewModel } from '@nextclaw/agent-chat-ui';
-import type { AgentProfileView, SessionTypeIconView } from '@/shared/lib/api';
+import type {
+  AgentProfileView,
+  SessionContextWindowView,
+  SessionTypeIconView
+} from '@/shared/lib/api';
 import type { ChatModelOption } from '@/features/chat/types/chat-input.types';
 
 export type ChatChildSessionTab = {
@@ -58,6 +62,7 @@ export type ChatThreadSnapshot = {
   activeChildSessionKey?: string | null;
   workspaceFileTabs: ChatWorkspaceFileTab[];
   activeWorkspaceFileKey?: string | null;
+  contextWindow?: SessionContextWindowView | null;
 };
 
 type ChatThreadStore = {
@@ -93,7 +98,8 @@ const initialSnapshot: ChatThreadSnapshot = {
   childSessionTabs: [],
   activeChildSessionKey: null,
   workspaceFileTabs: [],
-  activeWorkspaceFileKey: null
+  activeWorkspaceFileKey: null,
+  contextWindow: null
 };
 
 export const useChatThreadStore = create<ChatThreadStore>((set) => ({

package/src/features/chat/utils/chat-context-window-indicator.utils.ts

@@ -0,0 +1,50 @@
+import type { ChatContextWindowIndicator } from '@nextclaw/agent-chat-ui';
+import type { SessionContextWindowView } from '@/shared/lib/api';
+import { t } from '@/shared/lib/i18n';
+
+function formatTokenCount(value: number): string {
+  if (value >= 1_000_000) {
+    return `${(value / 1_000_000).toFixed(value >= 10_000_000 ? 0 : 1)}M`;
+  }
+  if (value >= 1_000) {
+    return `${(value / 1_000).toFixed(value >= 10_000 ? 0 : 1)}k`;
+  }
+  return String(value);
+}
+
+export function buildChatContextWindowIndicator(
+  contextWindow: SessionContextWindowView | null | undefined
+): ChatContextWindowIndicator | null {
+  if (!contextWindow || contextWindow.totalContextTokens <= 0) {
+    return null;
+  }
+  const ratio = contextWindow.usedContextTokens / contextWindow.totalContextTokens;
+  const clampedRatio = Math.max(0, Math.min(1, ratio));
+  const percentLabel = `${Math.round(clampedRatio * 100)}%`;
+  const tone: ChatContextWindowIndicator['tone'] =
+    clampedRatio >= 0.9 ? 'danger' : clampedRatio >= 0.75 ? 'warning' : 'neutral';
+  const details: ChatContextWindowIndicator['details'] = [
+    { label: t('chatContextWindowUsed'), value: formatTokenCount(contextWindow.usedContextTokens) },
+    { label: t('chatContextWindowTotal'), value: formatTokenCount(contextWindow.totalContextTokens) },
+    { label: t('chatContextWindowAvailable'), value: formatTokenCount(contextWindow.availableContextTokens) }
+  ];
+  if (contextWindow.prunedUsedContextTokens !== contextWindow.usedContextTokens) {
+    details.push({
+      label: t('chatContextWindowPruned'),
+      value: formatTokenCount(contextWindow.prunedUsedContextTokens)
+    });
+  }
+  if (contextWindow.droppedHistoryCount > 0) {
+    details.push({ label: t('chatContextWindowDroppedHistory'), value: String(contextWindow.droppedHistoryCount) });
+  }
+  if (contextWindow.truncatedToolResultCount > 0) {
+    details.push({ label: t('chatContextWindowTruncatedTools'), value: String(contextWindow.truncatedToolResultCount) });
+  }
+  return {
+    label: t('chatContextWindow'),
+    percentLabel,
+    ratio: clampedRatio,
+    tone,
+    details
+  };
+}

package/src/features/chat/utils/chat-runtime.utils.ts

@@ -179,7 +179,7 @@ class HistoryMessageBuilder {
   };
 
   private appendAssistantMessage = (message: SessionMessageView): void => {
-    const timestamp = message.timestamp;
+    const { timestamp } = message;
     const text = extractMessageText(message.content).trim();
     if (text) {
       this.appendAssistantText(timestamp, text);

package/src/features/chat/utils/chat-session-preference-governance.utils.test.tsx

@@ -0,0 +1,114 @@
+import { act, renderHook, waitFor } from '@testing-library/react';
+import { useState } from 'react';
+import { describe, expect, it } from 'vitest';
+import type { ChatModelOption } from '@/features/chat/types/chat-input.types';
+import { useSyncSelectedModel } from '@/features/chat/utils/chat-session-preference-governance.utils';
+
+const modelOptions: ChatModelOption[] = [
+  {
+    value: 'minimax/MiniMax-M2.7',
+    modelLabel: 'MiniMax-M2.7',
+    providerLabel: 'MiniMax',
+    thinkingCapability: null
+  },
+  {
+    value: 'deepseek/deepseek-v4-flash',
+    modelLabel: 'deepseek-v4-flash',
+    providerLabel: 'DeepSeek',
+    thinkingCapability: null
+  },
+  {
+    value: 'openai/gpt-5',
+    modelLabel: 'gpt-5',
+    providerLabel: 'OpenAI',
+    thinkingCapability: null
+  }
+];
+
+type HookProps = {
+  fallbackPreferredModel?: string;
+  defaultModel: string;
+};
+
+describe('useSyncSelectedModel', () => {
+  it('replaces an auto-selected global default with the later-arriving recent same-runtime model for a fresh draft session', async () => {
+    const initialProps: HookProps = {
+      fallbackPreferredModel: undefined,
+      defaultModel: 'minimax/MiniMax-M2.7'
+    };
+    const { result, rerender } = renderHook(
+      (props: HookProps) => {
+        const [selectedModel, setSelectedModel] = useState('');
+        useSyncSelectedModel({
+          modelOptions,
+          selectedSessionKey: 'draft-session',
+          selectedSessionExists: false,
+          fallbackPreferredModel: props.fallbackPreferredModel,
+          defaultModel: props.defaultModel,
+          setSelectedModel
+        });
+        return selectedModel;
+      },
+      {
+        initialProps
+      }
+    );
+
+    await waitFor(() => {
+      expect(result.current).toBe('minimax/MiniMax-M2.7');
+    });
+
+    rerender({
+      fallbackPreferredModel: 'deepseek/deepseek-v4-flash',
+      defaultModel: 'minimax/MiniMax-M2.7'
+    });
+
+    await waitFor(() => {
+      expect(result.current).toBe('deepseek/deepseek-v4-flash');
+    });
+  });
+
+  it('does not override a manual model selection when recent same-runtime model data arrives later', async () => {
+    const initialProps: HookProps = {
+      fallbackPreferredModel: undefined,
+      defaultModel: 'minimax/MiniMax-M2.7'
+    };
+    const { result, rerender } = renderHook(
+      (props: HookProps) => {
+        const [selectedModel, setSelectedModel] = useState('');
+        useSyncSelectedModel({
+          modelOptions,
+          selectedSessionKey: 'draft-session',
+          selectedSessionExists: false,
+          fallbackPreferredModel: props.fallbackPreferredModel,
+          defaultModel: props.defaultModel,
+          setSelectedModel
+        });
+        return {
+          selectedModel,
+          setSelectedModel
+        };
+      },
+      {
+        initialProps
+      }
+    );
+
+    await waitFor(() => {
+      expect(result.current.selectedModel).toBe('minimax/MiniMax-M2.7');
+    });
+
+    act(() => {
+      result.current.setSelectedModel('openai/gpt-5');
+    });
+
+    rerender({
+      fallbackPreferredModel: 'deepseek/deepseek-v4-flash',
+      defaultModel: 'minimax/MiniMax-M2.7'
+    });
+
+    await waitFor(() => {
+      expect(result.current.selectedModel).toBe('openai/gpt-5');
+    });
+  });
+});

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

@@ -160,37 +160,14 @@ export function resolveRecentSessionPreferredValue<T>(params: {
   return bestValue;
 }
 
-export function resolveRecentSessionPreferredModel(params: {
-  sessions: readonly SessionEntryView[];
-  selectedSessionKey?: string | null;
-  sessionType?: string | null;
-}): string | undefined {
-  const { sessions, selectedSessionKey, sessionType } = params;
-  return resolveRecentSessionPreferredValue<string>({
-    sessions,
-    selectedSessionKey,
-    sessionType,
-    readPreference: (session) => session.preferredModel?.trim() || undefined
-  });
-}
-
-export function resolveRecentSessionPreferredThinking(params: {
-  sessions: readonly SessionEntryView[];
-  selectedSessionKey?: string | null;
-  sessionType?: string | null;
-}): ThinkingLevel | undefined {
-  const { sessions, selectedSessionKey, sessionType } = params;
-  return resolveRecentSessionPreferredValue<ThinkingLevel>({
-    sessions,
-    selectedSessionKey,
-    sessionType,
-    readPreference: (session) => session.preferredThinking ?? undefined
-  });
+function buildSyncKey(parts: unknown[]): string {
+  return parts.map((part) => (part == null ? '' : String(part))).join('\u0002');
 }
 
 type UseSyncSessionPreferenceParams<T> = {
   isPreferenceAvailable: boolean;
   emptyValue: T;
+  syncKey: string;
   selectedSessionKey?: string | null;
   selectedSessionExists?: boolean;
   setValue: Dispatch<SetStateAction<T>>;
@@ -201,6 +178,7 @@ function useSyncSessionPreference<T>(params: UseSyncSessionPreferenceParams<T>)
   const {
     isPreferenceAvailable,
     emptyValue,
+    syncKey,
     selectedSessionKey,
     selectedSessionExists = false,
     setValue,
@@ -208,27 +186,31 @@ function useSyncSessionPreference<T>(params: UseSyncSessionPreferenceParams<T>)
   } = params;
   const previousSessionKeyRef = useRef<string | null | undefined>(undefined);
   const resolveValueRef = useRef(resolveValue);
-
-  useEffect(() => {
-    resolveValueRef.current = resolveValue;
-  }, [resolveValue]);
+  const lastSyncedValueRef = useRef<T>(emptyValue);
+  resolveValueRef.current = resolveValue;
 
   useEffect(() => {
     const sessionChanged = previousSessionKeyRef.current !== selectedSessionKey;
     if (!isPreferenceAvailable) {
       setValue(emptyValue);
+      lastSyncedValueRef.current = emptyValue;
       previousSessionKeyRef.current = selectedSessionKey;
       return;
     }
-    setValue((prev) =>
-      resolveValueRef.current({
-        currentValue: prev,
+    setValue((prev) => {
+      const next = resolveValueRef.current({
+        currentValue:
+          !sessionChanged && Object.is(prev, lastSyncedValueRef.current)
+            ? emptyValue
+            : prev,
         sessionChanged,
         preserveCurrentValueOnSessionChange: sessionChanged && Boolean(selectedSessionKey) && !selectedSessionExists
-      })
-    );
+      });
+      lastSyncedValueRef.current = next;
+      return next;
+    });
     previousSessionKeyRef.current = selectedSessionKey;
-  }, [emptyValue, isPreferenceAvailable, selectedSessionExists, selectedSessionKey, setValue]);
+  }, [emptyValue, isPreferenceAvailable, selectedSessionExists, selectedSessionKey, setValue, syncKey]);
 }
 
 export function useSyncSelectedModel(params: {
@@ -244,6 +226,12 @@ export function useSyncSelectedModel(params: {
   useSyncSessionPreference<string>({
     isPreferenceAvailable: modelOptions.length > 0,
     emptyValue: '',
+    syncKey: buildSyncKey([
+      modelOptions.map((option) => option.value).join('\u0001'),
+      selectedSessionPreferredModel,
+      fallbackPreferredModel,
+      defaultModel
+    ]),
     selectedSessionKey,
     selectedSessionExists,
     setValue: setSelectedModel,
@@ -273,6 +261,12 @@ export function useSyncSelectedThinking(params: {
   useSyncSessionPreference<ThinkingLevel | null>({
     isPreferenceAvailable: supportedThinkingLevels.length > 0,
     emptyValue: null,
+    syncKey: buildSyncKey([
+      supportedThinkingLevels.join('\u0001'),
+      selectedSessionPreferredThinking,
+      fallbackPreferredThinking,
+      defaultThinkingLevel
+    ]),
     selectedSessionKey,
     selectedSessionExists,
     setValue: setSelectedThinkingLevel,

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

@@ -0,0 +1,165 @@
+import { describe, expect, it } from 'vitest';
+import { t } from '@/shared/lib/i18n';
+import type { SystemStatusView } from '@/features/system-status';
+import {
+  isNcpChatRuntimeBlocked,
+  resolveNcpChatRuntimeMessage,
+  resolveNcpChatSendErrorMessage,
+} from './ncp-chat-runtime-availability.utils';
+
+function createStatus(overrides: Partial<SystemStatusView> = {}): SystemStatusView {
+  return {
+    lifecyclePhase: 'ready',
+    phase: 'ready',
+    connectionStatus: 'connected',
+    hasReachedReady: true,
+    lastReadyAt: Date.now(),
+    recoveryStartedAt: null,
+    bootstrapStatus: {
+      phase: 'ready',
+      ncpAgent: {
+        state: 'ready',
+      },
+      pluginHydration: {
+        state: 'ready',
+        loadedPluginCount: 1,
+        totalPluginCount: 1,
+      },
+      channels: {
+        state: 'ready',
+        enabled: [],
+      },
+      remote: {
+        state: 'pending',
+      },
+    },
+    lastError: null,
+    lastTransportError: null,
+    runtimeControlView: null,
+    runtimeControlError: null,
+    activeSystemAction: null,
+    lastSystemActionError: null,
+    ...overrides,
+  };
+}
+
+describe('ncp-chat-runtime-availability.utils', () => {
+  it('allows chat send when the NCP agent is ready even if the aggregate phase is stalled', () => {
+    expect(isNcpChatRuntimeBlocked(createStatus())).toBe(false);
+    expect(
+      isNcpChatRuntimeBlocked(
+        createStatus({
+          lifecyclePhase: 'stalled',
+          phase: 'stalled',
+          connectionStatus: 'disconnected',
+          recoveryStartedAt: Date.now(),
+        })
+      )
+    ).toBe(false);
+  });
+
+  it('blocks chat send while the NCP agent is not ready', () => {
+    expect(
+      isNcpChatRuntimeBlocked(
+        createStatus({
+          bootstrapStatus: null,
+        })
+      )
+    ).toBe(true);
+  });
+
+  it('uses the startup message during cold start', () => {
+    expect(
+      resolveNcpChatRuntimeMessage(
+        createStatus({
+          lifecyclePhase: 'cold-starting',
+          phase: 'cold-starting',
+          connectionStatus: 'connecting',
+          hasReachedReady: false,
+          lastReadyAt: null,
+        })
+      )
+    ).toBe(t('chatRuntimeInitializing'));
+  });
+
+  it('uses the bootstrap error when startup failed', () => {
+    expect(
+      resolveNcpChatRuntimeMessage(
+        createStatus({
+          lifecyclePhase: 'startup-failed',
+          phase: 'startup-failed',
+          connectionStatus: 'disconnected',
+          hasReachedReady: false,
+          lastReadyAt: null,
+          bootstrapStatus: {
+            phase: 'error',
+            ncpAgent: {
+              state: 'error',
+              error: 'boom',
+            },
+            pluginHydration: {
+              state: 'pending',
+              loadedPluginCount: 0,
+              totalPluginCount: 0,
+            },
+            channels: {
+              state: 'pending',
+              enabled: [],
+            },
+            remote: {
+              state: 'pending',
+            },
+            lastError: 'boom',
+          },
+        })
+      )
+    ).toBe('boom');
+  });
+
+  it('prefers the centralized action message while a system action is running', () => {
+    expect(
+      resolveNcpChatRuntimeMessage(
+        createStatus({
+          activeSystemAction: {
+            action: 'restart-service',
+            lifecycle: 'recovering',
+            serviceState: null,
+            message: 'NextClaw 正在恢复连接',
+          },
+        })
+      )
+    ).toBe('NextClaw 正在恢复连接');
+  });
+
+  it('maps transient chat errors to friendly recovery copy while recovering', () => {
+    expect(
+      resolveNcpChatSendErrorMessage({
+        message: 'NCP fetch failed for POST /api/ncp/agent: Error: Failed to fetch',
+        status: createStatus({
+          lifecyclePhase: 'recovering',
+          phase: 'recovering',
+          connectionStatus: 'connecting',
+          recoveryStartedAt: Date.now(),
+          lastError: 'Failed to fetch',
+          lastTransportError: 'Failed to fetch',
+        }),
+      })
+    ).toBe(t('runtimeControlRecoveringHelp'));
+  });
+
+  it('suppresses transient transport errors after recovery stalls', () => {
+    expect(
+      resolveNcpChatSendErrorMessage({
+        message: 'NCP fetch failed for POST /api/ncp/agent: Error: Failed to fetch',
+        status: createStatus({
+          lifecyclePhase: 'stalled',
+          phase: 'stalled',
+          connectionStatus: 'disconnected',
+          recoveryStartedAt: Date.now(),
+          lastError: 'Failed to fetch',
+          lastTransportError: 'Failed to fetch',
+        }),
+      })
+    ).toBeNull();
+  });
+});