@kabmo-labs/kabmo 0.3.1 → 0.5.0

package/src/server/routes/waiting/index.ts

@@ -0,0 +1,123 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * `/api/waiting` — prompts held until another session finishes.
+ *
+ * The list is also served over the `waiting` realtime topic, which is what the
+ * sidebar and the composer read; these routes exist for the create/cancel
+ * actions and as the read path for a client whose socket is down.
+ *
+ * Validation is the last gate before the row. In particular the dependency must
+ * look UNFINISHED at creation: a dropdown that went stale (the session finished
+ * while the user was typing) would otherwise create a prompt that is released on
+ * the very next sweep — a prompt the user believed they had deferred. The client
+ * re-checks and sends normally instead; this is the server's own refusal for a
+ * client that did not.
+ */
+
+import { isAbsolute } from 'path';
+import { json } from '@/server/lib/remix-compat';
+import type { ActionFunctionArgs, LoaderFunctionArgs } from '@/server/lib/remix-compat';
+import { methodNotAllowed } from '@/server/lib/route-adapter';
+import { emitRealtimeSignal } from '@/server/lib/realtime/signals.server';
+import { isDependencySettled } from '@/server/lib/waiting/runtime.server';
+import {
+  cancelWaitingPrompt,
+  createWaitingPrompt,
+  getWaitingPrompt,
+  listWaitingPrompts,
+} from '@/server/lib/waiting/store.server';
+import { attachmentHasPayload } from '@/shared/lib/chat/attachments';
+import { parseModeSelection } from '@/server/lib/omp/mode/request';
+import { isSinglePathSegment } from '@/server/lib/fs/path-segment';
+import { isMockMode } from '@/server/mock.server';
+
+/** GET — every prompt a client may still need (waiting + recent outcomes). */
+export async function loader(_args: LoaderFunctionArgs) {
+  return json({ prompts: await listWaitingPrompts() });
+}
+
+function asRecord(value: unknown): Record<string, unknown> {
+  return value && typeof value === 'object' && !Array.isArray(value) ? (value as Record<string, unknown>) : {};
+}
+
+/** POST — hold a prompt until `dependsOn` finishes. */
+async function createPrompt(request: Request) {
+  // A demo install spawns no omp child, so a held prompt could never be sent.
+  // Refused with the reason instead of creating a row that waits forever.
+  if (isMockMode()) {
+    return json(
+      { error: 'Held prompts need a real omp session — this console is running on demo data.', code: 'mock_mode' },
+      { status: 409 },
+    );
+  }
+  const body = asRecord(await request.json().catch(() => null));
+  const dependsOn = typeof body.dependsOn === 'string' ? body.dependsOn.trim() : '';
+  if (!dependsOn || !isSinglePathSegment(dependsOn)) {
+    return json({ error: 'A session to wait for is required', code: 'depends_on_required' }, { status: 400 });
+  }
+  const prompt = typeof body.prompt === 'string' ? body.prompt : '';
+  const attachments = Array.isArray(body.attachments) ? body.attachments : [];
+  // Same rule the composer's own send guard applies: an empty prompt is not a
+  // prompt. Without it a row would be created, spawn a session, and deliver
+  // nothing to it.
+  if (!prompt.trim() && !attachments.some((attachment) => attachmentHasPayload(attachment as never))) {
+    return json({ error: 'The prompt is empty', code: 'prompt_required' }, { status: 400 });
+  }
+  const cwd = typeof body.cwd === 'string' ? body.cwd.trim() : '';
+  // `isAbsolute`, not `startsWith('/')`: a Windows workspace names its directory
+  // `C:\…`, and the POSIX-only test refused every hold there with
+  // `cwd_required` — the prompt was sent immediately instead of being held
+  // (measured on the Windows CI leg of `waiting-prompt.e2e.ts`).
+  if (!isAbsolute(cwd)) {
+    return json({ error: 'An absolute working directory is required', code: 'cwd_required' }, { status: 400 });
+  }
+  if (await isDependencySettled(dependsOn)) {
+    return json(
+      { error: 'That session has already finished — send the prompt without waiting.', code: 'dependency_idle' },
+      { status: 409 },
+    );
+  }
+
+  const created = await createWaitingPrompt({
+    pendingId: typeof body.pendingId === 'string' ? body.pendingId : null,
+    dependsOn,
+    dependsOnTitle: typeof body.dependsOnTitle === 'string' ? body.dependsOnTitle : null,
+    prompt,
+    attachments,
+    model: body.model,
+    modes: body.modes === undefined ? null : parseModeSelection(asRecord(body.modes)),
+    cwd,
+    folderId: typeof body.folderId === 'number' ? body.folderId : null,
+  });
+  emitRealtimeSignal('waiting-changed');
+  return json({ prompt: created });
+}
+
+/** DELETE `?id=` — cancel a prompt that has not been dispatched yet. */
+async function cancelPrompt(request: Request) {
+  const id = new URL(request.url).searchParams.get('id') ?? '';
+  if (!id) return json({ error: 'id is required', code: 'id_required' }, { status: 400 });
+  const existing = await getWaitingPrompt(id);
+  if (!existing) return json({ error: 'Waiting prompt not found' }, { status: 404 });
+  if (existing.status === 'dispatched') {
+    // The prompt has already become a session: Stop that session instead. Saying
+    // so is the difference between "cancel did nothing" and a next step.
+    return json(
+      { error: 'That prompt has already been sent — stop its session instead.', code: 'already_dispatched' },
+      { status: 409 },
+    );
+  }
+  const cancelled = await cancelWaitingPrompt(id);
+  if (cancelled) emitRealtimeSignal('waiting-changed');
+  return json({ cancelled, prompt: await getWaitingPrompt(id) });
+}
+
+export async function action({ request }: ActionFunctionArgs) {
+  if (request.method === 'POST') return createPrompt(request);
+  if (request.method === 'DELETE') return cancelPrompt(request);
+  return methodNotAllowed({ request, params: {} });
+}

