xtralab 0.8.0 → 0.10.0

package/src/git/index.ts

@@ -5,14 +5,15 @@ import {
 import { IThemeManager, WidgetTracker } from '@jupyterlab/apputils';
 import { IRenderMimeRegistry } from '@jupyterlab/rendermime';
 
-import { CommandArguments, CommandIDs, registerGitCommands } from './commands';
 import {
-  DiffContentWidget,
+  CommandArguments,
+  CommandIDs,
+  DiffMainAreaWidget,
   PREVIEW_DIFF_WIDGET_ID,
-  pinnedDiffWidgetId
-} from './diffWidget';
+  pinnedDiffWidgetId,
+  registerGitCommands
+} from './commands';
 import diffProviderPlugin from './diffProvider';
-import type { MainAreaWidget } from '@jupyterlab/apputils';
 import { IFileChange } from './tokens';
 
 const GIT_DIFF_COMMAND_PLUGIN_ID = 'xtralab:git-diff-command';
@@ -21,12 +22,8 @@ const GIT_DIFF_TRACKER_NAMESPACE = 'xtralab-git-diff';
 /**
  * The launcher's git diff command plugin.
  *
- * The `@jupyterlab/git` frontend stays enabled (only its diff plugins are
- * swapped — see `diffProvider.tsx`), so the upstream git panel is what the
- * user sees in the sidebar. This plugin is the launcher dashboard's
- * independent diff path: the `xtralab:git:open-diff` command the
- * dashboard's "Changes" section calls, plus a tracker so reopening a diff
- * reveals the existing tab and the preview/pin behavior keeps working.
+ * The upstream git panel stays enabled; this plugin only gives the launcher
+ * its own `xtralab:git:open-diff` command and preview/pinned-tab tracking.
  */
 const diffCommandPlugin: JupyterFrontEndPlugin<void> = {
   id: GIT_DIFF_COMMAND_PLUGIN_ID,
@@ -39,17 +36,15 @@ const diffCommandPlugin: JupyterFrontEndPlugin<void> = {
     themeManager: IThemeManager | null,
     rendermime: IRenderMimeRegistry | null
   ): void => {
-    // Track open diff widgets so the openDiff handler can reveal an
-    // already-open diff for the same file instead of creating a duplicate
-    // (and so a promoted preview can find its pinned twin).
-    const tracker = new WidgetTracker<MainAreaWidget<DiffContentWidget>>({
+    // Track open diffs so repeated opens reveal the existing tab.
+    const tracker = new WidgetTracker<DiffMainAreaWidget>({
       namespace: GIT_DIFF_TRACKER_NAMESPACE
     });
 
     const findDiff = (
       change: IFileChange,
       pin = false
-    ): MainAreaWidget<DiffContentWidget> | undefined => {
+    ): DiffMainAreaWidget | undefined => {
       const id = pin ? pinnedDiffWidgetId(change) : PREVIEW_DIFF_WIDGET_ID;
       const existing = tracker.find(
         widget => !widget.isDisposed && widget.id === id
@@ -62,13 +57,9 @@ const diffCommandPlugin: JupyterFrontEndPlugin<void> = {
       themeManager,
       contentsManager: app.serviceManager.contents,
       rendermime,
-      // The launcher polls git status on its own cadence and the
-      // jupyterlab-git panel auto-refreshes on the contents `fileChanged`
-      // signal a hunk-discard save emits, so no extra refresh is needed.
-      onChanged: () => undefined,
       trackDiff: widget => tracker.add(widget),
       onPinned: current => {
-        const existing = findDiff(current.content.change, true);
+        const existing = findDiff(current.change, true);
         if (
           existing !== undefined &&
           existing !== current &&
@@ -78,7 +69,7 @@ const diffCommandPlugin: JupyterFrontEndPlugin<void> = {
           current.close();
           return;
         }
-        current.id = pinnedDiffWidgetId(current.content.change);
+        current.id = pinnedDiffWidgetId(current.change);
         current.title.className = '';
         app.shell.activateById(current.id);
       },
@@ -88,12 +79,7 @@ const diffCommandPlugin: JupyterFrontEndPlugin<void> = {
 };
 
 /**
- * Every plugin contributed by xtralab's git integration:
- *
- *   1. {@link diffCommandPlugin} — the launcher's `xtralab:git:open-diff`.
- *   2. `diffProviderPlugin` — registers the `@pierre/diffs` rendering as
- *      jupyterlab-git's diff providers (replacing its disabled
- *      notebook/text diff plugins).
+ * Plugins contributed by xtralab's git integration.
  */
 const plugins: JupyterFrontEndPlugin<unknown>[] = [
   diffCommandPlugin,

package/src/git/notebookDiff.tsx

@@ -13,6 +13,8 @@ import {
   type FileDiffMetadata
 } from '@pierre/diffs';
 
+import { resolveDiffTheme } from './diffTheme';
+
 /**
  * The CSS class added to the root of the notebook diff. Selectors that
  * style cell sections, headers, and the per-cell diff blocks hang off this
@@ -151,7 +153,7 @@ function emptyNotebook(): INotebook {
  * nbformat allows multiline string fields (`source`, stream `text`,
  * `text/plain` outputs, …) to be either a single string or an array of
  * strings. Normalize to one string so equality checks and diffs see the
- * same shape regardless of how the writer chose to serialise it.
+ * same shape regardless of how the writer chose to serialize it.
  */
 export function joinMultiline(value: string | string[] | undefined): string {
   if (value === undefined) {
@@ -836,6 +838,11 @@ function MarkdownPreviewSection(props: {
 interface INotebookDiffViewProps {
   diff: INotebookDiffResult;
   dark: boolean;
+  /**
+   * Whether a Pierre JupyterLab theme is active; selects Pierre's rich
+   * highlighting vs the CSS-variable theme (see {@link resolveDiffTheme}).
+   */
+  pierreTheme: boolean;
   rendermime: IRenderMimeRegistry | null;
 }
 
@@ -852,8 +859,8 @@ interface INotebookDiffViewProps {
 export function NotebookDiffView(
   props: INotebookDiffViewProps
 ): React.ReactElement {
-  const { diff, dark, rendermime } = props;
-  const theme: DiffsThemeNames = dark ? 'pierre-dark' : 'pierre-light';
+  const { diff, dark, pierreTheme, rendermime } = props;
+  const theme: DiffsThemeNames = resolveDiffTheme(dark, pierreTheme);
   const summary = React.useMemo(() => summarize(diff.cells), [diff.cells]);
   return (
     <div className={NOTEBOOK_DIFF_CSS_CLASS}>

package/src/index.ts

@@ -2,12 +2,14 @@ import { JupyterFrontEndPlugin } from '@jupyterlab/application';
 
 import agentSessionsPlugin from './agentSessions';
 import fileBrowserPlugin from './fileBrowser';
+import fileTypeIconsPlugin from './fileTypeIcons';
 import editorBreadcrumbsPlugin from './editorBreadcrumbs';
 import editorIndentPlugin from './editorIndent';
 import gitPlugins from './git';
 import launcherPlugins from './launcher';
 import menusPlugin from './menus';
 import sidebarPlugin from './sidebar';
+import terminalNotificationsPlugin from './terminalNotifications';
 import terminalsPlugin from './terminals';
 import topBarPlugin from './topBar';
 
@@ -25,10 +27,12 @@ const plugins: JupyterFrontEndPlugin<unknown>[] = [
   editorBreadcrumbsPlugin,
   editorIndentPlugin,
   fileBrowserPlugin,
+  fileTypeIconsPlugin,
   ...gitPlugins,
   ...launcherPlugins,
   menusPlugin,
   sidebarPlugin,
+  terminalNotificationsPlugin,
   terminalsPlugin,
   topBarPlugin
 ];

package/src/terminalNotifications/index.ts

@@ -0,0 +1,295 @@
+import {
+  JupyterFrontEnd,
+  JupyterFrontEndPlugin
+} from '@jupyterlab/application';
+import type { MainAreaWidget } from '@jupyterlab/apputils';
+import { ISettingRegistry } from '@jupyterlab/settingregistry';
+import { ITerminal, ITerminalTracker } from '@jupyterlab/terminal';
+import { ITranslator, nullTranslator } from '@jupyterlab/translation';
+
+const PLUGIN_ID = 'xtralab:terminal-notifications';
+
+// Per-terminal gap between notifications, so the OSC-9-plus-bell agents emit
+// together collapses into one and a chatty program cannot flood the OS.
+const NOTIFY_THROTTLE_MS = 3000;
+
+// iTerm2 growl notification: `ESC ] 9 ; <message> BEL`. What Claude Code and
+// most agents emit on their default `auto` setting once TERM_PROGRAM is set.
+const OSC_ITERM2_GROWL = 9;
+
+// rxvt/Ghostty notification: `ESC ] 777 ; notify ; <title> ; <body> BEL`.
+const OSC_RXVT_NOTIFY = 777;
+
+const MAX_TEXT_LENGTH = 256;
+
+// The bits of an xterm.js `Terminal` we reach into. JupyterLab's terminal
+// widget keeps its xterm in a private `_term` field and does not expose these
+// hooks, so a structural type uses them without depending on `@xterm/xterm`. If
+// the field is ever renamed, `_term` is `undefined` and notifications stop, with
+// a console warning per terminal.
+interface IXtermDisposable {
+  dispose(): void;
+}
+interface IXtermTerminal {
+  onBell(handler: () => void): IXtermDisposable;
+  parser: {
+    registerOscHandler(
+      ident: number,
+      callback: (data: string) => boolean
+    ): IXtermDisposable;
+  };
+}
+interface ITerminalContentInternals extends ITerminal.ITerminal {
+  ready: Promise<void>;
+  _term?: IXtermTerminal;
+}
+
+type TerminalWidget = MainAreaWidget<ITerminal.ITerminal>;
+
+// The renderer→main bridge the desktop shell injects on the lab window. Absent
+// for pip-install users in a browser, who fall back to web Notifications.
+interface IDesktopBridge {
+  notify?: (
+    title: string,
+    body: string,
+    session?: string
+  ) => Promise<void> | void;
+  onFocusTerminal?: (callback: (session: string) => void) => void;
+}
+
+/**
+ * Turns the notifications coding agents already emit (OSC 9, OSC 777, the bell)
+ * into desktop notifications. JupyterLab's xterm renders these sequences but
+ * never forwards them to the OS, so this plugin hooks each terminal and bridges
+ * them through `window.xtralab.notify` (desktop) or the web Notifications API.
+ *
+ * A notification is suppressed while its terminal is the focused, active tab,
+ * and throttled per terminal. The desktop shell advertises
+ * `TERM_PROGRAM=iTerm.app` so agents emit OSC 9 in the first place, and the
+ * session name is forwarded so clicking a notification focuses the terminal
+ * that fired it.
+ */
+const plugin: JupyterFrontEndPlugin<void> = {
+  id: PLUGIN_ID,
+  description:
+    'Forwards desktop notifications emitted by agents in xtralab terminals (OSC 9, OSC 777, bell) to the operating system.',
+  autoStart: true,
+  requires: [ITerminalTracker],
+  optional: [ISettingRegistry, ITranslator],
+  activate: async (
+    app: JupyterFrontEnd,
+    tracker: ITerminalTracker,
+    settingRegistry: ISettingRegistry | null,
+    translator: ITranslator | null
+  ): Promise<void> => {
+    const trans = (translator ?? nullTranslator).load('jupyterlab');
+
+    let enabled = true;
+    let notifyOnBell = true;
+
+    // Per-widget throttle timestamps and xterm hooks. WeakMaps let disposed
+    // widgets be collected; hooks are torn down when a tab closes.
+    const lastNotified = new WeakMap<TerminalWidget, number>();
+    const hooks = new WeakMap<TerminalWidget, IXtermDisposable[]>();
+
+    // True when the user is already looking at this terminal, so a banner would
+    // just be noise.
+    const isActivelyViewing = (widget: TerminalWidget): boolean =>
+      document.hasFocus() && app.shell.currentWidget === widget;
+
+    const deliver = (title: string, body: string, session?: string): void => {
+      const bridge = (window as Window & { xtralab?: IDesktopBridge }).xtralab;
+      if (bridge && typeof bridge.notify === 'function') {
+        void Promise.resolve(bridge.notify(title, body, session)).catch(
+          reason => {
+            console.warn('xtralab: desktop notification failed', reason);
+          }
+        );
+        return;
+      }
+      // Plain-browser fallback (pip install): the Web Notifications API.
+      if (typeof Notification === 'undefined') {
+        return;
+      }
+      if (Notification.permission === 'granted') {
+        new Notification(title, { body });
+      } else if (Notification.permission !== 'denied') {
+        void Notification.requestPermission().then(permission => {
+          if (permission === 'granted') {
+            new Notification(title, { body });
+          }
+        });
+      }
+    };
+
+    const notify = (
+      widget: TerminalWidget,
+      title: string,
+      body: string
+    ): void => {
+      if (!enabled || isActivelyViewing(widget)) {
+        return;
+      }
+      const now = Date.now();
+      const previous = lastNotified.get(widget);
+      if (previous !== undefined && now - previous < NOTIFY_THROTTLE_MS) {
+        return;
+      }
+      lastNotified.set(widget, now);
+      const session = widget.content.session?.name;
+      deliver(sanitize(title) || 'xtralab', sanitize(body), session);
+    };
+
+    // The tab label is the agent's name once the launcher or an xterm title sets
+    // it, so it reads well as the title for body-only sequences (OSC 9, bell).
+    const labelOf = (widget: TerminalWidget): string =>
+      widget.title.label || trans.__('Terminal');
+
+    const onOsc9 = (widget: TerminalWidget, data: string): boolean => {
+      // OSC 9 is overloaded: ConEmu/Windows Terminal use `9 ; <n> ; …`
+      // subcommands (e.g. `9 ; 4` progress), so skip a numeric-subcommand
+      // payload and leave it unconsumed rather than treat it as a notification.
+      if (/^\d+(;|$)/.test(data)) {
+        return false;
+      }
+      const message = sanitize(data);
+      if (message) {
+        notify(widget, labelOf(widget), message);
+      }
+      return true;
+    };
+
+    const onOsc777 = (widget: TerminalWidget, data: string): boolean => {
+      // `notify ; <title> ; <body>`; a body may contain ';'. Other OSC 777
+      // subcommands are left unconsumed.
+      const parts = data.split(';');
+      if (parts.shift() !== 'notify') {
+        return false;
+      }
+      const title = sanitize(parts.shift() ?? '') || labelOf(widget);
+      const body = sanitize(parts.join(';'));
+      if (body || title) {
+        notify(widget, title, body);
+      }
+      return true;
+    };
+
+    const onBell = (widget: TerminalWidget): void => {
+      if (notifyOnBell) {
+        notify(widget, labelOf(widget), trans.__('Activity in terminal'));
+      }
+    };
+
+    const hookWidget = (widget: TerminalWidget): void => {
+      if (hooks.has(widget)) {
+        return;
+      }
+      const content = widget.content as ITerminalContentInternals;
+      void content.ready
+        .then(() => {
+          const term = content._term;
+          if (widget.isDisposed) {
+            return;
+          }
+          if (!term) {
+            console.warn(
+              'xtralab: xterm internals not found; terminal notifications are disabled for this terminal'
+            );
+            return;
+          }
+          // Handlers are wrapped so a parse slip cannot break xterm's parser; an
+          // OSC handler returns whether it consumed the sequence.
+          const disposables: IXtermDisposable[] = [
+            term.onBell(() => guard(() => onBell(widget))),
+            term.parser.registerOscHandler(OSC_ITERM2_GROWL, data =>
+              guardOsc(() => onOsc9(widget, data))
+            ),
+            term.parser.registerOscHandler(OSC_RXVT_NOTIFY, data =>
+              guardOsc(() => onOsc777(widget, data))
+            )
+          ];
+          hooks.set(widget, disposables);
+          widget.disposed.connect(() => {
+            for (const disposable of disposables) {
+              disposable.dispose();
+            }
+            hooks.delete(widget);
+          });
+        })
+        .catch(reason => {
+          console.warn(
+            'xtralab: could not hook terminal notifications',
+            reason
+          );
+        });
+    };
+
+    tracker.forEach(hookWidget);
+    tracker.widgetAdded.connect((_, widget) => hookWidget(widget));
+
+    // Focus the terminal that fired a notification when the desktop shell
+    // reports a click. `terminal:open` activates its tab or reopens the session.
+    const desktopBridge = (window as Window & { xtralab?: IDesktopBridge })
+      .xtralab;
+    desktopBridge?.onFocusTerminal?.(session => {
+      if (session) {
+        void app.commands.execute('terminal:open', { name: session });
+      }
+    });
+
+    if (settingRegistry) {
+      try {
+        const settings = await settingRegistry.load(PLUGIN_ID);
+        const readSettings = (): void => {
+          enabled = boolOption(settings.composite.enabled, true);
+          notifyOnBell = boolOption(settings.composite.notifyOnBell, true);
+        };
+        readSettings();
+        settings.changed.connect(readSettings);
+      } catch (reason) {
+        console.error(
+          'xtralab: failed to load terminal-notifications settings',
+          reason
+        );
+      }
+    }
+  }
+};
+
+// Run `fn`, swallowing errors so a malformed escape sequence cannot take the
+// terminal's parser or bell handler down with it.
+function guard(fn: () => void): void {
+  try {
+    fn();
+  } catch (reason) {
+    console.warn('xtralab: terminal notification handler failed', reason);
+  }
+}
+
+// `guard` for an OSC handler that reports whether it consumed the sequence.
+function guardOsc(fn: () => boolean): boolean {
+  try {
+    return fn();
+  } catch (reason) {
+    console.warn('xtralab: terminal notification handler failed', reason);
+    return false;
+  }
+}
+
+// Replace control characters with spaces (so a notification cannot carry escape
+// sequences), collapse whitespace, and clamp the length.
+function sanitize(value: string): string {
+  let result = '';
+  for (const char of value) {
+    const code = char.codePointAt(0) ?? 0;
+    const isControl = code < 0x20 || (code >= 0x7f && code <= 0x9f);
+    result += isControl ? ' ' : char;
+  }
+  return result.replace(/\s+/g, ' ').trim().slice(0, MAX_TEXT_LENGTH);
+}
+
+function boolOption(value: unknown, fallback: boolean): boolean {
+  return typeof value === 'boolean' ? value : fallback;
+}
+
+export default plugin;

package/src/terminals/model.ts

@@ -194,7 +194,7 @@ export class SessionRegistry implements IDisposable {
 
   /**
    * Return the open widget for a session, if any. The panel uses this to
-   * switch behaviour between "activate existing tab" and "open a new tab
+   * switch behavior between "activate existing tab" and "open a new tab
    * connected to the live session".
    */
   widgetFor(name: string): TerminalWidget | null {

package/src/terminals/widget.tsx

@@ -32,7 +32,7 @@ export const RUNNING_TERMINALS_ID = 'xtralab-running-terminals';
  * Backed by {@link SessionRegistry}: a `UseSignal` re-renders the list
  * whenever the registry emits `stateChanged`, so it tracks
  * `runningChanged` and the agent-title cache without any local state.
- * Click behaviour (activate vs. reopen, shutdown, new terminal) is
+ * Click behavior (activate vs. reopen, shutdown, new terminal) is
  * delegated to plugin-supplied callbacks so the widget never imports
  * `app`.
  */

package/style/git.css

@@ -40,12 +40,7 @@
   color: var(--jp-ui-font-color1);
 
   /*
-   * Map JupyterLab's theme variables onto the `--diffs-*-override`
-   * properties the library exposes. The `*-override` variants take
-   * precedence over the library's defaults, so these values track the
-   * JupyterLab theme automatically — no JS needed when the theme
-   * switches. Theme-dependent colors (insertion green, deletion red, …)
-   * still come from the active Shiki theme passed via `options.theme`.
+   * Feed JupyterLab theme colors into @pierre/diffs.
    */
   --diffs-bg-override: var(--jp-layout-color1);
   --diffs-bg-buffer-override: var(--jp-layout-color1);
@@ -58,6 +53,8 @@
   --diffs-fg-number-override: var(--jp-ui-font-color3);
   --diffs-fg-conflict-marker-override: var(--jp-warn-color1);
   --diffs-modified-color-override: var(--jp-warn-color1);
+  --diffs-addition-color-override: var(--jp-success-color1);
+  --diffs-deletion-color-override: var(--jp-error-color1);
 }
 
 /*
@@ -91,7 +88,9 @@
   font-size: var(--jp-ui-font-size0);
 }
 
-/* Breathing room when both toggles appear (notebook diff in JSON view). */
+/*
+ * Breathing room when both toggles appear (notebook diff in JSON view).
+ */
 .jp-xtralab-DiffWidget-diffStyleToolbarItem {
   margin-left: 4px;
 }
@@ -589,7 +588,9 @@
 
 .jp-xtralab-ImageDiff-frame,
 .jp-xtralab-ImageDiff-stack {
-  /* Checkerboard so transparent regions are obvious; theme-neutral. */
+  /*
+   * Checkerboard so transparent regions are obvious; theme-neutral.
+   */
   background-color: #fff;
   background-image:
     linear-gradient(45deg, #c8c8c8 25%, transparent 25%),
@@ -766,7 +767,9 @@
   bottom: -14px;
 }
 
-/* Chevron triangles drawn with borders so no asset is needed. */
+/*
+ * Chevron triangles drawn with borders so no asset is needed.
+ */
 .jp-xtralab-ImageDiff-swipeDividerArrow {
   width: 0;
   height: 0;

package/style/index.css

@@ -2,6 +2,7 @@
 @import url('editorBreadcrumbs.css');
 @import url('git.css');
 @import url('launcher.css');
+@import url('sidebar.css');
 @import url('tabs.css');
 @import url('terminals.css');
 @import url('topBar.css');

package/style/index.js

@@ -1,6 +1,7 @@
 import './base.css';
 import './git.css';
 import './launcher.css';
+import './sidebar.css';
 import './tabs.css';
 import './terminals.css';
 import './topBar.css';

package/style/launcher.css

@@ -166,8 +166,8 @@
 
 /*
  * Changed files list. Each row is a button so click + keyboard activate
- * both work; the badge on the left mirrors the single-letter status
- * indicator the git panel uses, kept in sync via FileChangeStatus.
+ * both work; the letter on the left is the file's single-letter git status,
+ * colored to match the @pierre/trees file tree's decorations.
  */
 .jp-xtralab-Launcher-changes {
   list-style: none;
@@ -178,6 +178,27 @@
   border: 1px solid var(--jp-border-color2);
   border-radius: 4px;
   overflow: hidden;
+
+  /*
+   * Git status letter palette, mirroring the @pierre/trees `--trees-status-*`
+   * defaults. The file tree resolves those through `light-dark()` under
+   * `color-scheme: light dark` — i.e. by OS appearance — so the
+   * `prefers-color-scheme` override below reproduces that exact resolution
+   * and keeps these letters in lockstep with the tree's.
+   */
+  --xtralab-git-status-added: #16a994;
+  --xtralab-git-status-modified: #1ca1c7;
+  --xtralab-git-status-renamed: #d5a910;
+  --xtralab-git-status-deleted: #ff2e3f;
+}
+
+@media (prefers-color-scheme: dark) {
+  .jp-xtralab-Launcher-changes {
+    --xtralab-git-status-added: #00cab1;
+    --xtralab-git-status-modified: #08c0ef;
+    --xtralab-git-status-renamed: #ffd452;
+    --xtralab-git-status-deleted: #ff6762;
+  }
 }
 
 .jp-xtralab-Launcher-changes > li + li {
@@ -207,35 +228,42 @@
   outline-offset: -1px;
 }
 
+/*
+ * Bare colored letter, not a filled badge — the same treatment the
+ * @pierre/trees file tree gives its git status decorations. The fixed width
+ * keeps the letters in a tidy gutter so the paths stay column-aligned.
+ */
 .jp-xtralab-Launcher-change-badge {
   display: inline-flex;
   align-items: center;
   justify-content: center;
-  width: 18px;
-  height: 18px;
-  font-size: 10px;
-  font-weight: 700;
-  border-radius: 3px;
+  width: 14px;
+  flex: 0 0 auto;
   font-family: var(--jp-code-font-family);
-  background-color: var(--jp-layout-color2);
+  font-size: var(--jp-code-font-size);
+  font-weight: 600;
   color: var(--jp-ui-font-color2);
-  flex: 0 0 auto;
-}
-
-.jp-xtralab-Launcher-change-modified {
-  background-color: var(--jp-warn-color3, var(--jp-layout-color2));
-  color: var(--jp-warn-color1, var(--jp-ui-font-color1));
 }
 
 .jp-xtralab-Launcher-change-added,
 .jp-xtralab-Launcher-change-untracked {
-  background-color: var(--jp-success-color3, var(--jp-layout-color2));
-  color: var(--jp-success-color1, var(--jp-ui-font-color1));
+  color: var(--xtralab-git-status-added);
+}
+
+/* The file tree folds unmerged/typechange/unknown onto modified; match it. */
+.jp-xtralab-Launcher-change-modified,
+.jp-xtralab-Launcher-change-unmerged,
+.jp-xtralab-Launcher-change-typechange,
+.jp-xtralab-Launcher-change-unknown {
+  color: var(--xtralab-git-status-modified);
+}
+
+.jp-xtralab-Launcher-change-renamed {
+  color: var(--xtralab-git-status-renamed);
 }
 
 .jp-xtralab-Launcher-change-deleted {
-  background-color: var(--jp-error-color3, var(--jp-layout-color2));
-  color: var(--jp-error-color1, var(--jp-ui-font-color1));
+  color: var(--xtralab-git-status-deleted);
 }
 
 .jp-xtralab-Launcher-change-path {

package/style/sidebar.css

@@ -0,0 +1,14 @@
+/*
+ * The side activity bar is shipped horizontally (activityBarPosition: "top",
+ * see jupyter-config/labconfig). In that mode the TabBar content node spans
+ * the full width (@jupyterlab/application/style/sidepanel.css) with no
+ * justify-content, so the icons sit at the leading edge. Center them under
+ * the menu bar instead.
+ *
+ * `safe center` keeps the row start-aligned should the icons ever exceed the
+ * bar width, so none are pushed past the leading edge out of reach of the
+ * content node's horizontal overflow scroll.
+ */
+.jp-SideBar[data-orientation='horizontal'] .lm-TabBar-content {
+  justify-content: safe center;
+}