@kabmo-labs/kabmo 0.7.0 → 0.9.0

package/src/shared/lib/fs/paths.test.ts

@@ -4,7 +4,7 @@
  */
 
 import { describe, expect, test } from 'bun:test';
-import { isVirtualPath, stripReadSelector } from '@/shared/lib/fs/paths';
+import { isVirtualPath, lastPathSegment, stripReadSelector } from '@/shared/lib/fs/paths';
 
 describe('stripReadSelector', () => {
   test('peels every selector shape omp accepts', () => {
@@ -88,3 +88,26 @@ describe('isVirtualPath', () => {
     expect(isVirtualPath('')).toBe(false);
   });
 });
+
+describe('lastPathSegment', () => {
+  test('names the last segment on either separator', () => {
+    // The Windows case is the one that shipped broken: the composer's target
+    // trigger read `kabmo · C:\Users\…\cosmic-dolphin`, because `split('/')`
+    // has nothing to cut in a `\`-separated absolute path.
+    expect(lastPathSegment('/data/worktrees/abc/cosmic-dolphin')).toBe('cosmic-dolphin');
+    expect(lastPathSegment('C:\\Users\\u\\AppData\\Local\\worktrees\\abc\\cosmic-dolphin')).toBe('cosmic-dolphin');
+    expect(lastPathSegment('wt/nested/branch')).toBe('branch');
+  });
+
+  test('a trailing separator names the same thing', () => {
+    expect(lastPathSegment('/data/worktrees/abc/cosmic-dolphin/')).toBe('cosmic-dolphin');
+    expect(lastPathSegment('C:\\worktrees\\abc\\cosmic-dolphin\\')).toBe('cosmic-dolphin');
+  });
+
+  test('nothing to name is empty, not a stray separator', () => {
+    expect(lastPathSegment(undefined)).toBe('');
+    expect(lastPathSegment(null)).toBe('');
+    expect(lastPathSegment('')).toBe('');
+    expect(lastPathSegment('/')).toBe('');
+  });
+});

package/src/shared/lib/fs/paths.ts

@@ -107,3 +107,20 @@ export function toAbsolutePath(baseDir: string | null | undefined, relPath: stri
   // Join with the base's own separator: `C:\proj` + `src` → `C:\proj\src`.
   return `${base}${base.includes('\\') && !base.includes('/') ? '\\' : '/'}${rel}`;
 }
+
+/**
+ * The last segment of a path on ANY platform.
+ *
+ * `split('/').pop()` is the shape this replaces, and it is wrong for every
+ * ABSOLUTE path on Windows: a worktree the server created under
+ * `C:\…\worktrees\<id>\cosmic-dolphin` came back whole, so the composer's target
+ * trigger read `kabmo · C:\Users\…\cosmic-dolphin` instead of
+ * `kabmo · cosmic-dolphin` (measured on the Windows E2E leg, which is the only
+ * place it shows — every POSIX path splits the same either way). A trailing
+ * separator is dropped first so `…/cosmic-dolphin/` names the same worktree.
+ */
+export function lastPathSegment(target: string | null | undefined): string {
+  if (!target) return '';
+  const parts = target.replace(/[/\\]+$/, '').split(/[/\\]/);
+  return parts[parts.length - 1] ?? '';
+}

package/src/shared/lib/fs/worktree/settings-keys.ts

@@ -0,0 +1,18 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * The two worktree setting keys, in a module with NO server imports.
+ *
+ * The server reads them from `kabmo_settings` (`lib/fs/worktree/settings.server.ts`)
+ * and the settings panel writes them through `writeSetting`; both sides need the
+ * same strings, and the client bundle must not pull in `@/db.server` to get them.
+ */
+
+/** Parent directory new worktrees are created in; empty means the default. */
+export const WORKTREE_DIRECTORY_SETTING = 'worktreeDirectory';
+
+/** Whether a create copies the project's ignored build folders. Default: on. */
+export const WORKTREE_CARRY_SETTING = 'worktreeCarryIgnored';

package/src/shared/lib/omp/session/prewarm.ts

@@ -32,7 +32,14 @@ export function spawnCwdForNewSession(
   folders: PrewarmFolderShape[],
   activeSessionId: string | number | null,
   folderId?: number | string,
+  /**
+   * A worktree the draft chose. It wins over the folder's project path, because
+   * that is the whole point of picking one: the chat is born in the worktree and
+   * nothing is ever relocated afterwards.
+   */
+  worktreePath?: string | null,
 ): string | null {
+  if (worktreePath) return worktreePath;
   const target = folderId !== undefined
     ? folders.find((f) => String(f.id) === String(folderId))
     : folders.find((f) => f.sessions?.some((s) => String(s.id) === String(activeSessionId)))

package/src/shared/lib/realtime/protocol.ts

@@ -45,6 +45,22 @@ export const TOPIC_SIDEBAR = 'sidebar';
  *  the structure needs a JSONL scan to produce. */
 export const TOPIC_SIDEBAR_STATUS = 'sidebar:status';
 
+/**
+ * The last-activity stamp of each session with a run IN FLIGHT, keyed by id.
+ *
+ * Split from `sidebar` for the same reason `sidebar:status` is, but the cost
+ * difference is far larger: a transcript grows on every tool call, so this
+ * changes per tool call while the structure is a 216 KB payload over 731
+ * sessions (measured on the author's install) that must be re-scanned to
+ * produce. Only a RUNNING session's stamp can move between turn boundaries, so
+ * only those are carried — the payload is one ISO string per live run
+ * (measured: 87 bytes for one), against 216 KB for the whole list.
+ *
+ * The structure remains the authority for every other row; this only ever
+ * ADVANCES a stamp the structure already carries (see `applySidebarActivity`).
+ */
+export const TOPIC_SIDEBAR_ACTIVITY = 'sidebar:activity';
+
 /** One session's live conversation: agent frames, queue and modes. */
 export function sessionTopic(sessionId: string): string {
   return `session:${sessionId}`;

package/src/shared/lib/ui/toolbar-overflow.test.ts

@@ -0,0 +1,83 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * The `⋯` rule, asserted as arithmetic.
+ *
+ * Each case is a failure the toolbars had: a row that wrapped into two rows
+ * instead of hiding a control, a control hidden while the width was still
+ * unknown (a menu flashing on every mount), and a pinned control buried in the
+ * menu because the row happened to be narrow.
+ */
+
+import { describe, expect, test } from 'bun:test';
+
+import {
+  TOOLBAR_ITEM_GAP_PX,
+  TOOLBAR_OVERFLOW_TRIGGER_PX,
+  toolbarHasOverflow,
+  toolbarVisibleClusters,
+} from '@/shared/lib/ui/toolbar-overflow';
+
+/** Save, find, wrap, zoom, copy, modes, full screen — the editor's real row. */
+const widths = [26, 26, 26, 52, 52, 52, 26];
+const pinned = [true, false, false, false, false, true, true];
+
+/** Row width needed to draw `visible` plus the trigger when anything is hidden. */
+function rowWidth(visible: boolean[]): number {
+  const shown = widths.filter((_, index) => visible[index]);
+  const overflow = toolbarHasOverflow(visible);
+  return (
+    shown.reduce((sum, width) => sum + width, 0) +
+    TOOLBAR_ITEM_GAP_PX * Math.max(0, shown.length - 1) +
+    (overflow ? TOOLBAR_OVERFLOW_TRIGGER_PX + TOOLBAR_ITEM_GAP_PX : 0)
+  );
+}
+
+describe('toolbarVisibleClusters', () => {
+  test('an unmeasured row shows every cluster', () => {
+    // Not "hide everything": the row is measured a layout effect later, and a
+    // menu that flashes on every mount is worse than one frame of a full row.
+    expect(toolbarVisibleClusters({ widths, pinned, available: 0 }).every(Boolean)).toBe(true);
+  });
+
+  test('a row wide enough for everything shows everything, with no trigger', () => {
+    const total = widths.reduce((sum, width) => sum + width, 0) + TOOLBAR_ITEM_GAP_PX * (widths.length - 1);
+    const visible = toolbarVisibleClusters({ widths, pinned, available: total });
+    expect(visible.every(Boolean)).toBe(true);
+    expect(toolbarHasOverflow(visible)).toBe(false);
+  });
+
+  test('a narrow row hides what does not fit and reserves the trigger', () => {
+    // 200px of row: the three pinned clusters (26 + 52 + 26) plus their gaps
+    // leave room for one unpinned control and the `⋯` trigger, and no more.
+    const visible = toolbarVisibleClusters({ widths, pinned, available: 200 });
+    expect(toolbarHasOverflow(visible)).toBe(true);
+    // The promise the arithmetic has to keep: what stays plus the trigger fits.
+    expect(rowWidth(visible)).toBeLessThanOrEqual(200);
+  });
+
+  test('a pinned cluster stays on the row at any width', () => {
+    // A 120px row fits one 26px control plus the trigger, and the pinned width
+    // modes (52px) would not fit at all on their own — they stay regardless,
+    // because a menu-only mode button is a mode the reader never finds.
+    const visible = toolbarVisibleClusters({ widths, pinned, available: 120 });
+    expect(visible[0]).toBe(true);
+    expect(visible[5]).toBe(true);
+    expect(visible[6]).toBe(true);
+    // The unpinned controls are what gives way.
+    expect(visible[1]).toBe(false);
+  });
+
+  test('order is preserved: what stays is a subsequence, not a re-sort', () => {
+    const visible = toolbarVisibleClusters({ widths, pinned, available: 200 });
+    const shownIndexes = visible.flatMap((isShown, index) => (isShown ? [index] : []));
+    expect([...shownIndexes].sort((a, b) => a - b)).toEqual(shownIndexes);
+  });
+
+  test('no clusters is no row', () => {
+    expect(toolbarVisibleClusters({ widths: [], pinned: [], available: 500 })).toEqual([]);
+  });
+});

package/src/shared/lib/ui/toolbar-overflow.ts

@@ -0,0 +1,86 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Which toolbar clusters fit on ONE row, and which go into the `⋯` menu.
+ *
+ * The editor and diff toolbars carry ten-plus controls and the editor panel is
+ * 320px wide on a 1440px screen. WRAPPING was the previous answer and it is the
+ * wrong one: a second row moves the document down by the toolbar's own height
+ * and reads as a second toolbar. A horizontal scroll is worse still — a clipped
+ * control is invisible and reads as "there is nothing more here".
+ *
+ * So: the clusters that do not fit move into a `⋯` menu, and a cluster can be
+ * PINNED to stay on the row at every width. Pinning is what keeps this from
+ * being a priority guess — the toolbar's visual order is not its priority order
+ * (Save is drawn first because that is where a reader looks for it, while the
+ * width modes sit last and are the reason the panel exists).
+ *
+ * Pure, and measured widths in: the caller lays the clusters out once and hands
+ * their rendered widths here. A table of guessed pixel widths drifts the moment
+ * a label, an icon or a font changes.
+ */
+
+/** Width the `⋯` trigger needs, including the gap before it. */
+export const TOOLBAR_OVERFLOW_TRIGGER_PX = 30;
+
+/** Gap between two clusters (`gap-x-1`). */
+export const TOOLBAR_ITEM_GAP_PX = 4;
+
+export interface ToolbarOverflowArgs {
+  /** Rendered width of each cluster, in row order. */
+  widths: number[];
+  /** Which clusters never leave the row. Same length as `widths`. */
+  pinned: boolean[];
+  /** Width the row actually has, or 0 before it is measured. */
+  available: number;
+}
+
+/**
+ * Which clusters to render on the row, in row order.
+ *
+ * An unmeasured row (available 0) keeps everything: hiding controls before the
+ * width is known flashes a menu on every mount, and the row is measured a
+ * layout effect later.
+ */
+export function toolbarVisibleClusters({ widths, pinned, available }: ToolbarOverflowArgs): boolean[] {
+  if (!(available > 0) || widths.length === 0) return widths.map(() => true);
+
+  const total = widths.reduce((sum, width) => sum + width, 0) + TOOLBAR_ITEM_GAP_PX * (widths.length - 1);
+  if (total <= available) return widths.map(() => true);
+
+  // Pinned clusters are placed FIRST and in full, because whether the row is
+  // wide enough for them is not a question — they stay and the row clips if it
+  // must. The unpinned ones then take whatever is left, in row order, once the
+  // `⋯` trigger's own width is set aside. Filling in one pass over row order
+  // instead would let an early unpinned control consume the space a pinned one
+  // later needs.
+  const shown = widths.map(() => false);
+  let used = 0;
+  let rendered = 0;
+  widths.forEach((width, index) => {
+    if (!pinned[index]) return;
+    used += width + (rendered > 0 ? TOOLBAR_ITEM_GAP_PX : 0);
+    rendered += 1;
+    shown[index] = true;
+  });
+
+  let budget = available - used - TOOLBAR_OVERFLOW_TRIGGER_PX - TOOLBAR_ITEM_GAP_PX;
+  widths.forEach((width, index) => {
+    if (pinned[index]) return;
+    const cost = width + (rendered > 0 ? TOOLBAR_ITEM_GAP_PX : 0);
+    if (cost > budget) return;
+    budget -= cost;
+    rendered += 1;
+    shown[index] = true;
+  });
+
+  return shown;
+}
+
+/** True when at least one cluster is going into the menu. */
+export function toolbarHasOverflow(visible: boolean[]): boolean {
+  return visible.some((shown) => !shown);
+}

package/src/shared/lib/updates/shell-arch.ts

@@ -0,0 +1,54 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * The architecture a DESKTOP shell runs as, and the artifact it installs itself
+ * from.
+ *
+ * ## Why this exists at all
+ *
+ * Every desktop artifact is per-architecture (`Kabmo-0.2.0-mac-arm64.zip`,
+ * `Kabmo-0.2.0-win-x64-setup.exe`), and the console used to answer a desktop
+ * probe with the RELEASE PAGE precisely because it could not know which
+ * architecture the window asking was running on. That is correct for a link and
+ * useless for a self-update: handing an arm64 reader an x64 installer produces
+ * an app that does not launch, and on Windows an installer that refuses with
+ * "this installation package could not be opened".
+ *
+ * So a desktop shell reports its own architecture over the bridge, and the
+ * server names the ONE artifact. This module is the vocabulary both ends share,
+ * which is what stops the shell, the route and the asset table from spelling
+ * `x86_64`, `x64` and `amd64` for the same machine.
+ *
+ * ## Two spellings, one canonical token
+ *
+ * A shell reports the CANONICAL token (`arm64` / `x64`) because that is what the
+ * client and the route pass around. Each platform's release assets spell its
+ * architecture differently — Linux says `x86_64`, macOS and Windows say `x64` —
+ * and that mapping lives in ONE table (`SHELL_ASSETS`), on the server, next to
+ * the names it has to match. A shell that mapped its own spelling to the asset's
+ * would be a second copy of the same fact.
+ */
+
+/** A desktop architecture, in the vocabulary the console and the shells share. */
+export type ShellArch = 'arm64' | 'x64';
+
+/**
+ * Read a canonical arch out of a string, or null.
+ *
+ * Lenient about the spellings a shell might report (a shell that read
+ * `std::env::consts::ARCH` says `x86_64`; one that read
+ * `RuntimeInformation.ProcessArchitecture` says `X64`), because a refused arch
+ * costs the reader the self-update and buys nothing: the value only chooses
+ * between two artifacts of the same product, and the artifact is then verified
+ * by the shell before it is installed.
+ */
+export function parseShellArch(value: string | null | undefined): ShellArch | null {
+  if (!value) return null;
+  const folded = value.trim().toLowerCase();
+  if (folded === 'arm64' || folded === 'aarch64') return 'arm64';
+  if (folded === 'x64' || folded === 'x86_64' || folded === 'amd64') return 'x64';
+  return null;
+}

package/src/shared/lib/updates/shell-ua.ts

@@ -19,14 +19,34 @@
  */
 
 /** The native shells that report themselves on the UA. */
-export type ShellKind = 'android' | 'ios';
+export type MobileShellKind = 'android' | 'ios';
 
-/** The token's name, before the slash, per shell. */
-export const SHELL_UA_PREFIXES: Record<ShellKind, string> = {
+/**
+ * The desktop shells. They carry NO User-Agent token — a desktop app is not
+ * downloaded from a page, so the server has nothing to parse per request. They
+ * report their version and their ARCHITECTURE over the shell bridge instead
+ * (`__kabmoDesktop`), which is why they are a separate family: both facts exist,
+ * the UA channel does not.
+ */
+export type DesktopShellKind = 'macos' | 'windows' | 'linux';
+
+/** Every shell Kabmo publishes an artifact for. */
+export type ShellKind = MobileShellKind | DesktopShellKind;
+
+/** The token's name, before the slash, per MOBILE shell. */
+export const SHELL_UA_PREFIXES: Record<MobileShellKind, string> = {
   android: 'KabmoAndroid/',
   ios: 'KabmoIOS/',
 };
 
+/** The desktop family, in the order their release tracks were added. */
+export const DESKTOP_SHELL_KINDS: readonly DesktopShellKind[] = ['macos', 'windows', 'linux'];
+
+/** Whether a shell reports itself over the bridge rather than the User-Agent. */
+export function isDesktopShellKind(kind: string): kind is DesktopShellKind {
+  return (DESKTOP_SHELL_KINDS as readonly string[]).includes(kind);
+}
+
 /**
  * Whether this request came from an Android device at all — the app or a
  * browser on it.
@@ -60,7 +80,7 @@ export function isAndroidDevice(userAgent: string | null | undefined): boolean {
  */
 export function shellVersion(
   userAgent: string | null | undefined,
-  kind: ShellKind,
+  kind: MobileShellKind,
 ): string | null {
   if (!userAgent) return null;
 

package/src/shared/lib/workspace/active-project.ts

@@ -23,6 +23,29 @@ export function activeProjectForSession(
   return { folder: null, projectPath: null };
 }
 
+/**
+ * The root the right-panel tools should operate on for this session: its own
+ * worktree when the session's cwd is a linked checkout, else the folder's
+ * registered project path.
+ *
+ * A worktree session runs OUTSIDE its folder's project directory, so pointing
+ * the panels at `project_path` showed the checkout the agent had left — measured:
+ * every panel kept reading the main tree while the run wrote to the worktree.
+ * The server's `resolveRoot` accepts a worktree of a registered project for the
+ * same reason, so the two agree about what is readable.
+ */
+export function effectiveRootFor(
+  folders: WorkspaceFolderData[],
+  sessionId: string | number | null | undefined,
+): string | null {
+  const { folder } = activeProjectForSession(folders, sessionId);
+  if (!folder) return null;
+  const row = (folder.sessions || []).find((session) => String(session.id) === String(sessionId));
+  const worktree = row?.worktree;
+  if (worktree && worktree.status === 'ready') return worktree.path;
+  return folder.project_path ?? null;
+}
+
 /**
  * Resolve the workspace root the composer should scope `@` file mentions to:
  * the active session's bound project first, then the explicitly selected

package/src/shared/lib/workspace/editor-view-mode.test.ts

@@ -0,0 +1,70 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * The three width modes' table, asserted as data.
+ *
+ * Each case is a rule the layout depends on and that no component test would
+ * catch: `compact` must NOT hide the sidebar (that is `full`'s job, and the
+ * two buttons would be the same button if it did), the right panel is hidden
+ * by neither, and clicking an active mode returns to `normal` rather than
+ * doing nothing.
+ */
+
+import { describe, expect, test } from 'bun:test';
+
+import {
+  DEFAULT_EDITOR_VIEW_MODE,
+  isEditorViewMode,
+  editorViewHides,
+  toggledEditorViewMode,
+} from '@/shared/lib/workspace/editor-view-mode';
+
+describe('editorViewHides', () => {
+  test('compact hides the chat only', () => {
+    expect(editorViewHides('compact', 'chat')).toBe(true);
+    expect(editorViewHides('compact', 'sidebar')).toBe(false);
+  });
+
+  test('full hides the chat AND the sidebar', () => {
+    expect(editorViewHides('full', 'chat')).toBe(true);
+    expect(editorViewHides('full', 'sidebar')).toBe(true);
+  });
+
+  test('normal hides nothing', () => {
+    expect(editorViewHides('normal', 'chat')).toBe(false);
+    expect(editorViewHides('normal', 'sidebar')).toBe(false);
+  });
+});
+
+describe('toggledEditorViewMode', () => {
+  test('a mode button enters its mode', () => {
+    expect(toggledEditorViewMode('normal', 'compact')).toBe('compact');
+    expect(toggledEditorViewMode('normal', 'full')).toBe('full');
+  });
+
+  test('the OTHER mode switches rather than toggling off', () => {
+    expect(toggledEditorViewMode('compact', 'full')).toBe('full');
+    expect(toggledEditorViewMode('full', 'compact')).toBe('compact');
+  });
+
+  test('clicking the active mode returns to normal', () => {
+    expect(toggledEditorViewMode('compact', 'compact')).toBe('normal');
+    expect(toggledEditorViewMode('full', 'full')).toBe('normal');
+  });
+});
+
+describe('isEditorViewMode', () => {
+  test('accepts the three modes and nothing else', () => {
+    expect(['normal', 'compact', 'full'].every(isEditorViewMode)).toBe(true);
+    expect(isEditorViewMode('fullscreen')).toBe(false);
+    expect(isEditorViewMode(undefined)).toBe(false);
+    expect(isEditorViewMode(null)).toBe(false);
+  });
+
+  test('the fallback is the ordinary layout', () => {
+    expect(DEFAULT_EDITOR_VIEW_MODE).toBe('normal');
+  });
+});

package/src/shared/lib/workspace/editor-view-mode.ts

@@ -0,0 +1,48 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * How wide the editor column is allowed to be, as ONE of three modes.
+ *
+ * `compact` and `full` both hide the chat timeline and let the editor take the
+ * width the chat had; `full` also hides the session sidebar. Neither touches
+ * the right panel: the point of the two modes is a wider DOCUMENT, and the
+ * right column is where the outline, search hits and the diff list live while
+ * it is being read. The third width — the existing `fixed inset-0` full
+ * SCREEN — is a different thing entirely (it covers the right panel too) and
+ * stays where it is, on its own button.
+ *
+ * The rules are pure so the layout, both toolbars and the tests read the same
+ * table: which columns a mode hides is data, never a condition at a call site.
+ */
+
+export type EditorViewMode = 'normal' | 'compact' | 'full';
+
+/** The two modes a toolbar button can name. */
+export type EditorViewModeTarget = 'compact' | 'full';
+
+/** Session-state slot. Per session, like every other layout choice. */
+export const EDITOR_VIEW_MODE_KEY = 'layout.editorViewMode';
+
+export const DEFAULT_EDITOR_VIEW_MODE: EditorViewMode = 'normal';
+
+/** A stored value written by another build is not a mode this one can draw. */
+export function isEditorViewMode(value: unknown): value is EditorViewMode {
+  return value === 'normal' || value === 'compact' || value === 'full';
+}
+
+/**
+ * What a mode HIDES. `full` hides everything `compact` does plus the sidebar,
+ * so it is strictly wider — the two are ordered, not alternatives.
+ */
+export function editorViewHides(mode: EditorViewMode, column: 'chat' | 'sidebar'): boolean {
+  if (column === 'chat') return mode === 'compact' || mode === 'full';
+  return mode === 'full';
+}
+
+/** Clicking the mode a button already names returns to `normal`. */
+export function toggledEditorViewMode(current: EditorViewMode, next: EditorViewModeTarget): EditorViewMode {
+  return current === next ? 'normal' : next;
+}

package/src/shared/lib/workspace/panel-widths.test.ts

@@ -124,6 +124,27 @@ describe('resolvePanelWidth', () => {
     // panel keeps its minimum and the row clips, rather than collapsing.
     expect(resolvePanelWidth({ ...base, available: 400, siblingWidth: 320, handleCount: 2 })).toBe(320);
   });
+
+  test('a collapsed chat removes the floor AND the pair caps', () => {
+    const available = 2000;
+    // The ordinary layout would cap this at 0.6 × 2000 = 1200 (own cap) and at
+    // 0.7 × 2000 − 320 = 1080 (pair cap, a sibling reserving its floor), and the
+    // chat's 400 floor would bind at 1280. With no chat on screen there is no
+    // conversation to leave room for, so only the group's own width limits it.
+    const wanted = { fraction: 0.9 };
+    expect(resolvePanelWidth({ ...base, available, siblingWidth: 320, handleCount: 1, stored: wanted })).toBe(
+      Math.round(PAIR_MAX_FRACTION * available),
+    );
+    expect(resolvePanelWidth({ ...base, available, siblingWidth: 320, handleCount: 1, stored: wanted, chatHidden: true })).toBe(
+      available - 320 - 1 * 3,
+    );
+  });
+
+  test('the floor still wins with the chat collapsed', () => {
+    // A group narrower than the sibling and this panel's floor: the panel keeps
+    // its minimum rather than collapsing into nothing.
+    expect(resolvePanelWidth({ ...base, available: 400, siblingWidth: 320, handleCount: 1, chatHidden: true })).toBe(320);
+  });
 });
 
 describe('the editor/right-panel pair', () => {
@@ -273,4 +294,13 @@ describe('pairMaxSize (the drag cap)', () => {
   test('no measured area means no cap', () => {
     expect(pairMaxSize({ available: null, siblingMin: editorMin, siblingOpen: true })).toBeUndefined();
   });
+
+  test('a collapsed chat lets a drag reach the whole row', () => {
+    // Two panels and nothing else: the editor may be dragged up to the group's
+    // width minus the right panel's floor. The 0.6 own-cap would have frozen the
+    // separator at 2400 of 4000 with 1600px of empty row behind it.
+    expect(pairMaxSize({ available, siblingMin: rightMin, siblingOpen: true, chatHidden: true })).toBe(available - rightMin);
+    // The sibling closed means nothing to reserve at all.
+    expect(pairMaxSize({ available, siblingMin: 0, siblingOpen: false, chatHidden: true })).toBe(available);
+  });
 });

package/src/shared/lib/workspace/panel-widths.ts

@@ -149,6 +149,13 @@ export interface ResolveWidthArgs {
   siblingWidth: number;
   /** Separators in the group, which also consume width. */
   handleCount: number;
+  /**
+   * The CHAT column is collapsed (`compact`/`full` editor views), so it holds no
+   * floor and the pair caps do not apply — both exist to leave the conversation
+   * a share of the group, and neither has anything to reserve once it is off
+   * screen. Keeping them would cap a two-panel layout at 70% of its width.
+   */
+  chatHidden?: boolean;
 }
 
 /**
@@ -172,7 +179,7 @@ export interface ResolveWidthArgs {
  * default pixel width is used unchanged.
  */
 export function resolvePanelWidth(args: ResolveWidthArgs): number {
-  const { stored, defaultFraction, defaultPx, available, min, pairReservePx = 0, siblingWidth, handleCount } = args;
+  const { stored, defaultFraction, defaultPx, available, min, pairReservePx = 0, siblingWidth, handleCount, chatHidden = false } = args;
 
   if (available === null || available <= 0) return Math.max(min, Math.round(stored?.px ?? defaultPx));
 
@@ -182,14 +189,20 @@ export function resolvePanelWidth(args: ResolveWidthArgs): number {
   // `total × available − the sibling's reserved px` — and ROUNDED, because
   // `0.7 × 4000` is `2799.9999…` in binary floating point and flooring it lands
   // a pixel short of the intended share.
-  const ownCap = Math.round(PAIR_MAX_FRACTION * available);
-  const pairCap = Math.round(PAIR_MAX_TOTAL_FRACTION * available) - pairReservePx;
+  //
+  // With the chat COLLAPSED neither cap means anything: the pair's 70% share
+  // and the chat floor are both about leaving the conversation room, and there
+  // is no conversation on screen. Only the group's own width remains a limit,
+  // which is what lets the editor take the width the chat had.
+  const ownCap = chatHidden ? Number.MAX_SAFE_INTEGER : Math.round(PAIR_MAX_FRACTION * available);
+  const pairCap = chatHidden ? Number.MAX_SAFE_INTEGER : Math.round(PAIR_MAX_TOTAL_FRACTION * available) - pairReservePx;
+  const chatFloor = chatHidden ? 0 : MIN_CHAT_PANEL_WIDTH;
   const ceiling = Math.max(
     min,
     Math.min(
       ownCap,
       pairCap,
-      Math.floor(available - MIN_CHAT_PANEL_WIDTH - siblingWidth - handleCount * HANDLE_WIDTH),
+      Math.floor(available - chatFloor - siblingWidth - handleCount * HANDLE_WIDTH),
     ),
   );
 
@@ -263,9 +276,16 @@ export function pairMaxSize(args: {
   siblingMin: number;
   /** The sibling is open and therefore reserves its floor from the pair total. */
   siblingOpen: boolean;
+  /** The chat column is collapsed, so the pair's shared share is the whole group. */
+  chatHidden?: boolean;
 }): number | undefined {
-  const { available, siblingMin, siblingOpen } = args;
+  const { available, siblingMin, siblingOpen, chatHidden = false } = args;
   if (available === null || available <= 0) return undefined;
+  // No chat on screen means nothing to reserve a share FOR: the pair is the
+  // whole row, so each side may be dragged up to the group's width minus the
+  // sibling's floor. The 60% own-cap would freeze a separator halfway across a
+  // layout whose only two panels are the ones being dragged.
+  if (chatHidden) return Math.max(0, Math.floor(available - (siblingOpen ? siblingMin : 0)));
   const ownCap = Math.round(PAIR_MAX_FRACTION * available);
   if (!siblingOpen) return ownCap;
   const pairCap = Math.round(PAIR_MAX_TOTAL_FRACTION * available) - siblingMin;