package/src/server/routes/waiting/routes.test.ts

@@ -0,0 +1,121 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * `/api/waiting` POST — the refusals that guard the row.
+ *
+ * The case worth pinning is the WORKING DIRECTORY, because it is the one that
+ * only fails on a platform the author does not run: the route tested
+ * `cwd.startsWith('/')`, so every hold from a Windows workspace (`C:\…`) was
+ * refused with `cwd_required` and the prompt was sent immediately instead of
+ * being deferred — measured on the Windows CI leg of
+ * `waiting-prompt.e2e.ts`, where the browser showed the toast and the row was
+ * never created. The fix is `path.isAbsolute`, which is what this asserts on
+ * both platform shapes rather than only the one this run happens to be on.
+ *
+ * Everything else here is the validation order a stale client can reach: a
+ * missing dependency, an empty prompt, a mock install.
+ */
+
+import { afterAll, beforeAll, describe, expect, test } from 'bun:test';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { isolateDb, releaseDb } from '@/test-support/isolated-db';
+import { action } from '@/server/routes/waiting/index';
+import { listWaitingPrompts } from '@/server/lib/waiting/store.server';
+
+const ROOT = path.join(os.tmpdir(), `kabmo-waiting-routes-${process.pid}`);
+
+function post(body: unknown): Request {
+  return new Request('http://localhost/api/waiting', {
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify(body),
+  });
+}
+
+async function call(body: unknown): Promise<{ status: number; body: Record<string, unknown> }> {
+  const res = (await action({ request: post(body), params: {} } as never)) as Response;
+  return { status: res.status, body: (await res.json()) as Record<string, unknown> };
+}
+
+beforeAll(async () => {
+  fs.mkdirSync(ROOT, { recursive: true });
+  isolateDb();
+});
+
+afterAll(async () => {
+  releaseDb();
+  fs.rmSync(ROOT, { recursive: true, force: true });
+});
+
+describe('/api/waiting — working directory', () => {
+  // The rule is the SERVER's own platform rule (`path.isAbsolute`), because a
+  // hold's cwd is a directory on the machine that will spawn the session — the
+  // client sends the folder's stored `project_path`, which the server resolved.
+  //
+  // This table is derived from `path.isAbsolute` rather than written out, so it
+  // is a real regression net on BOTH legs: on Windows it feeds `C:\…`, which
+  // the old `startsWith('/')` refused, and on POSIX it feeds `/…`. Hardcoding
+  // either spelling would assert the platform this run happens to be on.
+  //
+  // The dependency must look UNFINISHED for a create to reach the store, and a
+  // session id nothing has ever streamed is settled by definition — so these
+  // cases assert the CWD verdict, which is decided BEFORE that read.
+  const shapes = [
+    path.join(ROOT, 'projects', 'kabmo'),
+    '/home/dev/projects/kabmo',
+    'C:\\Users\\dev\\projects\\kabmo',
+    '\\\\server\\share\\kabmo',
+    'projects/kabmo',
+    'C:relative',
+    '',
+  ];
+
+  for (const cwd of shapes) {
+    const absolute = path.isAbsolute(cwd);
+    test(`${JSON.stringify(cwd)} is ${absolute ? 'accepted' : 'refused as relative'}`, async () => {
+      const res = await call({ dependsOn: 'sess-anything', prompt: 'held', cwd });
+      if (absolute) {
+        // `dependency_idle` is the next gate: the cwd passed.
+        expect(res.body.code).not.toBe('cwd_required');
+      } else {
+        expect(res.status).toBe(400);
+        expect(res.body.code).toBe('cwd_required');
+      }
+    });
+  }
+
+  test('a whitespace-only path is refused, never trimmed into a valid one', async () => {
+    const res = await call({ dependsOn: 'sess-anything', prompt: 'x', cwd: '   ' });
+    expect(res.status).toBe(400);
+    expect(res.body.code).toBe('cwd_required');
+  });
+});
+
+describe('/api/waiting — the rest of the validation order', () => {
+  test('a missing dependency is refused before the path is read', async () => {
+    const res = await call({ prompt: 'x', cwd: '/tmp/x' });
+    expect(res.status).toBe(400);
+    expect(res.body.code).toBe('depends_on_required');
+  });
+
+  test('a dependency that could name a path is refused', async () => {
+    const res = await call({ dependsOn: '../../etc', prompt: 'x', cwd: '/tmp/x' });
+    expect(res.body.code).toBe('depends_on_required');
+  });
+
+  test('an empty prompt with no attachment is refused', async () => {
+    const res = await call({ dependsOn: 'sess-anything', prompt: '  ', cwd: '/tmp/x' });
+    expect(res.status).toBe(400);
+    expect(res.body.code).toBe('prompt_required');
+  });
+
+  test('a refusal writes no row', async () => {
+    await call({ dependsOn: 'sess-anything', prompt: 'x', cwd: 'relative/path' });
+    expect(await listWaitingPrompts()).toHaveLength(0);
+  });
+});

