@marimo-team/islands 0.25.3-dev267 → 0.25.3-dev268

package/src/__tests__/CellStatus.test.tsx

@@ -3,7 +3,7 @@
 import { render } from "@testing-library/react";
 import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
 import { TooltipProvider } from "@/components/ui/tooltip";
-import { formatElapsedTime, type Seconds } from "@/utils/time";
+import { formatElapsedTime, type Milliseconds } from "@/utils/time";
 import {
   CellStatusComponent,
   ElapsedTime,
@@ -76,8 +76,8 @@ describe("CellStatusComponent", () => {
     status: "idle" as const,
     interrupted: false,
     elapsedTime: null,
-    runStartTimestamp: null,
-    lastRunStartTimestamp: null,
+    startedAt: null,
+    blocked: false,
     uninstantiated: false,
   };
 
@@ -95,7 +95,7 @@ describe("CellStatusComponent", () => {
       ...baseProps,
       disabled: true,
       staleInputs: true,
-      lastRunStartTimestamp: 1_704_096_000 as Seconds, // Jan 1, 2024 12:00:00
+      startedAt: 1_704_096_000_000 as Milliseconds, // Jan 1, 2024 12:00:00
     };
 
     const { container } = render(
@@ -110,7 +110,7 @@ describe("CellStatusComponent", () => {
     const props = {
       ...baseProps,
       disabled: true,
-      lastRunStartTimestamp: 1_704_096_000 as Seconds,
+      startedAt: 1_704_096_000_000 as Milliseconds,
     };
 
     const { container } = render(
@@ -124,8 +124,8 @@ describe("CellStatusComponent", () => {
   test("renders disabled transitively state", () => {
     const props = {
       ...baseProps,
-      status: "disabled-transitively" as const,
-      lastRunStartTimestamp: 1_704_096_000 as Seconds,
+      blocked: true,
+      startedAt: 1_704_096_000_000 as Milliseconds,
     };
 
     const { container } = render(
@@ -139,9 +139,9 @@ describe("CellStatusComponent", () => {
   test("renders stale and disabled transitively state", () => {
     const props = {
       ...baseProps,
-      status: "disabled-transitively" as const,
+      blocked: true,
       staleInputs: true,
-      lastRunStartTimestamp: 1_704_096_000 as Seconds,
+      startedAt: 1_704_096_000_000 as Milliseconds,
     };
 
     const { container } = render(
@@ -156,8 +156,7 @@ describe("CellStatusComponent", () => {
     const props = {
       ...baseProps,
       status: "running" as const,
-      runStartTimestamp: 1_704_096_000 as Seconds,
-      lastRunStartTimestamp: 1_704_096_000 as Seconds,
+      startedAt: 1_704_096_000_000 as Milliseconds,
     };
 
     const { container } = render(
@@ -172,7 +171,7 @@ describe("CellStatusComponent", () => {
     const props = {
       ...baseProps,
       status: "queued" as const,
-      lastRunStartTimestamp: 1_704_096_000 as Seconds,
+      startedAt: 1_704_096_000_000 as Milliseconds,
     };
 
     const { container } = render(
@@ -201,8 +200,8 @@ describe("CellStatusComponent", () => {
     const props = {
       ...baseProps,
       interrupted: true,
-      elapsedTime: 1500,
-      lastRunStartTimestamp: 1_704_096_000 as Seconds,
+      elapsedTime: 1500 as Milliseconds,
+      startedAt: 1_704_096_000_000 as Milliseconds,
     };
 
     const { container } = render(
@@ -217,8 +216,8 @@ describe("CellStatusComponent", () => {
     const props = {
       ...baseProps,
       edited: true,
-      elapsedTime: 1500,
-      lastRunStartTimestamp: 1_704_096_000 as Seconds,
+      elapsedTime: 1500 as Milliseconds,
+      startedAt: 1_704_096_000_000 as Milliseconds,
     };
 
     const { container } = render(
@@ -233,8 +232,8 @@ describe("CellStatusComponent", () => {
     const props = {
       ...baseProps,
       staleInputs: true,
-      elapsedTime: 1500,
-      lastRunStartTimestamp: 1_704_096_000 as Seconds,
+      elapsedTime: 1500 as Milliseconds,
+      startedAt: 1_704_096_000_000 as Milliseconds,
     };
 
     const { container } = render(
@@ -248,8 +247,8 @@ describe("CellStatusComponent", () => {
   test("renders completed run with elapsed time", () => {
     const props = {
       ...baseProps,
-      elapsedTime: 1500,
-      lastRunStartTimestamp: 1_704_096_000 as Seconds,
+      elapsedTime: 1500 as Milliseconds,
+      startedAt: 1_704_096_000_000 as Milliseconds,
     };
 
     const { container } = render(

package/src/components/dependency-graph/minimap-content.tsx

@@ -7,11 +7,12 @@ import {
   cellGraphsAtom,
   isVariableAffectedBySelectedCell,
 } from "@/components/editor/chrome/wrapper/minimap-state";
-import { useCellData, useCellRuntime } from "@/core/cells/cells";
+import { useCellData } from "@/core/cells/cells";
 import { useCellActions } from "@/core/cells/actions";
 import { cellFocusAtom, useCellFocusActions } from "@/core/cells/focus";
 import type { CellId } from "@/core/cells/ids";
 import { useLayout } from "@/core/cells/layout";
+import { useCellExecution } from "@/core/executions";
 import { useVariables } from "@/core/variables/state";
 import { cn } from "@/utils/cn";
 import { extractCellPreview } from "./utils/cell-preview";
@@ -32,7 +33,7 @@ const MinimapCell: React.FC<MinimapCellProps> = (props) => {
     id: props.cellId,
     graph: graphs[props.cellId],
     code: useCellData(props.cellId).code,
-    hasError: useCellRuntime(props.cellId).errored,
+    hasError: useCellExecution(props.cellId).outcome === "error",
   };
 
   let selectedCell: undefined | { id: CellId; graph: CellGraph };

package/src/components/editor/__tests__/data-attributes.test.tsx

@@ -104,16 +104,9 @@ describe("Cell data attributes", () => {
       });
 
       notebook.cellRuntime[cid] = createCellRuntimeState({
-        status: "idle",
         output: null,
         consoleOutputs: [],
-        interrupted: false,
-        errored: false,
-        stopped: false,
         staleInputs: false,
-        runStartTimestamp: null,
-        lastRunStartTimestamp: null,
-        runElapsedTimeMs: null,
         debuggerActive: false,
         outline: null,
       });

package/src/components/editor/__tests__/output-persistence.test.tsx

@@ -4,6 +4,7 @@ import { createStore, Provider } from "jotai";
 import { beforeAll, describe, expect, it } from "vitest";
 import { SetupMocks } from "@/__mocks__/common";
 import { mockDocumentModel } from "@/__mocks__/document";
+import { MockExecutions } from "@/__mocks__/executions";
 import { MockNotebook } from "@/__mocks__/notebook";
 import { MockRequestClient } from "@/__mocks__/requests";
 import { cellId } from "@/__tests__/branded";
@@ -50,7 +51,6 @@ function seedNotebook(
     },
   });
   notebook.cellRuntime[cid] = createCellRuntimeState({
-    status: "idle",
     output: {
       channel: "output",
       mimetype: "text/html",
@@ -207,8 +207,8 @@ describe("output persistence across mode changes", () => {
 
   it("hides errored cells while presenting without unmounting them", () => {
     const { store, wrapper } = createTestWrapper();
+    MockExecutions.seed(store, [MockExecutions.errored(cid)]);
     seedNotebook(store, {
-      errored: true,
       output: {
         channel: "marimo-error",
         mimetype: "application/vnd.marimo+error",

package/src/components/editor/actions/__tests__/useCellActionButton.test.tsx

@@ -52,6 +52,7 @@ function renderActions(cellId: CellId, name: string, edit?: Edit) {
           name,
           config: { disabled: false, hide_code: false, column: null },
           status: "idle",
+          blocked: false,
           hasOutput: false,
           hasConsoleOutput: false,
           getEditorView: () => null,

package/src/components/editor/actions/useCellActionButton.tsx

@@ -56,7 +56,8 @@ import {
   appWidthAtom,
   autoInstantiateAtom,
 } from "@/core/config/config";
-import type { CellConfig, RuntimeState } from "@/core/network/types";
+import type { CellRunStatus } from "@/core/executions";
+import type { CellConfig } from "@/core/network/types";
 import { canEditAtom } from "@/core/notebook";
 import { canLinkToCell, createCellLink } from "@/utils/cell-urls";
 import { copyToClipboard } from "@/utils/copy";
@@ -74,7 +75,9 @@ export interface CellActionButtonProps extends Pick<
   "name" | "config"
 > {
   cellId: CellId;
-  status: RuntimeState;
+  status: CellRunStatus;
+  /** Whether a cell it depends on is disabled. */
+  blocked: boolean;
   hasOutput: boolean;
   hasConsoleOutput: boolean;
   getEditorView: () => EditorView | null;
@@ -121,6 +124,7 @@ export function useCellActionButtons({ cell, closePopover }: Props) {
     hasOutput,
     hasConsoleOutput,
     status,
+    blocked,
   } = cell;
 
   const toggleDisabled = () => {
@@ -155,7 +159,7 @@ export function useCellActionButtons({ cell, closePopover }: Props) {
         hidden:
           status === "running" ||
           status === "queued" ||
-          status === "disabled-transitively" ||
+          blocked ||
           config.disabled,
         redundant: true,
         handle: () => runCell(),

package/src/components/editor/alerts/stdin-blocking-alert.tsx

@@ -2,6 +2,7 @@
 
 import { atom, useAtomValue } from "jotai";
 import { notebookAtom } from "@/core/cells/cells";
+import { cellExecutionInputsAtom, cellExecutionView } from "@/core/executions";
 import { Logger } from "@/utils/Logger";
 import { Button } from "../../ui/button";
 import { Kbd } from "../../ui/kbd";
@@ -10,12 +11,13 @@ import { FloatingAlert } from "./floating-alert";
 // Atom to check if there is a cell with unresolved stdin
 const hasBlockingStdinAtom = atom((get) => {
   const notebook = get(notebookAtom);
+  const executions = get(cellExecutionInputsAtom);
 
   // Check each cell in order
   for (const cellId of notebook.cellIds) {
     // Check if the cell is idle and has unresolved stdin
     const runtime = notebook.cellRuntime[cellId];
-    if (runtime.status === "idle") {
+    if (cellExecutionView(executions, cellId).status === "idle") {
       const hasUnresolvedStdin = runtime.consoleOutputs.some(
         (output) => output.channel === "stdin" && output.response === undefined,
       );

package/src/components/editor/cell/CellStatus.tsx

@@ -7,24 +7,29 @@ import {
 } from "lucide-react";
 import { useDateFormatter } from "react-aria";
 import { MultiIcon } from "@/components/icons/multi-icon";
+import type { CellRunStatus } from "@/core/executions";
 import { Logger } from "@/utils/Logger";
-import type { CellRuntimeState } from "../../../core/cells/types";
 import { useElapsedTime } from "../../../hooks/useElapsedTime";
 import { Tooltip } from "../../ui/tooltip";
 
 import "./cell-status.css";
 import { formatDistanceToNow } from "date-fns";
-import { formatElapsedTime, Time } from "@/utils/time";
+import { formatElapsedTime, type Milliseconds, Time } from "@/utils/time";
 
-export interface CellStatusComponentProps extends Pick<
-  CellRuntimeState,
-  "status" | "runStartTimestamp" | "interrupted" | "lastRunStartTimestamp"
-> {
+export interface CellStatusComponentProps {
   editing: boolean;
   edited: boolean;
   disabled: boolean;
+  /** Whether a cell it depends on is disabled. */
+  blocked: boolean;
   staleInputs: boolean;
-  elapsedTime: number | null;
+  status: CellRunStatus;
+  /** Whether the cell's last run was interrupted. */
+  interrupted: boolean;
+  /** How long the last run took, once it has ended. */
+  elapsedTime: Milliseconds | null;
+  /** When the current run started, or the last one, since the epoch. */
+  startedAt: Milliseconds | null;
   uninstantiated: boolean;
 }
 
@@ -32,20 +37,21 @@ export const CellStatusComponent: React.FC<CellStatusComponentProps> = ({
   editing,
   status,
   disabled,
+  blocked,
   staleInputs,
   edited,
   interrupted,
   elapsedTime,
-  runStartTimestamp,
-  lastRunStartTimestamp,
+  startedAt,
   uninstantiated,
 }) => {
   if (!editing) {
     return null;
   }
 
-  const start = runStartTimestamp ?? lastRunStartTimestamp;
-  const lastRanTime = start ? <LastRanTime lastRanTime={start} /> : null;
+  const lastRanTime = startedAt ? (
+    <LastRanTime lastRanTime={startedAt} />
+  ) : null;
 
   // unexpected states
   if (disabled && status === "running") {
@@ -103,7 +109,7 @@ export const CellStatusComponent: React.FC<CellStatusComponentProps> = ({
   }
 
   // disabled from parent
-  if (!staleInputs && status === "disabled-transitively") {
+  if (!staleInputs && blocked) {
     return (
       <Tooltip
         content={
@@ -131,7 +137,7 @@ export const CellStatusComponent: React.FC<CellStatusComponentProps> = ({
   }
 
   // stale from parent being disabled
-  if (staleInputs && status === "disabled-transitively") {
+  if (staleInputs && blocked) {
     return (
       <Tooltip
         content={
@@ -175,9 +181,7 @@ export const CellStatusComponent: React.FC<CellStatusComponentProps> = ({
           data-testid="cell-status"
           data-status="running"
         >
-          <CellTimer
-            startTime={Time.fromSeconds(runStartTimestamp) || Time.now()}
-          />
+          <CellTimer startTime={startedAt ?? Time.now().toMilliseconds()} />
         </div>
       </Tooltip>
     );
@@ -307,7 +311,7 @@ export const ElapsedTime = (props: { elapsedTime: string }) => {
   );
 };
 const LastRanTime = (props: { lastRanTime: number }) => {
-  const date = new Date(props.lastRanTime * 1000);
+  const date = new Date(props.lastRanTime);
   const today = new Date();
 
   // Looks like HH:MM:SS.SSS AM/PM
@@ -348,7 +352,7 @@ const LastRanTime = (props: { lastRanTime: number }) => {
   );
 };
 
-const CellTimer = (props: { startTime: Time }) => {
-  const time = useElapsedTime(props.startTime.toMilliseconds());
+const CellTimer = (props: { startTime: Milliseconds }) => {
+  const time = useElapsedTime(props.startTime);
   return <span>{formatElapsedTime(time)}</span>;
 };

package/src/components/editor/cell/RunButton.tsx

@@ -1,7 +1,8 @@
 /* Copyright 2026 Marimo. All rights reserved. */
 import { HardDriveDownloadIcon, PlayIcon } from "lucide-react";
 import type { JSX } from "react";
-import type { CellConfig, RuntimeState } from "@/core/network/types";
+import type { CellRunStatus } from "@/core/executions";
+import type { CellConfig } from "@/core/network/types";
 import {
   getConnectionTooltip,
   isAppInteractionDisabled,
@@ -35,20 +36,29 @@ function computeColor({
 
 export const RunButton = (props: {
   edited: boolean;
-  status: RuntimeState;
+  status: CellRunStatus;
+  /** Whether a cell it depends on is disabled. */
+  blocked: boolean;
   needsRun: boolean;
   connectionState: ConnectionState;
   config: CellConfig;
   onClick?: () => void;
 }): JSX.Element => {
-  const { onClick, connectionState, needsRun, status, config, edited } = props;
+  const {
+    onClick,
+    connectionState,
+    needsRun,
+    status,
+    blocked,
+    config,
+    edited,
+  } = props;
 
-  const blockedStatus = status === "disabled-transitively";
   const loading = status === "running" || status === "queued";
   const inactive =
     isAppInteractionDisabled(connectionState) ||
     loading ||
-    (!config.disabled && blockedStatus && !edited);
+    (!config.disabled && blocked && !edited);
   const variant = computeColor({
     connectionState,
     needsRun,
@@ -69,7 +79,7 @@ export const RunButton = (props: {
       </ToolbarItem>
     );
   }
-  if (!config.disabled && blockedStatus && !edited) {
+  if (!config.disabled && blocked && !edited) {
     return (
       <ToolbarItem
         disabled={inactive}

package/src/components/editor/cell/__tests__/useRunCells.test.ts

@@ -0,0 +1,45 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+
+import { describe, expect, it, vi } from "vitest";
+import { MockExecutions } from "@/__mocks__/executions";
+import { MockNotebook } from "@/__mocks__/notebook";
+import { cellId } from "@/__tests__/branded";
+import {
+  cellExecutionInputsAtom,
+  cellExecutionView,
+  notebookQueuedOrRunningCountAtom,
+} from "@/core/executions";
+import { store } from "@/core/state/jotai";
+import { runCells } from "../useRunCells";
+
+const ENABLED = cellId("enabled");
+const DISABLED = cellId("disabled");
+
+describe("runCells", () => {
+  it("sends a disabled cell to the kernel without reading it as queued", async () => {
+    MockExecutions.seed(store, []);
+    const notebook = MockNotebook.notebookState({
+      cellData: {
+        [ENABLED]: { code: "x = 1" },
+        [DISABLED]: { code: "y = 2", config: { disabled: true } },
+      },
+    });
+    const sendRun = vi.fn(async () => null);
+
+    await runCells({
+      cellIds: [ENABLED, DISABLED],
+      sendRun,
+      prepareForRun: vi.fn(),
+      notebook,
+    });
+
+    expect(sendRun).toHaveBeenCalledWith({
+      cellIds: [ENABLED, DISABLED],
+      codes: ["x = 1", "y = 2"],
+    });
+    const inputs = store.get(cellExecutionInputsAtom);
+    expect(cellExecutionView(inputs, ENABLED).status).toBe("queued");
+    expect(cellExecutionView(inputs, DISABLED).status).toBe("idle");
+    expect(store.get(notebookQueuedOrRunningCountAtom)).toBe(1);
+  });
+});

package/src/components/editor/cell/cell-context-menu.tsx

@@ -23,6 +23,7 @@ import { toast } from "@/components/ui/use-toast";
 import { useCellData, useCellRuntime } from "@/core/cells/cells";
 import { CellOutputId } from "@/core/cells/ids";
 import { isOutputEmpty } from "@/core/cells/outputs";
+import { useCellExecution } from "@/core/executions";
 import { goToDefinitionWithLspFallback } from "@/core/codemirror/go-to-definition/utils";
 import { sendToPanelManager } from "@/core/vscode/vscode-bindings";
 import { copyImageToClipboard, copyToClipboard } from "@/utils/copy";
@@ -54,12 +55,14 @@ export const CellActionsContextMenu = ({
 }: Props) => {
   const cellData = useCellData(cellId);
   const cellRuntime = useCellRuntime(cellId);
+  const execution = useCellExecution(cellId);
   const actions = useCellActionButtons({
     cell: {
       cellId: cellId,
       name: cellData.name,
       config: cellData.config,
-      status: cellRuntime.status,
+      status: execution.status,
+      blocked: execution.blocked,
       hasOutput: !isOutputEmpty(cellRuntime.output),
       hasConsoleOutput: cellRuntime.consoleOutputs.length > 0,
       getEditorView,

package/src/components/editor/cell/code/cell-editor.tsx

@@ -19,7 +19,8 @@ import {
   useNotebookDocumentEdit,
 } from "@/core/notebook/document";
 import { usePendingDeleteService } from "@/core/cells/pending-delete-service";
-import type { CellData, CellRuntimeState } from "@/core/cells/types";
+import type { CellData } from "@/core/cells/types";
+import type { CellRunStatus } from "@/core/executions";
 import { setupCodeMirror } from "@/core/codemirror/cm";
 import { acceptCompletionOnEnterAtom } from "@/core/codemirror/completion/accept-on-enter-atom";
 import { editorMountScheduler } from "@/core/codemirror/editor-mount-scheduler";
@@ -54,10 +55,11 @@ import { useSplitCellCallback } from "../useSplitCell";
 import { CodePlaceholder } from "./code-placeholder";
 import { LanguageToggles } from "./language-toggle";
 
-export interface CellEditorProps
-  extends
-    Pick<CellRuntimeState, "status">,
-    Pick<CellData, "id" | "code" | "config"> {
+export interface CellEditorProps extends Pick<
+  CellData,
+  "id" | "code" | "config"
+> {
+  status: CellRunStatus;
   runCell: () => void;
   theme: Theme;
   showPlaceholder: boolean;

package/src/components/editor/cell/collapse.tsx

@@ -9,6 +9,7 @@ import {
   RefreshCcw,
 } from "lucide-react";
 import type React from "react";
+import { useAtomValue } from "jotai";
 import { memo } from "react";
 import { Toolbar } from "@/components/layout/toolbar";
 import { Button } from "@/components/ui/button";
@@ -17,6 +18,7 @@ import { useNotebook } from "@/core/cells/cells";
 import { columnOf, useLayout } from "@/core/cells/layout";
 import type { CellId } from "@/core/cells/ids";
 import { getDescendantsStatus } from "@/core/cells/utils";
+import { cellExecutionInputsAtom } from "@/core/executions";
 import { cn } from "@/utils/cn";
 
 interface Props {
@@ -65,9 +67,11 @@ export const CollapsedCellBanner: React.FC<{
   count: number;
 }> = memo(({ onClick, count, cellId }) => {
   const notebook = useNotebook();
+  const executions = useAtomValue(cellExecutionInputsAtom);
   const layout = useLayout();
   const states = getDescendantsStatus(
     notebook,
+    executions,
     columnOf(layout, cellId).folds.get(cellId) ?? [],
   );
 

package/src/components/editor/cell/useRunCells.ts

@@ -7,10 +7,16 @@ import { getNotebook, type NotebookState } from "@/core/cells/cells";
 import { useCellActions } from "@/core/cells/actions";
 import type { CellId } from "@/core/cells/ids";
 import { enabledCellIds, staleCellIds } from "@/core/cells/utils";
+import {
+  cellExecutionInputsAtom,
+  submitCells,
+  withdrawCells,
+} from "@/core/executions";
 import { getCurrentLanguageAdapter } from "@/core/codemirror/language/commands";
 import { getEditorCodeAsPython } from "@/core/codemirror/language/utils";
 import { useRequestClient } from "@/core/network/requests";
 import type { ExecuteCellsRequest } from "@/core/network/types";
+import { store } from "@/core/state/jotai";
 import { Logger } from "@/utils/Logger";
 
 export const hasRunAnyCellAtom = atom<boolean>(false);
@@ -20,7 +26,9 @@ export const hasRunAnyCellAtom = atom<boolean>(false);
  */
 export function useRunStaleCells() {
   const runCells = useRunCells();
-  const runStaleCells = useEvent(() => runCells(staleCellIds(getNotebook())));
+  const runStaleCells = useEvent(() =>
+    runCells(staleCellIds(getNotebook(), store.get(cellExecutionInputsAtom))),
+  );
   return runStaleCells;
 }
 
@@ -107,9 +115,16 @@ export async function runCells({
     codes.push(code);
     prepareForRun({ cellId });
   }
-
-  // Send the run request to the Kernel
+  // The kernel sets a disabled cell aside without planning an execution,
+  // so a submission for it would never be superseded.
+  submitCells(
+    store,
+    cellIds.filter((cellId) => !cellData[cellId]?.config.disabled),
+  );
+
+  // TODO(MO-8346): Submit through the host's `runtime.run`.
   await sendRun({ cellIds: cellIds, codes: codes }).catch((error) => {
+    withdrawCells(store, cellIds);
     Logger.error(error);
   });
 }

package/src/components/editor/chrome/wrapper/sidebar.tsx

@@ -7,10 +7,8 @@ import type { PropsWithChildren } from "react";
 import { useEffect, useMemo } from "react";
 import { ReorderableList } from "@/components/ui/reorderable-list";
 import { Tooltip } from "@/components/ui/tooltip";
-import {
-  cellErrorCount,
-  notebookQueuedOrRunningCountAtom,
-} from "@/core/cells/cells";
+import { cellErrorCount } from "@/core/cells/cells";
+import { notebookQueuedOrRunningCountAtom } from "@/core/executions";
 import { capabilitiesAtom } from "@/core/config/capabilities";
 import { aiEnabledAtom } from "@/core/config/config";
 import { cn } from "@/utils/cn";

package/src/components/editor/header/status.tsx

@@ -5,7 +5,7 @@ import { HourglassIcon, UnlinkIcon } from "lucide-react";
 import React from "react";
 import { Tooltip } from "@/components/ui/tooltip";
 import { notebookScrollToRunning } from "@/core/cells/actions";
-import { onlyScratchpadIsRunningAtom } from "@/core/cells/cells";
+import { cellExecutionInputsAtom, onlyScratchRunning } from "@/core/executions";
 import { viewStateAtom } from "@/core/mode";
 import {
   type ConnectionStatus,
@@ -77,7 +77,9 @@ const DisconnectedIcon: React.FC<{ onReconnect?: () => void }> = ({
 };
 
 const RunningIcon = () => {
-  const scratchpadOnly = useAtomValue(onlyScratchpadIsRunningAtom);
+  const scratchpadOnly = onlyScratchRunning(
+    useAtomValue(cellExecutionInputsAtom).executions,
+  );
   const tooltip = scratchpadOnly
     ? "Scratchpad is running"
     : "Jump to running cell";

package/src/components/editor/navigation/navigation.ts

@@ -22,6 +22,7 @@ import {
   visibleNeighbor,
 } from "@/core/cells/layout";
 import { useCellActions } from "@/core/cells/actions";
+import { cellExecutionInputsAtom, cellExecutionView } from "@/core/executions";
 import { useNotebookDocumentEdit } from "@/core/notebook/document";
 import { useCellFocusActions } from "@/core/cells/focus";
 import type { CellId } from "@/core/cells/ids";
@@ -582,9 +583,9 @@ export function useCellNavigationProps(
             selectedCells.size >= 2 ? [...selectedCells] : [cellId];
 
           // Cannot delete running cells
-          const notebook = store.get(notebookAtom);
+          const executions = store.get(cellExecutionInputsAtom);
           const hasRunningCell = cellIds.some((id) => {
-            const { status } = notebook.cellRuntime[id];
+            const { status } = cellExecutionView(executions, id);
             return status === "running" || status === "queued";
           });