Skip to content

Environments: server icons get Open terminal and Dashboard actions #378

Closed

Description

@mubeda

Problem / summary

(measured) Owner request, 15 November 2026, 07:53 America/Buenos_Aires: each server should offer two commands from the place where it is chosen.

  1. Open terminal. Opens a terminal in the center panel, in that server's home folder.
  2. Dashboard. Shows that server's existing host dashboard (CPU, memory and disk volumes from Settings → Remote Servers) in the center panel.

Where the commands go:

  • Environments view. A right-click menu on the left-rail server icons (the Local monitor icon and the letter-avatar icons for saved servers).
  • Repositories view. Visible icon buttons on the server card, next to the existing overflow, New worktree and Git Manager icons.

(inferred) This is a follow-up to #292, not a duplicate. #292 shipped the host dashboard as a right-side sheet, with entry points on the environment-card menu, a connected Settings row, and the status bar. It did not add a rail menu, card icons, a center-panel host, or a terminal command.

Area: primarily apps/web. Resolving the home folder or hosting a terminal without a thread may also touch apps/server and packages/contracts (see Open questions).

Current behavior

(measured) Verified at 27a32e80998a983affdb244de7d232249963e0ed (current main, merge of PR #373). “Measured” means source, test-source, GitHub metadata, or the supplied report was inspected. It does not mean the app or tests were run. Two independent read-only reviews (Codex and Claude) reached the same facts below unless a difference is called out.

Environments view: left-rail server icons

  • The rail is EnvironmentRail in EnvironmentRail.tsx:147. It renders only in the Environments view; Repositories and Inbox hide it (AppSidebarLayout.tsx:183). (measured)
  • The Local button is a MonitorIcon with a status dot (:208-275). Its accessible name is "Local (this machine)" (:214). A left click selects the primary local environment, or opens a sub-picker Menu listing "This device" and each desktop-local backend when those exist (:239-255, environmentRail.logic.ts:125-131). (measured)
  • Saved servers render as RemoteEntryButton (:67-106): a two-letter avatar with a status dot, aria-label and tooltip set to the server name, role="radio". A left click selects the environment (:87, :171-173). Selection only changes panel presentation; it does not connect, disconnect, or navigate the center panel. (measured)
  • Right-click: none. The rail has no onContextMenu handler. (measured)
  • Keyboard today. Icons sit in a role="radiogroup" named "Environments", with roving tabIndex. Arrow Up/Down, Home and End move focus (:185-238). There is no Shift+F10 or Menu-key handler. (measured)

Menu primitives already in the app:

  • api.contextMenu.show (packages/contracts/src/ipc.ts:1560-1565), with disabled and a description that explains an unavailable action (:133-145). Call sites include the project header menu (Sidebar.tsx:2635-2660, sidebarMenus.logic.ts:217). (measured)
  • Keyboard helpers already used on thread and primary-card rows: isContextMenuShortcut and isKeyboardContextMenuEcho (Sidebar.logic.ts:1045-1062), contextMenuAnchorForRect (:489). (measured)
  • In-DOM Menu / MenuItem / MenuPopup from apps/web/src/components/ui/menu, used by the Local picker and the environment-card "…" menu. (measured)

Repositories view: server card

  • The card is the project header row with environmentCard set (Sidebar.tsx:3412-3583). Identity is EnvironmentCardHeader.tsx:9-41: a monitor icon or letter avatar, a "Local" or server-name label, a status ("This device", "Connected", "Reconnecting", "Connection error", or "Offline"), and the checkout path (repositoryView.logic.ts:36-68). The header dims when the environment is not connected. (measured)
  • Visible icon actions live in the project-actions-strip (Sidebar.tsx:3476-3582). Pull Requests and Pipelines icons are hidden on environment cards (:3402-3404). None of the current strip buttons is disabled, including when the environment is offline. Row padding is reserved by projectHeaderActionCount (:671-678, max 5), which new icons must update. (measured)
Icon Accessible name Tooltip Action
EllipsisIcon "…" (:3497) Project actions for <name> Project actions Opens the project header menu
PlusIcon "+" (:3514) New worktree in <name> New worktree Creates a worktree
GitBranchIcon (:3530) Git Manager for <name> Git Manager Navigates to /project/$environmentId/$projectId/git
  • A right-click on the header already opens the project menu (handleProjectButtonContextMenu, :2745; items in sidebarMenus.logic.ts:217-243). That menu has neither requested command. The header keydown handles Enter and Space only (:2283-2291). (measured)

Existing "Host dashboard" entry points

  • EnvironmentContextCard appears only in the Environments view and not for this device or desktop-local backends (environmentContextCard.logic.ts:55-60). Its "…" menu already lists Host dashboard, then Disconnect, updates, and Manage… (EnvironmentContextCard.tsx:137-172). "Host dashboard" is always enabled (:151). (measured)
  • Settings → Remote Servers shows a Host dashboard button on a connected row only (ConnectTab.tsx:460-464). (measured)
  • The status bar resource popover also opens it (ResourceUsageSegment.tsx:147-150). (measured)
  • All three open a global right-side sheet, not a Settings-embedded view and not a center tab: HostDashboardSheet (HostDashboardSheet.tsx:103-201), mounted from AppRoot.tsx:166-168, triggered by useOpenHostDashboard (hostDashboard.ts:7-19). (measured)
  • The sheet already shows CPU, memory, volumes, charts and statistics since server start. Data comes from serverEnvironment.hostMetrics({ environmentId }) (packages/client-runtime/src/state/server.ts:223-229), RPC server.subscribeHostMetrics, capability hostMetrics. HostDashboardValuesView (HostDashboardSheet.tsx:254) and HostMetricBars are exported. (measured)
  • (inferred, both reviews) Subscription, state and notices still live inside the sheet body (:112-199). Reuse as a center-panel view needs that controller extracted; it is not a drop-in of the sheet itself. Calling the current sheet opener would not satisfy "show it in the center panel."

Terminals in the center panel

  • The opener is createCenterTerminal (centerTerminalActions.ts:112-171). It requires a threadRef and launch.cwd. The only caller is ChatView.tsx:4818; cwd comes from the thread workspace (ChatView.tsx:4553-4565). (measured)
  • TerminalOpenInput requires threadId and a nonempty cwd (packages/contracts/src/terminal.ts:92-115). The server validates that literal path and does not expand ~ (terminal/manager.rs:5012-5022). (measured)
  • Placement adds or activates a tab in the focused group (centerPanelStore.ts:660-668); a split is created only when asked. Failures toast "Could not open terminal" (ChatView.tsx:4888-4902) and close a session that could not be placed (centerTerminalActions.ts:85-110). (measured)
  • (inferred, both reviews) There is no existing server-only center-terminal opener. Terminal state is thread-scoped. Opening a terminal from a rail icon when no thread is selected is a gap, not just a missing button.

Home folder

  • On the server, expand_home uses dirs::home_dir() (apps/server/src/workspace/entries.rs:195-207) and is used by filesystem.browse. The client already calls filesystemEnvironment.browse({ environmentId, input: { partialPath: "~", mode: "directory" } }) from RemoteDirectoryBrowser.tsx:98,135; the server returns a canonical directoryPath. The same RPC applies to local and remote environments; resolution happens on the targeted server. (measured)
  • There is no dedicated client-visible "home directory" field or RPC, and terminal.open will not accept an unresolved ~. (measured)
  • (inferred) The browse result's directoryPath is the existing way to obtain that server user's home without a contract change. It is a directory listing, not a home-only API, and it is an extra round trip. Whether to reuse it, accept ~ as a terminal cwd, or add a descriptor field is Open question 2.

Center-panel routing

  • Registered center surfaces are only chat-host, chat, and terminal (centerPanelStore.ts:47-60). ChatView dispatches those kinds. There is no dashboard surface. (measured)
  • Other center content can be a full _chat route; Git Manager is the existing example (routes/_chat.project.$environmentId.$projectId.git.tsx). There is no environment-scoped route that can host a server terminal or dashboard when no thread is open. With no thread, /_chat/ renders NoActiveThreadState (_chat.index.tsx:14-23). (measured)

Requested behavior

  • Environments view. Right-clicking a server icon in the rail opens a menu with Open terminal and Dashboard, in that order, for that icon's environment (Local monitor and saved-server avatars).
  • Repositories view. The server card shows the same two commands as icon buttons in its action strip.
  • Open terminal. Opens a terminal in the center panel whose initial working directory is that server user's home folder, not a project or worktree path.
  • Dashboard. Shows the existing host dashboard (CPU, memory and volumes) for that server in the center panel, reusing the current metrics stream and presentation.

Goal and non-goals

  • Goal: complete either server action from either requested entry point, for local and remote servers, with the result visible in the center panel. Both views wire the same two commands.
  • Non-goals (agent's call; the owner did not state these):
    • A new metrics collector, new charts, or changes to server.subscribeHostMetrics. The dashboard shows what Remote servers: open a live dashboard of a server's CPU, memory and disk usage, with statistics since the server started #292 shipped.
    • Changing the existing project header menu, or the existing "…", "+" and branch icon behavior.
    • Opening a terminal on a server that is not connected, or reconnecting it as a side effect.
    • Removing the existing Settings, environment-card, or status-bar dashboard entry points. Whether those should also open the new center view is Open question 4.
    • Per-folder "open terminal here" on a project path. That is a different request.

Requirements and acceptance criteria

"The app" means the BiBCode web client in browser or desktop mode.

P0

R1. Same commands from both entry points. The app SHALL run one shared Open terminal command and one shared Dashboard command for a given server, whether started from the Environments rail menu or the Repositories card icons.

  • Scenario (rail): GIVEN a connected saved server "Server A" in the rail, WHEN the user right-clicks its icon and picks Dashboard, THEN the center panel shows the dashboard for "Server A".
  • Scenario (card): GIVEN the same server's card in the Repositories view, WHEN the user activates its Dashboard icon, THEN the center panel shows the same dashboard view for "Server A".
  • Negative: WHEN either command runs for "Server A", THEN no dashboard or terminal opens for any other environment.

R2. Rail right-click menu. WHEN the user right-clicks a server icon in the Environments rail, the app SHALL show a menu with Open terminal and Dashboard, in that order, for that icon's environment.

  • Scenario (remote): GIVEN a saved server avatar, WHEN the user right-clicks it, THEN the menu shows those two commands for that server, and the browser's default context menu does not appear.
  • Scenario (local): GIVEN the Local monitor icon (no other local backends), WHEN the user right-clicks it, THEN the menu shows those two commands for the primary local environment.
  • Negative: GIVEN an open menu, WHEN it is dismissed, THEN no terminal or dashboard opens, and left-click rail selection and the existing Local picker still work as before.

R3. Card icon buttons. The app SHALL show an Open terminal icon button and a Dashboard icon button in the server card's action strip in the Repositories view, for that card's environment, and SHALL update the header's action-count padding so row text stays clear of the icons.

  • Scenario: GIVEN a Repositories card for the local environment, WHEN it renders, THEN the strip holds the existing three buttons plus the two new ones.
  • Negative: WHEN the project is shown outside a repository group (no server card), THEN the two new buttons do not appear. The existing overflow, New worktree and Git Manager actions remain available.

R4. Accessible names and tooltips. The app SHALL give each new card button an accessible name that includes the command and the server's label, and a tooltip with the command name, following the existing strip pattern (Git Manager for <name>).

  • Scenario: GIVEN the card for "Server A", WHEN a screen reader lists its buttons, THEN it hears names such as "Open terminal on Server A" and "Dashboard for Server A" (exact wording is Open question 6). Hovering or focusing each button shows its tooltip.
  • Negative: an icon button with no accessible name fails the test.

R5. Terminal in the server's home folder. WHEN the user runs Open terminal for a connected server, the app SHALL open a terminal in the center panel whose initial working directory is the home directory of the user running that server.

  • Scenario (local): GIVEN the local environment is connected and home resolution succeeds, WHEN Open terminal runs, THEN a center terminal starts with cwd equal to that environment's resolved home, not the selected repository root.
  • Scenario (remote): GIVEN a connected remote server, WHEN Open terminal runs, THEN the session runs on that environment and cwd is that remote server's resolved home, not the client's.
  • Negative: the terminal never starts in a project folder, and an unresolved ~ is not passed to terminal.open (that path does not expand it today).
  • Failure: GIVEN home resolution or terminal creation fails, WHEN the action completes, THEN the existing "Could not open terminal" toast names the reason and no orphaned terminal tab is left, including no tab for another server or a fallback project directory.

R6. Dashboard in the center panel, reusing the existing view. WHEN the user runs Dashboard for a connected server, the app SHALL show that server's existing CPU, memory and disk dashboard in the center panel, using the same host-metrics subscription and the same presentation, not a second implementation.

  • Scenario: GIVEN a connected server that supports hostMetrics, WHEN Dashboard runs, THEN the center panel shows the same sections, units, charts, volume information and since-start statistics as the current sheet, for that server.
  • Scenario (unsupported): GIVEN a connected server whose hostMetrics capability is false, WHEN Dashboard runs, THEN the existing unsupported notice is shown and no host-metrics request is sent.
  • Negative: WHEN the center dashboard is closed, becomes inactive, or the document is hidden, THEN the host-metrics stream ends, as it does for the sheet today. Values from a different server are never substituted.

R7. Disconnected servers. IF the target server is not connected, THEN the app SHALL not start a terminal or a host-metrics stream on it, and SHALL show why the command is unavailable. The exact disabled-versus-hidden pattern is Open question 3, because current entry points disagree.

  • Scenario: GIVEN a saved server shown as Offline, WHEN the user opens its rail menu or inspects its card, THEN Open terminal cannot run and the reason is visible (menu description or button tooltip).
  • Negative: WHEN Open terminal is chosen for an offline server, THEN no terminal.open request is sent and the connection state does not change. A dashboard already open keeps its existing disconnected presentation.

P1

R8. Keyboard access. The app SHALL open the rail menu from the keyboard with Shift+F10 or the Menu key on a focused rail icon, anchored at that icon, using the existing shortcut helpers so a follow-up contextmenu event does not open a second menu. It SHALL let the user reach each new card icon with Tab (visible focus ring) and activate it with Enter or Space.

  • Scenario (rail): GIVEN focus on a rail icon, WHEN the user presses Shift+F10, THEN the two-command menu opens; Arrow keys and Enter activate an enabled item; Escape dismisses it and returns focus to the icon.
  • Negative: Arrow keys in the rail still move focus between icons and do not open the menu. Existing radio selection semantics remain usable.

R9. Dashboard lifecycle. WHILE a center dashboard is not visible, or its server is disconnected or unsupported, the dashboard SHALL stop its live subscription and retain the existing loading, stale, disconnected, restarted, unsupported, error and Retry presentations.

  • Scenario: GIVEN a live dashboard, WHEN its center surface is closed or hidden, THEN its subscription is released; WHEN it becomes visible again on a supported connected server, THEN it subscribes to that server again.
  • Negative: GIVEN two environments, WHEN the visible dashboard target changes, THEN the previous target's subscription is released.

P2

R10. Existing sheet actions. The center dashboard SHOULD keep the Retry and "Open Remote Servers" actions the sheet offers today, if those still apply in a center host. No new command-palette entry or shortcut is required.

Tests or e2e to add, and repository gates

(measured) Tests that exist today (names read at the SHA; not executed):

  • EnvironmentRail.test.tsx: radio semantics, selection, Local sub-picker. No context-menu test.
  • EnvironmentCardHeader.test.tsx; Sidebar.test.tsx and Sidebar.browser.test.tsx: project actions button.
  • EnvironmentContextCard.test.tsx: the Host dashboard item.
  • HostDashboardSheet.test.tsx and HostDashboardSheet.stream.test.tsx: dashboard states and stream close on hide.
  • ConnectTab.test.tsx: "offers Host dashboard on a connected row only"; ResourceUsageSegment.test.tsx.
  • centerTerminalActions.test.ts: placement, missing launch context, open failure, compensating close.
  • Packaged e2e: apps/desktop/e2e/specs/host-dashboard.e2e.ts (sheet from the Resource Manager, shapes only) and project-session-terminal.e2e.ts.

(inferred) Add:

  • EnvironmentRail.test.tsx: right-click on Local and remote icons shows the two items for the right environment (R2); Shift+F10 / Menu key with no echo (R8); offline behavior (R7); Local-picker regression; multi-backend Local targeting once Open question 1/5 is settled.
  • Sidebar.test.tsx (project header in a repository group): the two buttons render only with environmentCard (R3); accessible names and tooltips (R4); padding class reflects the new action count; offline behavior (R7); existing overflow / New worktree / Git Manager still work.
  • A unit test of the shared command module: both entry points call it with the same environment id (R1).
  • Terminal command tests: home-directory resolution for local and remote with fakes (R5); failure toast and no orphan session; no placement after a failed spawn. Build on centerTerminalActions.test.ts. If the server starts accepting ~ as cwd, add a Rust test next to entries.rs or terminal/manager.rs.
  • Center dashboard host tests: reuse the sheet's state tests against the extracted body (live, unsupported with no RPC, disconnected, stream ends on close and hide) (R6, R9).
  • Packaged e2e: extend host-dashboard.e2e.ts or add a spec that opens Dashboard from the Local rail icon and from a Repositories card, asserts the center dashboard shapes, and opens a center terminal whose shell prints the home directory (fixture-owned identities and cwd only, no private host values).

(measured) Repository gates for a later implementation, from AGENTS.md and CI, not claimed as run for this draft:

  • focused behavioral tests;
  • vp check and vp run typecheck;
  • for any Rust change: cargo fmt --all --check, the relevant Rust tests, and Clippy with warnings denied (cargo clippy --workspace --all-targets -- -D warnings);
  • vercel-react-best-practices review of changed React components and a UI.md review (disabled states must explain themselves);
  • a final git diff / git status --short and sensitive-data review;
  • a profiler coverage line if an RPC or long-running wait is added.

See AGENTS.md and .github/workflows/ci.yml.

Open questions

  1. Where does a server terminal (and the center dashboard) live? Center terminals are owned by a host thread today (threadRef, threadId on terminal.open, store key). Options:
    • (a) a new environment-scoped center route or host, with no thread, similar in spirit to the Git Manager route;
    • (b) open the terminal only in a currently open thread's center panel (fails when no thread on that server is open);
    • (c) a hidden per-environment host thread.
      (guess, agent's call if the owner has no preference) Prefer (a), because the commands are per server, not per thread. Do not silently borrow an unrelated active chat. This choice is the main size risk (see Evidence).
  2. How is the home folder resolved? terminal.open does not expand ~. Options:
    • (a) Accept ~ as a terminal cwd on the server, reusing expand_home (needs a capability or fallback for older servers);
    • (b) Add a home-directory field to the server descriptor;
    • (c) Call filesystem.browse with ~ and use the returned directoryPath (no server change, extra listing round trip).
      (guess) Codex recommended (c) as the existing resolver; Claude recommended (a) to keep resolution on the server that owns the home. A missing or unreadable home is a failure, not a fallback to the project root.
  3. Disabled pattern for offline servers. Current patterns are mixed: Settings hides "Host dashboard" unless connected; the environment-card item is always enabled; menu items use disabled plus description; Repositories card icons never disable. (guess) Claude recommended showing both commands, disabling Open terminal with a reason, and leaving Dashboard enabled because the dashboard already has a disconnected state. Codex recommended disabling both with "Not connected." Needs the owner's confirmation.
  4. Do the existing sheet entry points stay? Settings, the environment-card "…" item, and the status bar all open the sheet. Should they open the center view so there is one dashboard surface? (guess, agent's call) Keep them working in this issue; pointing them at the center view can be part of the same change if the owner wants a single surface.
  5. Does right-click select the server? (guess, agent's call) No. Opening the menu on an unselected icon, running a command, or dismissing the menu should not change the rail selection. The command still targets the clicked server.
  6. Labels. The request says "Dashboard"; the shipped UI says "Host dashboard" everywhere. (guess, agent's call) Use Open terminal and Dashboard on the new entry points, as requested, unless the owner wants "Host dashboard" for consistency. Accessible names should include the server label, for example "Open terminal on Server A" and "Dashboard for Server A."
  7. Card icons repeat per checkout. The Repositories card is per checkout, so a server with several checkouts of one repository would show the icons on each row. (guess, agent's call) Accept that; it matches the existing per-row icons.
  8. Icons. (guess, agent's call) Lucide TerminalSquare is already used for terminals in the chat header menu; use it for Open terminal, and a gauge or activity icon for Dashboard.
  9. Repeated activation. Existing terminal APIs add or activate a tab in the focused group; they do not implicitly split. (guess, agent's call) A second Dashboard command for the same server should focus the existing center view rather than open another. Confirm tab-versus-route for the new dashboard host.
  10. Local rail icon with several local backends. The Local monitor can represent more than one local backend. (guess, agent's call) Keep exactly the two requested top-level commands. Target the currently selected local backend when one is selected, otherwise the primary local environment, and retain the existing left-click picker. A submenu is not required unless the owner wants to pick a backend from the context menu.

Evidence and decision record

(measured) Privacy check: no personal usernames, local filesystem paths, hostnames, emails, tokens, or screenshot attachments are included.

Activity

  1. added
    enhancementRequested improvement or new capability.
    needs-triageIssue needs maintainer review and initial categorization.
    on Nov 15, 2026
  2. mubeda commented on Nov 15, 2026

    @mubeda
    OwnerAuthor

    Clarification from the owner (15 Nov 2026): how the terminal and dashboard are shown

    (measured: owner statement) Open terminal and Dashboard must each open as a center-panel panel/tab, the same way the PR panel and the Pipelines panel do today: not as a right-side sheet, a modal, or a terminal inside a chat thread.

    What this changes in the spec:

    • P0, Dashboard: the host dashboard (CPU, memory, disk volumes) renders as a center panel of its own, opened and focused like the PR and Pipelines panels. It keeps a tab/title naming the server, can be closed like those panels, and reopening for the same server focuses the existing panel instead of adding a duplicate. The existing right-side sheet from Remote servers: open a live dashboard of a server's CPU, memory and disk usage, with statistics since the server started #292 may stay for its current entry points, but these new commands open the panel.
    • P0, Open terminal: the terminal opens as a center panel of its own, scoped to the selected server (environment), not to a chat thread, starting in that server's home folder. It follows the same open, focus and close behavior as the PR and Pipelines panels. Opening it again either focuses the server's existing terminal panel or opens a new one (open question below).
    • (inferred) Implementation should reuse the same center-panel routing and registration that the PR and Pipelines panels use (see centerPanelStore.ts and the Git Manager / repository-module center routes cited above), adding server-scoped panel kinds for the terminal and dashboard, rather than a separate mechanism.
    • Acceptance: e2e coverage that both commands, from the Environments rail context menu and from the Repositories server-card icons, open the matching center panel, that a second invocation for the same server focuses rather than duplicates (dashboard), and that panels persist and restore like the PR and Pipelines panels.

    Open question added: should a second Open terminal on the same server focus the existing terminal panel or open an additional one?

  3. mubeda commented on Nov 15, 2026

    @mubeda
    OwnerAuthor

    Decided (owner, 15 Nov 2026): reopen focuses the existing panel

    (measured: owner statement) The open question is resolved: invoking Open terminal again for the same server focuses the terminal panel already open for that server instead of opening an additional one. Dashboard behaves the same way: one panel per server, and reopening focuses it.

    Acceptance (P0): for each server there is at most one Open terminal center panel and one Dashboard center panel. A second invocation from either entry point (Environments rail context menu or Repositories server-card icons) focuses the existing panel and does not create a new terminal session. A new panel opens only after the previous one was closed. e2e covers both commands from both entry points.

  4. mubeda commented on Nov 16, 2026

    @mubeda
    OwnerAuthor

    Scope extension: buttons on the Environments view remote server card

    The remote server card at the top of the Environments view sidebar, which shows the server name, Connected · BibCode vX.Y.Z, the update badge and the … menu, should also show the two actions as visible icon buttons:

    • Open terminal opens that server's terminal panel in the center, in the home folder.
    • Dashboard opens that server's dashboard panel in the center.

    The card is EnvironmentContextCard (apps/web/src/components/sidebar/EnvironmentContextCard.tsx, rendered by SidebarEnvironmentContextCard in Sidebar.tsx, inspected at be03142d). Measured: its … menu already has a Host dashboard item that calls useOpenHostDashboard(), which opens the HostDashboardSheet sheet.

    Rules (the same as the other entry points in this issue):

    • The buttons go in the card's header row, next to the … menu. They are icon buttons with a tooltip and an aria-label ("Open terminal", "Dashboard"), and they are shown only while the server is connected, otherwise disabled with the reason in the tooltip.
    • They use the same server-scoped center panels and the same reopen rule as the rail context menu and the Repositories view card: one terminal panel and one dashboard panel per server, and reopening focuses the panel that's already open.
    • Change the existing … > Host dashboard item so it opens the same center panel instead of the sheet, so there aren't two different dashboard surfaces (inferred, agent's call on whether the sheet stays anywhere else).
    • e2e covers the card buttons as a third entry point, including focusing an existing panel.

    Size stays size:M (guess: this adds one more call site for the same commands).

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Metadata

Metadata

Assignees

No one assigned

    Labels

    enhancementRequested improvement or new capability.needs-triageIssue needs maintainer review and initial categorization.size:M

    Projects

    No projects

      Milestone

      No milestone

      Relationships

      None yet

      Development

      No branches or pull requests

      Issue actions