package/src/shared/lib/chat/timeline/gutter.test.ts

@@ -0,0 +1,37 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * The transcript's frame inset.
+ *
+ * One rule, four call sites — so it is stated here and asserted, not repeated
+ * as a class string. The bug it prevents was measured on a phone: every framed
+ * block carried `mx-3` on top of the timeline's own `px-3`, putting cards at
+ * 24px while the composer's card sat at 12px. The transcript read as two
+ * columns that never met.
+ */
+
+import { describe, expect, test } from 'bun:test';
+import { transcriptBlockPadding, transcriptGutter } from '@/shared/lib/chat/timeline/gutter';
+
+describe('transcriptGutter', () => {
+  test('a phone adds no inset — the timeline container IS the gutter', () => {
+    expect(transcriptGutter(true)).toBe('');
+  });
+
+  test('desktop keeps the 12px inset that pairs with the panel p-4', () => {
+    expect(transcriptGutter(false)).toBe('mx-3');
+  });
+});
+
+describe('transcriptBlockPadding', () => {
+  test('a phone pads to the shared 24px text column (12 frame + 12 padding)', () => {
+    expect(transcriptBlockPadding(true)).toBe('p-3');
+  });
+
+  test('desktop keeps its roomier 14px padding', () => {
+    expect(transcriptBlockPadding(false)).toBe('p-3.5');
+  });
+});

