@nextclaw/ui 0.13.8 → 0.13.10-beta.0

package/src/features/right-panel-resources/utils/right-panel-resource-uri.utils.test.ts

@@ -4,11 +4,15 @@ import { createPanelAppRightPanelResourceTarget } from '@/features/right-panel-r
 
 function createPanelAppEntry(overrides: Partial<PanelAppEntryView> = {}): PanelAppEntryView {
   return {
+    appId: 'demo',
+    clientDeclared: false,
+    clientGranted: false,
     contentPath: '/api/panel-apps/demo/content',
     createdAt: '2026-06-02T00:00:00.000Z',
     favorite: false,
     fileName: 'demo.html',
     id: 'demo',
+    kind: 'single-file',
     openCount: 0,
     sizeBytes: 1024,
     title: 'Demo App',

package/src/features/service-apps/components/service-action-authorization-dialog.tsx

@@ -39,11 +39,16 @@ export function ServiceActionAuthorizationDialog() {
         {pending ? (
           <div className="space-y-3 rounded-md border border-gray-100 bg-gray-50 p-3 text-sm">
             <AuthorizationField label={t('serviceActionAuthorizationSource')} value={pending.panelAppId} />
-            <AuthorizationField label={t('serviceActionAuthorizationAction')} value={pending.actionTitle ?? pending.actionId} />
-            {pending.actionDescription ? (
-              <AuthorizationField label={t('serviceActionAuthorizationPurpose')} value={pending.actionDescription} />
-            ) : null}
-            <AuthorizationField label={t('serviceActionAuthorizationRisk')} value={pending.risk ?? 'dangerous'} />
+            <div className="space-y-2">
+              <div className="text-xs font-medium text-gray-500">
+                {t('serviceActionAuthorizationActions')}
+              </div>
+              <div className="max-h-64 space-y-2 overflow-auto">
+                {pending.actions.map((action) => (
+                  <AuthorizationActionItem key={action.actionId} action={action} />
+                ))}
+              </div>
+            </div>
             {pending.inputPreview ? (
               <AuthorizationField label={t('serviceActionAuthorizationInput')} value={pending.inputPreview} />
             ) : null}
@@ -62,6 +67,34 @@ export function ServiceActionAuthorizationDialog() {
   );
 }
 
+function AuthorizationActionItem({
+  action,
+}: {
+  action: {
+    actionId: string;
+    actionTitle?: string;
+    actionDescription?: string;
+    risk?: string;
+  };
+}) {
+  return (
+    <div className="space-y-1 rounded border border-gray-200 bg-white px-3 py-2">
+      <div className="flex items-start justify-between gap-3">
+        <div className="min-w-0 break-words text-xs font-medium text-gray-900">
+          {action.actionTitle ?? action.actionId}
+        </div>
+        <div className="shrink-0 rounded bg-amber-50 px-1.5 py-0.5 text-[11px] font-medium text-amber-700">
+          {action.risk ?? 'dangerous'}
+        </div>
+      </div>
+      <div className="break-words text-[11px] text-gray-500">{action.actionId}</div>
+      {action.actionDescription ? (
+        <div className="break-words text-xs text-gray-600">{action.actionDescription}</div>
+      ) : null}
+    </div>
+  );
+}
+
 function AuthorizationField({
   label,
   value,

package/src/features/service-apps/components/service-apps-panel.tsx

@@ -77,9 +77,9 @@ export function ServiceAppsPanel({
     );
   }
 
-  const apps = serviceApps.data?.entries ?? [];
-  const actions = serviceActions.data?.actions ?? [];
-  const grants = serviceActionGrants.data?.grants ?? [];
+  const apps: ServiceAppRecordView[] = serviceApps.data?.entries ?? [];
+  const actions: ServiceActionView[] = serviceActions.data?.actions ?? [];
+  const grants: ServiceActionGrantView[] = serviceActionGrants.data?.grants ?? [];
   const discover = (appId: string) => {
     void discoverServiceAppActions.mutateAsync(appId).then((result) => {
       setDiscoveredActionsByApp((current) => ({

package/src/features/service-apps/stores/service-action-authorization.store.ts

@@ -3,13 +3,17 @@ import type { ServiceActionListView } from '@nextclaw/client-sdk';
 
 type ServiceActionRisk = ServiceActionListView['actions'][number]['risk'];
 
-export type ServiceActionAuthorizationRequest = {
-  id: string;
-  panelAppId: string;
+export type ServiceActionAuthorizationItem = {
   actionId: string;
   actionTitle?: string;
   actionDescription?: string;
   risk?: ServiceActionRisk;
+};
+
+export type ServiceActionAuthorizationRequest = {
+  id: string;
+  panelAppId: string;
+  actions: ServiceActionAuthorizationItem[];
   inputPreview?: string;
 };
 

package/src/features/system-status/components/desktop-update-config.test.tsx

@@ -4,6 +4,7 @@ import { beforeEach, describe, expect, it, vi } from 'vitest';
 import { useRuntimeUpdateStore } from '@/features/system-status';
 import { DesktopUpdateConfig } from '@/features/system-status/components/desktop-update-config';
 import { setLanguage } from '@/shared/lib/i18n';
+import type * as SystemStatusModule from '@/features/system-status';
 
 const mocks = vi.hoisted(() => ({
   start: vi.fn(),
@@ -16,7 +17,7 @@ const mocks = vi.hoisted(() => ({
 }));
 
 vi.mock('@/features/system-status', async () => {
-  const actual = await vi.importActual<typeof import('@/features/system-status')>(
+  const actual = await vi.importActual<typeof SystemStatusModule>(
     '@/features/system-status'
   );
   return {

package/src/features/system-status/hooks/use-system-status.ts

@@ -17,10 +17,7 @@ export function useSystemStatusSources() {
       timeoutMs: 5_000,
     }),
     refetchInterval: (query) => {
-      return systemStatusManager.getRuntimeBootstrapPollInterval(
-        query.state.data,
-        query.state.fetchFailureCount
-      );
+      return systemStatusManager.getRuntimeBootstrapPollInterval(query.state.data);
     },
     retry: false,
   });

package/src/features/system-status/managers/system-status.manager.bootstrap-polling.test.ts

@@ -1,17 +1,77 @@
-import { beforeEach, describe, expect, it } from 'vitest';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import { systemStatusManager } from './system-status.manager';
-import { useSystemStatusStore } from '@/features/system-status/stores/system-status.store';
+import { appQueryClient } from '@/app-query-client';
+import type { BootstrapStatusView } from '@/shared/lib/api';
+
+const initializingBootstrapStatus: BootstrapStatusView = {
+  phase: 'shell-ready',
+  ncpAgent: {
+    state: 'running',
+  },
+  extensionLoading: {
+    state: 'pending',
+    loadedExtensionCount: 0,
+    totalExtensionCount: 0,
+  },
+  channels: {
+    state: 'pending',
+    enabled: [],
+  },
+  remote: {
+    state: 'pending',
+  },
+};
+
+const errorBootstrapStatus: BootstrapStatusView = {
+  phase: 'error',
+  ncpAgent: {
+    state: 'error',
+    error: 'startup failed',
+  },
+  extensionLoading: {
+    state: 'pending',
+    loadedExtensionCount: 0,
+    totalExtensionCount: 0,
+  },
+  channels: {
+    state: 'pending',
+    enabled: [],
+  },
+  remote: {
+    state: 'pending',
+  },
+  lastError: 'startup failed',
+};
+
+const readyBootstrapStatus: BootstrapStatusView = {
+  phase: 'ready',
+  ncpAgent: {
+    state: 'ready',
+  },
+  extensionLoading: {
+    state: 'ready',
+    loadedExtensionCount: 1,
+    totalExtensionCount: 1,
+  },
+  channels: {
+    state: 'ready',
+    enabled: [],
+  },
+  remote: {
+    state: 'disabled',
+  },
+};
 
 describe('getRuntimeBootstrapPollInterval', () => {
   beforeEach(() => {
-    useSystemStatusStore.setState({
-      state: {
-        ...useSystemStatusStore.getState().state,
-        lifecyclePhase: 'cold-starting',
-        hasReachedReady: false,
-        activeSystemAction: null,
-      },
-    });
+    vi.useFakeTimers();
+    systemStatusManager.resetForTests();
+  });
+
+  afterEach(() => {
+    systemStatusManager.resetForTests();
+    vi.restoreAllMocks();
+    vi.useRealTimers();
   });
 
   it('keeps polling while bootstrap status is missing', () => {
@@ -22,115 +82,92 @@ describe('getRuntimeBootstrapPollInterval', () => {
 
   it('keeps polling while ncp agent is still initializing', () => {
     expect(
-      systemStatusManager.getRuntimeBootstrapPollInterval({
-        phase: 'shell-ready',
-        ncpAgent: {
-          state: 'running',
-        },
-        extensionLoading: {
-          state: 'pending',
-          loadedExtensionCount: 0,
-          totalExtensionCount: 0,
-        },
-        channels: {
-          state: 'pending',
-          enabled: [],
-        },
-        remote: {
-          state: 'pending',
-        },
-      })
+      systemStatusManager.getRuntimeBootstrapPollInterval(
+        initializingBootstrapStatus
+      )
     ).toBe(1000);
   });
 
-  it('continues polling even when bootstrap status reports an ncp agent error', () => {
+  it('starts hot backoff when bootstrap status reports an ncp agent error', () => {
+    systemStatusManager.reportBootstrapStatus(errorBootstrapStatus);
+
     expect(
-      systemStatusManager.getRuntimeBootstrapPollInterval({
-        phase: 'error',
-        ncpAgent: {
-          state: 'error',
-          error: 'startup failed',
-        },
-        extensionLoading: {
-          state: 'pending',
-          loadedExtensionCount: 0,
-          totalExtensionCount: 0,
-        },
-        channels: {
-          state: 'pending',
-          enabled: [],
-        },
-        remote: {
-          state: 'pending',
-        },
-        lastError: 'startup failed',
-      })
-    ).toBe(2000);
+      systemStatusManager.getRuntimeBootstrapPollInterval(errorBootstrapStatus)
+    ).toBe(500);
   });
 
   it('stops polling once the ncp agent is ready', () => {
     expect(
-      systemStatusManager.getRuntimeBootstrapPollInterval({
-        phase: 'ready',
-        ncpAgent: {
-          state: 'ready',
-        },
-        extensionLoading: {
-          state: 'ready',
-          loadedExtensionCount: 1,
-          totalExtensionCount: 1,
-        },
-        channels: {
-          state: 'ready',
-          enabled: [],
-        },
-        remote: {
-          state: 'disabled',
-        },
-      })
+      systemStatusManager.getRuntimeBootstrapPollInterval(readyBootstrapStatus)
     ).toBe(false);
   });
 
   it('keeps polling while the runtime is recovering even if the last bootstrap status was ready', () => {
-    useSystemStatusStore.setState({
-      state: {
-        ...useSystemStatusStore.getState().state,
-        lifecyclePhase: 'recovering',
-        hasReachedReady: true,
-        lastReadyAt: Date.now(),
-        recoveryStartedAt: Date.now(),
-      },
-    });
+    systemStatusManager.reportBootstrapStatus(readyBootstrapStatus);
+    systemStatusManager.handleConnectionInterrupted('websocket error');
 
     expect(
-      systemStatusManager.getRuntimeBootstrapPollInterval({
-        phase: 'ready',
-        ncpAgent: {
-          state: 'ready',
-        },
-        extensionLoading: {
-          state: 'ready',
-          loadedExtensionCount: 1,
-          totalExtensionCount: 1,
-        },
-        channels: {
-          state: 'ready',
-          enabled: [],
-        },
-        remote: {
-          state: 'disabled',
-        },
-      })
-    ).toBe(1000);
+      systemStatusManager.getRuntimeBootstrapPollInterval(readyBootstrapStatus)
+    ).toBe(500);
   });
 
   it('backs off polling after transport failures', () => {
+    systemStatusManager.reportBootstrapQueryError(new Error('Failed to fetch'));
+    expect(systemStatusManager.getRuntimeBootstrapPollInterval(undefined)).toBe(
+      500
+    );
+
+    systemStatusManager.reportBootstrapQueryError(new Error('Failed to fetch'));
     expect(
-      systemStatusManager.getRuntimeBootstrapPollInterval(undefined, 1)
-    ).toBe(2000);
+      systemStatusManager.getRuntimeBootstrapPollInterval(undefined)
+    ).toBe(1000);
+
+    systemStatusManager.reportBootstrapQueryError(new Error('Failed to fetch'));
     expect(
-      systemStatusManager.getRuntimeBootstrapPollInterval(undefined, 3)
-    ).toBe(5000);
+      systemStatusManager.getRuntimeBootstrapPollInterval(undefined)
+    ).toBe(2000);
+  });
+
+  it('slows down after the hot recovery and long failure windows', async () => {
+    systemStatusManager.reportBootstrapQueryError(new Error('Failed to fetch'));
+
+    await vi.advanceTimersByTimeAsync(31_000);
+    expect(systemStatusManager.getRuntimeBootstrapPollInterval(undefined)).toBe(
+      10_000
+    );
+
+    systemStatusManager.reportBootstrapQueryError(new Error('Failed to fetch'));
+    systemStatusManager.reportBootstrapQueryError(new Error('Failed to fetch'));
+    expect(systemStatusManager.getRuntimeBootstrapPollInterval(undefined)).toBe(
+      30_000
+    );
+
+    await vi.advanceTimersByTimeAsync(5 * 60_000);
+    expect(systemStatusManager.getRuntimeBootstrapPollInterval(undefined)).toBe(
+      60_000
+    );
   });
 
+  it('lets manual runtime probe trigger one immediate interval after readiness stopped polling', async () => {
+    const refetchQueriesSpy = vi
+      .spyOn(appQueryClient, 'refetchQueries')
+      .mockResolvedValue(undefined as never);
+
+    systemStatusManager.reportBootstrapStatus(readyBootstrapStatus);
+    expect(
+      systemStatusManager.getRuntimeBootstrapPollInterval(readyBootstrapStatus)
+    ).toBe(false);
+
+    systemStatusManager.requestRuntimeBootstrapProbeNow();
+
+    expect(refetchQueriesSpy).toHaveBeenCalledWith({
+      queryKey: ['runtime-bootstrap-status'],
+    });
+    expect(
+      systemStatusManager.getRuntimeBootstrapPollInterval(readyBootstrapStatus)
+    ).toBe(0);
+    expect(
+      systemStatusManager.getRuntimeBootstrapPollInterval(readyBootstrapStatus)
+    ).toBe(false);
+  });
 });

package/src/features/system-status/managers/system-status.manager.ts

@@ -22,12 +22,18 @@ import {
   useSystemStatusStore,
 } from '@/features/system-status/stores/system-status.store';
 import { isTransientRuntimeConnectionErrorMessage } from '@/shared/lib/transport';
+import { AdaptiveCadence } from '@/shared/lib/cadence';
 
 const RECOVERY_TIMEOUT_MS = 30_000;
-const RUNTIME_BOOTSTRAP_PROBE_POLICY = {
-  activePollIntervalMs: 1_000,
-  errorPollIntervalMs: 2_000,
-  maxErrorPollIntervalMs: 5_000,
+const RUNTIME_BOOTSTRAP_PROBE_CADENCE = {
+  idleDelayMs: 1_000,
+  manualTriggerDelayMs: 0,
+  successDelayMs: false,
+  stages: [
+    { untilElapsedMs: 30_000, delaysMs: [500, 1_000, 2_000, 4_000, 5_000] },
+    { untilElapsedMs: 5 * 60_000, delaysMs: [10_000, 15_000, 30_000] },
+    { delaysMs: [60_000] },
+  ],
 } as const;
 
 function getErrorMessage(error: unknown): string {
@@ -61,32 +67,29 @@ function resolveActionHelp(action: RuntimeControlAction): string {
 
 export class SystemStatusManager {
   private recoveryTimeoutId: number | null = null;
+  private readonly runtimeBootstrapProbeCadence = new AdaptiveCadence(
+    RUNTIME_BOOTSTRAP_PROBE_CADENCE,
+  );
 
   getRuntimeBootstrapPollInterval = (
     status: BootstrapStatusView | null | undefined,
-    fetchFailureCount = 0
   ): number | false => {
     const { lifecyclePhase, activeSystemAction } = this.getState();
-    if (fetchFailureCount > 0) {
-      return Math.min(
-        RUNTIME_BOOTSTRAP_PROBE_POLICY.maxErrorPollIntervalMs,
-        RUNTIME_BOOTSTRAP_PROBE_POLICY.errorPollIntervalMs * fetchFailureCount
-      );
-    }
-    if (
+    const isRecovering =
       lifecyclePhase === 'recovering' ||
       lifecyclePhase === 'stalled' ||
-      activeSystemAction?.lifecycle === 'recovering'
-    ) {
-      return RUNTIME_BOOTSTRAP_PROBE_POLICY.activePollIntervalMs;
+      activeSystemAction?.lifecycle === 'recovering';
+    if (this.runtimeBootstrapProbeCadence.hasManualTrigger()) {
+      return this.runtimeBootstrapProbeCadence.getNextDelay({
+        consumeManualTrigger: true,
+      });
     }
-    if (status?.ncpAgent.state === 'ready') {
+    if (!isRecovering && status?.ncpAgent.state === 'ready') {
       return false;
     }
-    if (status?.ncpAgent.state === 'error' || status?.phase === 'error') {
-      return RUNTIME_BOOTSTRAP_PROBE_POLICY.errorPollIntervalMs;
-    }
-    return RUNTIME_BOOTSTRAP_PROBE_POLICY.activePollIntervalMs;
+    return this.runtimeBootstrapProbeCadence.getNextDelay({
+      consumeManualTrigger: true,
+    });
   };
 
   getRuntimeControl = async (): Promise<RuntimeControlView> => {
@@ -137,6 +140,7 @@ export class SystemStatusManager {
     }
     const state = this.getState();
     if (!state.hasReachedReady) {
+      this.runtimeBootstrapProbeCadence.recordFailure();
       this.patchState({
         lastTransportError: message,
       });
@@ -150,6 +154,7 @@ export class SystemStatusManager {
     const state = this.getState();
     const normalizedMessage = message?.trim() || null;
     if (!state.hasReachedReady) {
+      this.runtimeBootstrapProbeCadence.recordFailure();
       if (normalizedMessage) {
         this.patchState({
           lastTransportError: normalizedMessage,
@@ -215,6 +220,7 @@ export class SystemStatusManager {
           message: t('runtimeControlRecoveringHelp'),
         },
       });
+      this.runtimeBootstrapProbeCadence.requestManualTrigger();
 
       const recoveredView = await this.waitForRecovery();
       this.syncRuntimeControlQueryCache(recoveredView);
@@ -240,8 +246,16 @@ export class SystemStatusManager {
 
   getStatusView = () => toSystemStatusView(this.getState());
 
+  requestRuntimeBootstrapProbeNow = (): void => {
+    this.runtimeBootstrapProbeCadence.requestManualTrigger();
+    void appQueryClient.refetchQueries({
+      queryKey: ['runtime-bootstrap-status'],
+    });
+  };
+
   resetForTests = (): void => {
     this.clearRecoveryTimeout();
+    this.runtimeBootstrapProbeCadence.reset();
     useSystemStatusStore.setState({
       state: initialSystemStatusState,
     });
@@ -258,6 +272,7 @@ export class SystemStatusManager {
   private transitionToColdStarting = (
     bootstrapStatus: BootstrapStatusView
   ): void => {
+    this.runtimeBootstrapProbeCadence.recordFailure();
     this.clearRecoveryTimeout();
     this.patchState({
       lifecyclePhase: 'cold-starting',
@@ -271,6 +286,7 @@ export class SystemStatusManager {
     errorMessage: string | null,
     bootstrapStatus?: BootstrapStatusView
   ): void => {
+    this.runtimeBootstrapProbeCadence.recordFailure();
     this.clearRecoveryTimeout();
     this.patchState({
       lifecyclePhase: 'startup-failed',
@@ -284,6 +300,7 @@ export class SystemStatusManager {
     errorMessage: string | null,
     bootstrapStatus?: BootstrapStatusView
   ): void => {
+    this.runtimeBootstrapProbeCadence.recordFailure();
     const state = this.getState();
     if (!state.hasReachedReady) {
       this.patchState({
@@ -321,6 +338,7 @@ export class SystemStatusManager {
   private transitionToReady = (
     bootstrapStatus: BootstrapStatusView | null
   ): void => {
+    this.runtimeBootstrapProbeCadence.recordSuccess();
     const state = this.getState();
     const shouldRefreshQueries =
       state.lifecyclePhase === 'recovering' || state.lifecyclePhase === 'stalled';

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

@@ -7,7 +7,6 @@ import { Input } from '@/shared/components/ui/input';
 import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from '@/shared/components/ui/select';
 import { Card, CardContent } from '@/shared/components/ui/card';
 import {
-  describeCronDelivery,
   describeCronSchedule,
   describeCronSession,
   formatCronDate,
@@ -26,9 +25,7 @@ function matchQuery(job: CronJobView, query: string): boolean {
     job.id,
     job.name,
     job.payload.message,
-    job.payload.sessionId ?? '',
-    job.payload.channel ?? '',
-    job.payload.to ?? ''
+    job.payload.sessionId ?? ''
   ].join(' ').toLowerCase();
   return haystack.includes(q);
 }
@@ -64,7 +61,6 @@ function CronJobCard(props: {
             <div className="mt-2 text-xs text-gray-500">{t('cronScheduleLabel')}: {describeCronSchedule(job)}</div>
             <div className="mt-2 whitespace-pre-wrap break-words text-sm text-gray-700">{job.payload.message}</div>
             <div className="mt-2 text-xs text-gray-500">{t('cronSessionLabel')}: {describeCronSession(job)}</div>
-            <div className="mt-2 text-xs text-gray-500">{t('cronDeliverTo')}: {describeCronDelivery(job)}</div>
           </div>
           <div className="min-w-[220px] space-y-2 text-xs text-gray-500">
             <div><span className="font-medium text-gray-700">{t('cronNextRun')}:</span> {formatCronDate(job.state.nextRunAt)}</div>

package/src/shared/lib/api/index.ts

@@ -11,7 +11,7 @@ export * from './utils/mcp-marketplace.utils';
 export * from './utils/ncp-attachments.utils';
 export * from './utils/ncp-session.utils';
 export * from './ncp-session.types';
-export * from './ncp-session-query-cache';
+export * from './ncp-session-query-cache.utils';
 export * from './raw-client.utils';
 export * from './utils/remote.utils';
 export * from './remote.types';

package/src/shared/lib/api/{ncp-session-query-cache.test.ts → ncp-session-query-cache.utils.test.ts}

@@ -131,6 +131,29 @@ describe('ncp-session-query-cache', () => {
     });
   });
 
+  it('keeps the realtime running overlay when a newer persisted idle summary arrives', () => {
+    const current = updateNcpSessionRunStatusList(createSessionsList(), {
+      sessionKey: 'session-1',
+      status: 'running'
+    });
+
+    const updated = upsertNcpSessionSummaryList(current, {
+      sessionId: 'session-1',
+      messageCount: 2,
+      createdAt: '2026-03-29T08:00:00.000Z',
+      updatedAt: '2026-03-29T10:01:00.000Z',
+      lastMessageAt: '2026-03-29T10:01:00.000Z',
+      status: 'idle',
+      metadata: { last_activity_preview: { state: 'running' } }
+    });
+
+    expect(updated?.sessions[0]).toMatchObject({
+      sessionId: 'session-1',
+      messageCount: 2,
+      status: 'running'
+    });
+  });
+
   it('applies realtime upsert/delete events to every ncp-sessions query cache entry', () => {
     const queryClient = new QueryClient();
     queryClient.setQueryData(['ncp-sessions', 200], createSessionsList());

package/src/shared/lib/api/{ncp-session-query-cache.ts → ncp-session-query-cache.utils.ts}

@@ -14,18 +14,11 @@ function shouldReplaceSessionSummary(
   next: NcpSessionSummaryView
 ): boolean {
   const timeOrder = next.updatedAt.localeCompare(current.updatedAt);
-  if (timeOrder > 0) {
-    return true;
-  }
-  if (timeOrder < 0) {
-    return false;
-  }
-
-  if (current.status === next.status) {
-    return true;
+  if (timeOrder !== 0) {
+    return timeOrder > 0;
   }
 
-  return next.status === 'idle';
+  return current.status === next.status || next.status === 'idle';
 }
 
 export function upsertNcpSessionSummaryList(
@@ -40,7 +33,12 @@ export function upsertNcpSessionSummaryList(
   const nextSessions =
     existingIndex >= 0
       ? current.sessions.map((session, index) =>
-          index === existingIndex && shouldReplaceSessionSummary(session, summary) ? summary : session
+          index === existingIndex && shouldReplaceSessionSummary(session, summary)
+            ? {
+                ...summary,
+                status: session.status === 'running' && summary.status === 'idle' ? 'running' : summary.status
+              }
+            : session
         )
       : [...current.sessions, summary];
   const sortedSessions = sortSessionSummaries(nextSessions);

package/src/shared/lib/api/types.ts

@@ -363,7 +363,9 @@ export type ServerPathReadView = { requestedPath: string; resolvedPath: string;
 
 export type PanelAppEntryView = {
   id: string;
+  appId: string;
   fileName: string;
+  kind: "single-file" | "folder";
   title: string;
   description?: string;
   icon?: string;
@@ -372,6 +374,8 @@ export type PanelAppEntryView = {
   updatedAt: string;
   sizeBytes: number;
   favorite: boolean;
+  clientDeclared: boolean;
+  clientGranted: boolean;
   lastOpenedAt?: string;
   openCount: number;
 };
@@ -402,10 +406,6 @@ export type CronPayloadView = {
   message: string;
   agentId?: string | null;
   sessionId?: string | null;
-  deliver?: boolean;
-  channel?: string | null;
-  to?: string | null;
-  accountId?: string | null;
 };
 
 export type CronJobStateView = {