package/src/shared/lib/chat/timeline/gutter.ts

@@ -0,0 +1,37 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * The horizontal frame inset of a transcript block — a tool card, a thinking
+ * accordion, a system notice, a user bubble.
+ *
+ * Desktop keeps `mx-3`: the timeline's own container is `p-4`, and the extra
+ * 12px is what gives a card the same optical margin as the prose beside it.
+ *
+ * A phone does NOT. Its timeline container is already `px-3`, and that is the
+ * same 12px the composer dock uses — so a block that added another `mx-3` put
+ * every card 12px inside the composer's own edge, and the transcript read as
+ * two columns that never met. On mobile the block's frame IS the gutter.
+ *
+ * Stated once, because the class was written out at four separate call sites
+ * and a missed one is a card sitting 12px off its neighbours.
+ */
+export function transcriptGutter(isMobile: boolean): string {
+  return isMobile ? '' : 'mx-3';
+}
+
+/**
+ * Padding INSIDE a framed transcript block (the user bubble, the provider
+ * error strip).
+ *
+ * The pair with `transcriptGutter` is what keeps a phone's text column on one
+ * line: 12px frame + 12px padding = 24, which is exactly where the prose rows
+ * (`px-3` inside the same container) and the composer's textarea already sit.
+ * Desktop keeps its roomier `p-3.5`, because there the frame is inset and the
+ * text column is not shared with an edge-to-edge composer.
+ */
+export function transcriptBlockPadding(isMobile: boolean): string {
+  return isMobile ? 'p-3' : 'p-3.5';
+}

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

@@ -101,6 +101,16 @@ export const TOPIC_USAGE = 'usage';
 /** Scheduled tasks. */
 export const TOPIC_SCHEDULE = 'schedule';
 
+/**
+ * Prompts held until another session finishes.
+ *
+ * A global topic rather than per-session: the row belongs to the session that
+ * has NOT been created yet, and the dependency it names is a different session
+ * again. Both the sidebar (to draw the waiting row) and the composer (to offer
+ * the dependencies) read it.
+ */
+export const TOPIC_WAITING = 'waiting';
+
 /** Installed panel plugins and their catalog. */
 export const TOPIC_PANELS = 'panels';
 

package/src/shared/lib/ui/titlebar.test.ts

@@ -0,0 +1,124 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * The PWA titlebar insets, evaluated against the two platform geometries.
+ *
+ * The bug this pins is arithmetic, so asserting the STRING would pass while the
+ * wrong edge was reserved. The expressions are therefore substituted with real
+ * env values and evaluated:
+ *
+ *   - macOS puts the window controls on the LEFT: `titlebar-area-x` is ~76px and
+ *     `titlebar-area-width` is the rest of the window. The right inset must be
+ *     the BASE padding — the old form `100vw - width` reserved 76px of dead
+ *     space between the last navbar control and the window's right edge.
+ *   - Windows/Linux put them on the RIGHT: `x` is 0, so both forms agree and the
+ *     right inset is the overlay's own width.
+ *   - A browser tab has neither: both env variables fall back, and the base
+ *     padding is all that is left.
+ */
+
+import { describe, expect, test } from 'bun:test';
+
+import {
+  TITLEBAR_OVERLAY_RIGHT,
+  titlebarPaddingLeft,
+  titlebarPaddingRight,
+} from '@/shared/lib/ui/titlebar';
+
+const REM = 16;
+const VIEWPORT = 1440;
+
+interface Geometry {
+  /** `titlebar-area-x`; absent means the browser tab's fallback. */
+  x?: number;
+  /** `titlebar-area-width`; absent means the fallback. */
+  width?: number;
+  safeLeft?: number;
+  safeRight?: number;
+}
+
+/**
+ * Evaluate one of the returned declarations.
+ *
+ * `env(name, fallback)` resolves to the geometry's value or its fallback, `vw`
+ * resolves to the viewport, and `max()`/`calc()` become their JS equivalents —
+ * which is exactly what a browser computes, minus unit conversion.
+ */
+function evaluate(expression: string, geometry: Geometry): number {
+  const values: Record<string, number | undefined> = {
+    'titlebar-area-x': geometry.x,
+    'titlebar-area-width': geometry.width,
+    'safe-area-inset-left': geometry.safeLeft,
+    'safe-area-inset-right': geometry.safeRight,
+  };
+  const substituted = expression
+    // `vw` first: the fallback inside an `env()` can itself be a viewport unit
+    // (`env(titlebar-area-width, 100vw)`), and resolving it afterwards would
+    // hand `parseLength` a unit it cannot read.
+    .replace(/([\d.]+)vw/g, (_match, value: string) => `${(Number(value) / 100) * VIEWPORT}px`)
+    .replace(
+      /env\(\s*([a-z-]+)\s*,\s*([^)]+)\)/g,
+      (_match, name: string, fallback: string) => `${values[name] ?? parseLength(fallback)}px`,
+    )
+    .replace(/max\(/g, 'Math.max(')
+    .replace(/calc\(/g, '(');
+  const js = substituted.replace(/([\d.]+)(px|rem)/g, (_match, value: string, unit: string) =>
+    unit === 'rem' ? String(Number(value) * REM) : value,
+  );
+  return Function(`return (${js})`)() as number;
+}
+
+function parseLength(value: string): number {
+  const match = /^([\d.]+)(px|rem)?$/.exec(value.trim());
+  if (!match) throw new Error(`Unsupported length: ${value}`);
+  return match[2] === 'rem' ? Number(match[1]) * REM : Number(match[1]);
+}
+
+/** macOS: traffic lights on the left, ~76px of them. */
+const MACOS: Geometry = { x: 76, width: VIEWPORT - 76 };
+/** Windows: controls and the app menu on the right, ~138px of them. */
+const WINDOWS: Geometry = { x: 0, width: VIEWPORT - 138 };
+/** A browser tab: no WCO at all, so both variables take their fallbacks. */
+const TAB: Geometry = {};
+
+describe('titlebar insets', () => {
+  test('the right inset is the space AFTER the title bar area, not before it', () => {
+    // The overlay sits between the area's far edge and the window's right edge.
+    expect(TITLEBAR_OVERLAY_RIGHT).toContain('env(titlebar-area-x');
+    expect(TITLEBAR_OVERLAY_RIGHT).toContain('env(titlebar-area-width');
+
+    // macOS: the traffic lights are on the LEFT, so nothing may be reserved on
+    // the right. This is the reported gap.
+    expect(evaluate(titlebarPaddingRight('1rem'), MACOS)).toBe(REM);
+    // Windows: the overlay is on the right, and its width is what clears it.
+    expect(evaluate(titlebarPaddingRight('1rem'), WINDOWS)).toBe(138);
+    // No WCO: the base padding, unchanged.
+    expect(evaluate(titlebarPaddingRight('1rem'), TAB)).toBe(REM);
+  });
+
+  test('the left inset is the title bar area origin', () => {
+    expect(evaluate(titlebarPaddingLeft('1rem'), MACOS)).toBe(76);
+    expect(evaluate(titlebarPaddingLeft('1rem'), WINDOWS)).toBe(REM);
+    expect(evaluate(titlebarPaddingLeft('1rem'), TAB)).toBe(REM);
+  });
+
+  test('the phone variants keep the notch insets', () => {
+    expect(evaluate(titlebarPaddingLeft('0.75rem', true), { ...MACOS, safeLeft: 44 })).toBe(76);
+    expect(evaluate(titlebarPaddingLeft('0.75rem', true), { x: 0, safeLeft: 44 })).toBe(44);
+    // A landscape phone's right notch clears the edge on its own, and the
+    // overlay's width is still honoured when it is the larger of the two.
+    expect(evaluate(titlebarPaddingRight('0.75rem', true), { x: 0, width: VIEWPORT - 138, safeRight: 44 })).toBe(138);
+    expect(evaluate(titlebarPaddingRight('0.75rem', true), { ...MACOS, safeRight: 44 })).toBe(44);
+  });
+
+  test('the old form is the bug, stated as a control', () => {
+    // `100vw - titlebar-area-width` on macOS: the traffic lights' 76px charged
+    // to the wrong edge, which is the strip the report showed.
+    const buggy = `max(1rem, calc(100vw - env(titlebar-area-width, 100vw)))`;
+    expect(evaluate(buggy, MACOS)).toBe(76);
+    expect(evaluate(buggy, WINDOWS)).toBe(138);
+  });
+});

package/src/shared/lib/ui/titlebar.ts

@@ -0,0 +1,54 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * The insets that keep a header's controls clear of the PWA window controls
+ * (Window Controls Overlay), stated ONCE because four headers draw them.
+ *
+ * The `titlebar-area-*` env variables describe the area the page may use: it
+ * runs from the frame edge to the innermost edge of the overlay that houses the
+ * window controls. Which SIDE that overlay is on is the platform's choice, and
+ * `titlebar-area-x` is the answer:
+ *
+ *   - macOS puts the traffic lights on the LEFT, so `x` is ~76px and
+ *     `titlebar-area-width` is `viewport - 76`;
+ *   - Windows and Linux put the controls (and Chrome's `⋮` app menu) on the
+ *     RIGHT, so `x` is `0` and `titlebar-area-width` is `viewport - overlay`.
+ *
+ * So the LEFT inset is `x`, and the RIGHT inset is whatever is left over after
+ * the area ENDS — `viewport - (x + width)` — never `viewport - width`. The
+ * second form is what the headers used to compute, and on macOS it reserved the
+ * traffic lights' width on the wrong edge: a 76px dead strip between the last
+ * navbar control and the window's right edge, with no control anywhere near it.
+ * On Windows the two forms agree, which is why the bug only showed on one
+ * platform.
+ *
+ * `safeArea` adds the iOS/Android notch insets, which the phone headers carry.
+ * A desktop PWA has them at 0, so one helper serves both.
+ */
+
+/**
+ * The width of the overlay that sits to the RIGHT of the title bar area.
+ *
+ * Both env variables are read with a fallback, so this is `0px` in a browser
+ * tab (where WCO is not active) and on macOS, and the platform's real control
+ * width on Windows/Linux.
+ */
+export const TITLEBAR_OVERLAY_RIGHT =
+  'calc(100vw - env(titlebar-area-x, 0px) - env(titlebar-area-width, 100vw))';
+
+/** `base`-sized padding that also clears the window controls on the left. */
+export function titlebarPaddingLeft(base: string, safeArea = false): string {
+  return safeArea
+    ? `max(${base}, env(safe-area-inset-left, 0px), env(titlebar-area-x, 0px))`
+    : `max(${base}, env(titlebar-area-x, 0px))`;
+}
+
+/** `base`-sized padding that also clears the window controls on the right. */
+export function titlebarPaddingRight(base: string, safeArea = false): string {
+  return safeArea
+    ? `max(${base}, env(safe-area-inset-right, 0px), ${TITLEBAR_OVERLAY_RIGHT})`
+    : `max(${base}, ${TITLEBAR_OVERLAY_RIGHT})`;
+}

package/src/shared/lib/workspace/left-dock-width.ts

@@ -0,0 +1,78 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * The LEFT dock's width, remembered PER VIEW.
+ *
+ * The left column used to hold one view, so one number was enough and it lives
+ * in `sidebar-width.ts` (`omp_sidebar_width`). The column is a dock now, and a
+ * plugin panel placed on it wants its own width: a session list reads at 280px
+ * and a table does not, and a column that snapped to the list's width the moment
+ * the user switched views would be a column with one width that is wrong for
+ * every second view.
+ *
+ * GLOBAL, like the sidebar's own width and the right panel's order — the dock
+ * lists the same views in every session, so a width stored per session would
+ * move the layout when the user picked a different chat.
+ *
+ * The sessions view keeps reading `sidebar-width.ts` as its fallback, so an
+ * install that has been dragging the sidebar for a year opens at the width it
+ * was left at rather than at this module's default.
+ */
+
+import { readKabmoSetting, writeSetting } from '@/shared/lib/settings/client';
+import { SESSIONS_VIEW_ID } from '@/shared/lib/workspace/left-dock';
+import {
+  DEFAULT_LEFT_PANEL_WIDTH,
+  MAX_LEFT_PANEL_WIDTH,
+  MIN_LEFT_PANEL_WIDTH,
+  resolveSidebarWidth,
+} from '@/shared/lib/workspace/sidebar-width';
+
+/** `app_settings` key holding the dock's per-view widths, in pixels. */
+export const LEFT_DOCK_WIDTHS_SETTING_KEY = 'omp_left_dock_widths';
+
+/**
+ * Floor for a view that is not the session list.
+ *
+ * A plugin panel declares its own floor (320, `MIN_PLUGIN_PANEL_WIDTH`), and a
+ * column narrower than that clips the view it is showing. The list reads fine
+ * lower, which is why the two differ.
+ */
+export const MIN_LEFT_DOCK_PLUGIN_WIDTH = 320;
+
+function clamped(viewId: string, px: number): number {
+  const floor = viewId === SESSIONS_VIEW_ID ? MIN_LEFT_PANEL_WIDTH : MIN_LEFT_DOCK_PLUGIN_WIDTH;
+  return Math.min(MAX_LEFT_PANEL_WIDTH, Math.max(floor, Math.round(px)));
+}
+
+function readMap(): Record<string, number> {
+  const stored = readKabmoSetting<unknown>(LEFT_DOCK_WIDTHS_SETTING_KEY);
+  if (typeof stored !== 'object' || stored === null) return {};
+  const out: Record<string, number> = {};
+  for (const [view, value] of Object.entries(stored as Record<string, unknown>)) {
+    if (typeof value === 'number' && Number.isFinite(value)) out[view] = value;
+  }
+  return out;
+}
+
+/**
+ * The width this view opens at.
+ *
+ * A remembered width wins; otherwise the session list falls back to the width
+ * `sidebar-width.ts` has always resolved (setting, then the retired global blob,
+ * then the session slot), and a plugin view opens at the dock's plugin default.
+ */
+export function resolveLeftDockWidth(viewId: string): number {
+  const stored = readMap()[viewId];
+  if (stored !== undefined) return clamped(viewId, stored);
+  if (viewId === SESSIONS_VIEW_ID) return resolveSidebarWidth();
+  return clamped(viewId, DEFAULT_LEFT_PANEL_WIDTH);
+}
+
+/** Persist a dragged width for one view. */
+export function saveLeftDockWidth(viewId: string, px: number): void {
+  writeSetting(LEFT_DOCK_WIDTHS_SETTING_KEY, { ...readMap(), [viewId]: clamped(viewId, px) });
+}