ompchamber 0.3.0

package/src/shared/lib/updates/semver.ts

@@ -0,0 +1,34 @@
+/**
+ * Tiny dependency-free semantic-version helpers for the update checker.
+ * Deliberately lenient: it compares numeric dotted segments only and ignores
+ * any pre-release suffix, which is all the GitHub/omp version strings need.
+ */
+
+/** Strip a leading `v`/`V` and surrounding whitespace. */
+export function normalizeVersion(v: string): string {
+  return v.trim().replace(/^[vV]/, '');
+}
+
+function toSegments(v: string): number[] {
+  const core = normalizeVersion(v).split('-')[0] ?? '';
+  return core.split('.').map((segment) => (/^\d+$/.test(segment) ? Number.parseInt(segment, 10) : 0));
+}
+
+/** Compare two versions: -1 when a < b, 0 when equal, 1 when a > b. */
+export function compareVersions(a: string, b: string): number {
+  const left = toSegments(a);
+  const right = toSegments(b);
+  const length = Math.max(left.length, right.length);
+  for (let i = 0; i < length; i += 1) {
+    const x = left[i] ?? 0;
+    const y = right[i] ?? 0;
+    if (x > y) return 1;
+    if (x < y) return -1;
+  }
+  return 0;
+}
+
+/** True when `latest` is strictly newer than `current`. */
+export function isNewer(latest: string, current: string): boolean {
+  return compareVersions(latest, current) > 0;
+}

package/src/shared/lib/util/guards.ts

@@ -0,0 +1,14 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Dependency-free runtime guards shared by client and server. Kept free of any
+ * `node:`/`bun:` import so both bundles can consume it.
+ */
+
+/** Narrows an unknown value to a plain object (never arrays or null). */
+export function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}

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

@@ -0,0 +1,42 @@
+import type { WorkspaceFolderData } from '@/shared/types';
+
+export interface ActiveProjectScope {
+  folder: WorkspaceFolderData | null;
+  /** Registered project root of the selected session's workspace, or null. */
+  projectPath: string | null;
+}
+
+/**
+ * Resolve the workspace folder that owns the currently selected session and,
+ * when that folder is bound to an oh-my-pi project (project_path), the project
+ * root the right-panel developer tools should be scoped to.
+ */
+export function activeProjectForSession(
+  folders: WorkspaceFolderData[],
+  sessionId: string | number | null | undefined
+): ActiveProjectScope {
+  if (!sessionId) return { folder: null, projectPath: null };
+  for (const folder of folders) {
+    const ownsSession = (folder.sessions || []).some((s) => String(s.id) === String(sessionId));
+    if (ownsSession) return { folder, projectPath: folder.project_path ?? null };
+  }
+  return { folder: null, projectPath: null };
+}
+
+/**
+ * Resolve the workspace root the composer should scope `@` file mentions to:
+ * the active session's bound project first, then the explicitly selected
+ * folder, else null (client falls back to the app root).
+ */
+export function composerRootFor(
+  folders: WorkspaceFolderData[],
+  sessionId: string | number | null | undefined,
+  selectedFolderId: number | null
+): string | null {
+  const bySession = activeProjectForSession(folders, sessionId).folder;
+  const byFolder =
+    selectedFolderId != null
+      ? folders.find((f) => String(f.id) === String(selectedFolderId)) ?? null
+      : null;
+  return (bySession ?? byFolder)?.project_path ?? null;
+}

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

@@ -0,0 +1,72 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, expect, test } from 'bun:test';
+
+import { mergePanelWidths, normalizePanelWidths } from '@/shared/lib/workspace/panel-widths';
+
+describe('normalizePanelWidths', () => {
+  test('keeps every panel slot from a current blob', () => {
+    const raw = {
+      left: 342,
+      chat: 700,
+      editor: 620,
+      diff: 900,
+      right: { files: 300, browser: 804 },
+    };
+
+    expect(normalizePanelWidths(raw, 'files')).toEqual(raw);
+  });
+
+  test('adopts a legacy shared right width into the view that was open', () => {
+    const widths = normalizePanelWidths({ left: 342, editor: 620, right: 1091 }, 'browser');
+
+    expect(widths.right).toEqual({ browser: 1091 });
+    expect(widths.left).toBe(342);
+    expect(widths.editor).toBe(620);
+  });
+
+  test('drops unusable entries instead of trusting the blob', () => {
+    const widths = normalizePanelWidths(
+      { left: -10, chat: '700', editor: 620.4, diff: null, right: { files: 0, bogus: 300, git: 260 } },
+      'files',
+    );
+
+    expect(widths).toEqual({ editor: 620, right: { git: 260 } });
+  });
+
+  test('tolerates a missing or malformed blob', () => {
+    expect(normalizePanelWidths(undefined, 'files')).toEqual({});
+    expect(normalizePanelWidths('nonsense', 'files')).toEqual({});
+  });
+});
+
+describe('mergePanelWidths', () => {
+  test('merging one view keeps every other remembered width', () => {
+    const stored = {
+      left: 342,
+      chat: 700,
+      editor: 620,
+      diff: 900,
+      right: { files: 300, git: 260 },
+    };
+
+    const merged = mergePanelWidths(stored, { right: { browser: 804 } });
+
+    expect(merged.right).toEqual({ files: 300, git: 260, browser: 804 });
+    expect(merged.left).toBe(342);
+    expect(merged.editor).toBe(620);
+    expect(merged.diff).toBe(900);
+  });
+
+  test('a resized panel replaces only its own slot', () => {
+    const merged = mergePanelWidths(
+      { chat: 700, editor: 620, diff: 900, right: { files: 300 } },
+      { editor: 480 },
+    );
+
+    expect(merged).toEqual({ chat: 700, editor: 480, diff: 900, right: { files: 300 } });
+  });
+});

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

@@ -0,0 +1,79 @@
+/**
+ * Per-panel width state for the desktop layout.
+ *
+ * Every resizable surface remembers its OWN width: the session sidebar, the
+ * chat column, the editor panel (source and diff tabs separately, since a diff
+ * wants room a file view does not) and each right-panel view. Collapsing those
+ * into one slot per group is what made switching a panel look like a reset.
+ *
+ * Sizes are pixels — the unit the panel constraints are written in — and are
+ * persisted as `app_settings.desktopLayoutSizes`.
+ */
+import { isRightPanelType, type RightPanelType } from '@/shared/lib/workspace/right-panels';
+
+/** The editor panel keeps a separate width while a diff tab is active. */
+export type EditorWidthMode = 'editor' | 'diff';
+
+export interface PanelWidths {
+  /** Session sidebar. */
+  left?: number;
+  /** Chat timeline column, the inner stack's first panel. */
+  chat?: number;
+  /** Editor panel while a source file tab is active. */
+  editor?: number;
+  /** Editor panel while a diff tab is active. */
+  diff?: number;
+  /** Right panel, keyed by the activity-bar view it currently shows. */
+  right?: Partial<Record<RightPanelType, number>>;
+}
+
+/** Fallbacks for panels that have never been resized. */
+export const DEFAULT_PANEL_WIDTHS: Record<EditorWidthMode | 'left' | 'chat', number> = {
+  left: 268,
+  chat: 540,
+  editor: 536,
+  diff: 536,
+};
+
+function pixelWidth(value: unknown): number | undefined {
+  return typeof value === 'number' && Number.isFinite(value) && value > 0 ? Math.round(value) : undefined;
+}
+
+/**
+ * Coerce a stored blob into the current shape. Blobs written before per-view
+ * widths held the right panel as a single number shared by every view; that
+ * number belongs to whichever view was open when it was written, so it seeds
+ * `legacyView` alone instead of being copied onto all eight.
+ */
+export function normalizePanelWidths(raw: unknown, legacyView: RightPanelType): PanelWidths {
+  if (!raw || typeof raw !== 'object') return {};
+  const source = raw as Record<string, unknown>;
+
+  const widths: PanelWidths = {};
+  for (const key of ['left', 'chat', 'editor', 'diff'] as const) {
+    const value = pixelWidth(source[key]);
+    if (value !== undefined) widths[key] = value;
+  }
+
+  const right: Partial<Record<RightPanelType, number>> = {};
+  if (source.right && typeof source.right === 'object') {
+    for (const [view, value] of Object.entries(source.right as Record<string, unknown>)) {
+      if (!isRightPanelType(view)) continue;
+      const size = pixelWidth(value);
+      if (size !== undefined) right[view] = size;
+    }
+  } else {
+    const legacy = pixelWidth(source.right);
+    if (legacy !== undefined) right[legacyView] = legacy;
+  }
+  if (Object.keys(right).length > 0) widths.right = right;
+
+  return widths;
+}
+
+/** Fold a freshly measured patch over the stored widths (one level deep for `right`). */
+export function mergePanelWidths(current: PanelWidths, patch: PanelWidths): PanelWidths {
+  const next: PanelWidths = { ...current, ...patch };
+  if (patch.right) next.right = { ...current.right, ...patch.right };
+  return next;
+}

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

@@ -0,0 +1,29 @@
+import { BookOpen, Briefcase, Camera, Code2, Database, FlaskConical, Folder, Gamepad2, Globe, Heart, Home, Leaf, Lightbulb, Music, Palette, Rocket, Server, Shield, Smartphone, Terminal } from 'lucide-preact';
+import type { LucideIcon } from 'lucide-preact';
+
+const PROJECT_ICON_MAP: Record<string, LucideIcon> = {
+  default: Folder,
+  code: Code2,
+  terminal: Terminal,
+  rocket: Rocket,
+  flask: FlaskConical,
+  gamepad: Gamepad2,
+  briefcase: Briefcase,
+  home: Home,
+  globe: Globe,
+  leaf: Leaf,
+  shield: Shield,
+  palette: Palette,
+  server: Server,
+  smartphone: Smartphone,
+  database: Database,
+  lightbulb: Lightbulb,
+  music: Music,
+  camera: Camera,
+  book: BookOpen,
+  heart: Heart,
+};
+
+export function getProjectIcon(icon: string | undefined): LucideIcon {
+  return PROJECT_ICON_MAP[icon || 'default'] || Folder;
+}

package/src/shared/lib/workspace/project-settings-migration.ts

@@ -0,0 +1,62 @@
+import type { DbClient } from '@/server/lib/db/client';
+import { DEFAULT_PROJECTS_LIST } from '@/client/data/settings/project';
+
+const MIGRATION_KEY = 'omp_projects_config_migrated';
+
+interface LegacyProject {
+  name?: unknown;
+  path?: unknown;
+  model?: unknown;
+  accentColor?: unknown;
+  icon?: unknown;
+  customIconUrl?: unknown;
+}
+
+function isLegacyProject(value: unknown): value is LegacyProject {
+  return typeof value === 'object' && value !== null;
+}
+
+export async function migrateLegacyProjectSettings(db: DbClient): Promise<void> {
+  const marker = await db.get('SELECT value FROM app_settings WHERE key = ?', [MIGRATION_KEY]);
+  if (marker?.value === '1') return;
+
+  const legacyRow = await db.get('SELECT value FROM app_settings WHERE key = ?', ['omp_projects_config']);
+  if (!legacyRow?.value) return;
+
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(legacyRow.value);
+  } catch (error) {
+    return;
+  }
+
+  const legacyProjects = Array.isArray(parsed)
+    ? parsed.filter(isLegacyProject)
+    : DEFAULT_PROJECTS_LIST;
+  const folders = await db.all('SELECT id, name, project_path FROM workspace_folders');
+
+  for (const project of legacyProjects) {
+    const name = typeof project.name === 'string' ? project.name : '';
+    const path = typeof project.path === 'string' ? project.path : '';
+    const folder = folders.find((candidate) =>
+      (path && candidate.project_path === path) ||
+      (name && candidate.name.toLowerCase() === name.toLowerCase()),
+    );
+    if (!folder) continue;
+
+    await db.run(
+      `UPDATE workspace_folders
+       SET model = ?, accent_color = ?, icon = ?, custom_icon_url = ?
+       WHERE id = ?`,
+      [
+        typeof project.model === 'string' ? project.model : 'Not selected',
+        typeof project.accentColor === 'string' ? project.accentColor : '',
+        typeof project.icon === 'string' ? project.icon : 'default',
+        typeof project.customIconUrl === 'string' ? project.customIconUrl : null,
+        folder.id,
+      ],
+    );
+  }
+
+  await db.run('INSERT OR REPLACE INTO app_settings (key, value) VALUES (?, ?)', [MIGRATION_KEY, '1']);
+}

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

@@ -0,0 +1,139 @@
+import type { DbClient } from '@/server/lib/db/client';
+import type { ProjectConfigItem } from '@/shared/types';
+import { isRecord } from '@/shared/lib/util/guards';
+
+export interface WorkspaceFolderRow {
+  id: number;
+  name: string;
+  project_path?: string | null;
+  model?: string | null;
+  accent_color?: string | null;
+  icon?: string | null;
+  custom_icon_url?: string | null;
+  is_pinned?: number | null;
+  is_expanded?: number | null;
+}
+
+export interface FolderSettingsPatch {
+  name?: string;
+  projectPath?: string | null;
+  model?: string;
+  accentColor?: string;
+  icon?: string;
+  customIconUrl?: string | null;
+  isPinned?: boolean;
+  isExpanded?: boolean;
+}
+
+export function projectConfigFromFolder(folder: WorkspaceFolderRow): ProjectConfigItem {
+  return {
+    id: `folder-${folder.id}`,
+    folderId: folder.id,
+    name: folder.name,
+    path: folder.project_path ?? '',
+    model: folder.model || 'Not selected',
+    accentColor: folder.accent_color || '',
+    icon: folder.icon || 'default',
+    customIconUrl: folder.custom_icon_url || undefined,
+    isPinned: folder.is_pinned === 1,
+    isExpanded: folder.is_expanded === 1,
+  };
+}
+
+function readBoolean(value: unknown): boolean | undefined {
+  if (typeof value === 'boolean') return value;
+  if (value === 'true') return true;
+  if (value === 'false') return false;
+  return undefined;
+}
+
+export function parseFolderSettingsPatch(value: unknown): FolderSettingsPatch {
+  if (!isRecord(value)) return {};
+
+  const patch: FolderSettingsPatch = {};
+  if (typeof value.name === 'string') patch.name = value.name.trim();
+  if (typeof value.projectPath === 'string') patch.projectPath = value.projectPath.trim() || null;
+  if (typeof value.model === 'string') patch.model = value.model;
+  if (typeof value.accentColor === 'string') patch.accentColor = value.accentColor;
+  if (typeof value.icon === 'string') patch.icon = value.icon;
+  if (typeof value.customIconUrl === 'string') patch.customIconUrl = value.customIconUrl;
+  if (value.customIconUrl === null) patch.customIconUrl = null;
+
+  const isPinned = readBoolean(value.isPinned);
+  if (isPinned !== undefined) patch.isPinned = isPinned;
+  const isExpanded = readBoolean(value.isExpanded);
+  if (isExpanded !== undefined) patch.isExpanded = isExpanded;
+
+  return patch;
+}
+
+export async function updateWorkspaceFolder(
+  db: DbClient,
+  folderId: string,
+  patch: FolderSettingsPatch,
+): Promise<boolean> {
+  const assignments: string[] = [];
+  const values: Array<string | number | null> = [];
+
+  if (patch.name !== undefined && patch.name !== '') {
+    assignments.push('name = ?');
+    values.push(patch.name);
+  }
+  if (patch.projectPath !== undefined) {
+    assignments.push('project_path = ?');
+    values.push(patch.projectPath);
+  }
+  if (patch.model !== undefined) {
+    assignments.push('model = ?');
+    values.push(patch.model);
+  }
+  if (patch.accentColor !== undefined) {
+    assignments.push('accent_color = ?');
+    values.push(patch.accentColor);
+  }
+  if (patch.icon !== undefined) {
+    assignments.push('icon = ?');
+    values.push(patch.icon);
+  }
+  if (patch.customIconUrl !== undefined) {
+    assignments.push('custom_icon_url = ?');
+    values.push(patch.customIconUrl);
+  }
+  if (patch.isPinned !== undefined) {
+    assignments.push('is_pinned = ?');
+    values.push(patch.isPinned ? 1 : 0);
+  }
+  if (patch.isExpanded !== undefined) {
+    assignments.push('is_expanded = ?');
+    values.push(patch.isExpanded ? 1 : 0);
+  }
+
+  if (assignments.length === 0) return false;
+
+  values.push(folderId);
+  const result = await db.run(
+    `UPDATE workspace_folders SET ${assignments.join(', ')} WHERE id = ?`,
+    values,
+  );
+  return Boolean(result.changes);
+}
+
+export async function deleteWorkspaceFolder(db: DbClient, folderId: string): Promise<boolean> {
+  const folder = await db.get('SELECT id, project_path FROM workspace_folders WHERE id = ?', [folderId]);
+  if (!folder) return false;
+
+  if (folder.project_path) {
+    await db.run(
+      'INSERT OR REPLACE INTO deleted_workspaces (project_path) VALUES (?)',
+      [folder.project_path],
+    );
+  }
+
+  const sessionRows = await db.all('SELECT id FROM sessions WHERE folder_id = ?', [folderId]);
+  for (const session of sessionRows) {
+    await db.run('DELETE FROM files WHERE session_id = ?', [session.id]);
+  }
+  await db.run('DELETE FROM sessions WHERE folder_id = ?', [folderId]);
+  await db.run('DELETE FROM workspace_folders WHERE id = ?', [folderId]);
+  return true;
+}

package/src/shared/lib/workspace/refresh-cadence.ts

@@ -0,0 +1,128 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Single source of truth for every refresh/poll cadence in the chamber.
+ *
+ * These values used to live next to their hooks (sidebar idle, stream poll,
+ * revalidation throttle, panel poll, git status, repo discovery, CDP poll,
+ * server-side dataset TTL, spawn retry backoff). Scattering them made tuning a
+ * cross-file hunt and let related numbers drift apart — the sidebar's 5s poll
+ * sitting exactly on the server's 5s TTL was the clearest case: a poll landing
+ * on the TTL boundary is a coin flip between a cache hit and a full disk scan.
+ *
+ * Keep every cadence here so the cost/freshness trade-off can be reasoned
+ * about in one place. Imported by client hooks, shared browser modules, and
+ * server routes alike — this module must stay free of `node:`/`Bun.*` imports.
+ */
+
+/**
+ * Sidebar idle keep-alive. The event paths (`omp:session-updated`) and the
+ * stream poll only fire while THIS client is active, so changes made elsewhere
+ * — a second tab, a background omp process finishing, an archive from another
+ * browser — would never surface. A slow poll closes that gap.
+ *
+ * 30s: the payload costs a per-session filesystem probe server-side
+ * (`sessionHasSubagents`), and idle means the user is not running anything
+ * here, so a half-minute of staleness is imperceptible.
+ */
+export const SIDEBAR_IDLE_REFRESH_MS = 30_000;
+
+/**
+ * Sidebar poll while some session is streaming. This is the belt to the
+ * `omp:session-updated` suspenders: when a background run finishes while the
+ * user sits on another session, no event is dispatched on this client, so only
+ * a timer can notice.
+ *
+ * 8s: the thing being waited for is a one-shot "done" badge, where a few
+ * seconds of latency is invisible — 5s was buying nothing.
+ */
+export const SIDEBAR_STREAM_POLL_MS = 8_000;
+
+/**
+ * Coalescing window for sidebar revalidation, applied as a LEADING + TRAILING
+ * throttle: the first event revalidates immediately, further events inside the
+ * window collapse into one trailing call.
+ *
+ * Leading-edge matters: `omp:session-updated` arrives in bursts (spawn, JSONL
+ * write, agent end), and a pure trailing debounce starves under a sustained
+ * burst — a 500ms retry loop would reset the timer forever and the sidebar
+ * would never refresh. Capping at one fetch per second keeps a busy run cheap
+ * without the starvation.
+ */
+export const SIDEBAR_REVALIDATE_THROTTLE_MS = 1_000;
+
+/**
+ * Right-panel poll cadence (context, usage, files, git). Panels mount only
+ * while active and each already has an event-driven companion
+ * (`useFileMutationRefresh`) for agent edits, so this poll only covers
+ * out-of-band changes — 5s is plenty. The git panel is the expensive one: each
+ * tick spawns git status, and at 2s that was the heaviest poll in the app.
+ */
+export const PANEL_REFRESH_MS = 5_000;
+
+/**
+ * Coalescing window after a file-mutating tool completes. Event-driven, not a
+ * poll — a burst of quick edits should collapse into one re-read.
+ */
+export const FILE_MUTATION_THROTTLE_MS = 500;
+
+/**
+ * Git-status poll behind the activity-bar / mobile "uncommitted changes"
+ * indicator. Already visibility- and focus-gated, and now also refreshed by
+ * the `omp:session-updated` / `omp:workspace-updated` events.
+ */
+export const GIT_STATUS_POLL_MS = 15_000;
+
+/**
+ * Coalescing window for the event-driven git-status re-read. A single agent run
+ * emits `omp:session-updated` more than once (run start, settled JSONL read,
+ * run end) and every `useGitStatus` instance listens, so an uncoalesced trigger
+ * would spawn several `git status` processes per run — the exact cost the poll
+ * cadence was raised to avoid. Trailing-only on purpose: the tree only settles
+ * after the run's writes land, so there is nothing worth reading on the leading
+ * edge.
+ */
+export const GIT_STATUS_EVENT_THROTTLE_MS = 1_000;
+
+/**
+ * Nested-repo discovery poll (`?reposOnly=1`). Short-lived: it stops as soon
+ * as discovery settles, so a tight cadence only costs a few requests.
+ */
+export const REPO_DISCOVERY_POLL_MS = 1_500;
+
+/**
+ * CDP state/screencast poll. Latency-sensitive — the browser panel streams a
+ * live page, so this one stays tight on purpose.
+ */
+export const BROWSER_POLL_MS = 1_000;
+
+/**
+ * Keep-alive comment frame for long-lived SSE/WS transports (agent bridge and
+ * browser stream). Not a data refresh — it keeps proxies from reaping an idle
+ * connection.
+ */
+export const STREAM_HEARTBEAT_MS = 30_000;
+
+/**
+ * TTL for the server-side sidebar dataset scan (`loadOmpSidebarData`). Kept
+ * just UNDER the fastest sidebar poll (8s) so a poll deterministically misses
+ * and triggers exactly one scan instead of racing the boundary.
+ */
+export const SIDEBAR_DATA_TTL_MS = 4_000;
+
+/**
+ * Retry backoff (ms) used while waiting for a freshly spawned omp session's
+ * JSONL to carry the user turn. Each entry is the delay BEFORE the next
+ * attempt; attempt 1 runs immediately, so the total attempt count is
+ * `length + 1` and the elapsed budget is the sum (~15.5s over 13 attempts).
+ *
+ * Front-loaded on purpose: omp usually writes the turn within a second, so the
+ * early 250ms probes land the real title fast, while the 2s tail keeps watching
+ * a slow spawn without spending 40 requests to do it.
+ */
+export const SESSION_META_RETRY_SCHEDULE_MS: readonly number[] = [
+  250, 250, 500, 500, 1_000, 1_000, 2_000, 2_000, 2_000, 2_000, 2_000, 2_000,
+];

package/src/shared/lib/workspace/relative-time.ts

@@ -0,0 +1,25 @@
+/** Compact relative age for sidebar rows: `now`, `5m`, `3h`, `2d`, `6w`, or a
+ *  `DD MMM` date once the timestamp is older than a year. Returns null for a
+ *  missing/unparseable timestamp so callers can omit the column entirely. */
+export function relativeTimeAgo(value: string | number | null | undefined, now: number = Date.now()): string | null {
+  if (value === null || value === undefined || value === '') return null;
+  const ms = typeof value === 'number' ? value : Date.parse(value);
+  if (Number.isNaN(ms)) return null;
+
+  const seconds = Math.round((now - ms) / 1000);
+  if (seconds < 45) return 'now';
+  const minutes = Math.round(seconds / 60);
+  if (minutes < 60) return `${minutes}m`;
+  const hours = Math.round(minutes / 60);
+  if (hours < 24) return `${hours}h`;
+  const days = Math.round(hours / 24);
+  if (days < 7) return `${days}d`;
+  const weeks = Math.round(days / 7);
+  if (weeks < 5) return `${weeks}w`;
+
+  const date = new Date(ms);
+  const sameYear = date.getFullYear() === new Date(now).getFullYear();
+  const day = date.getDate();
+  const month = date.toLocaleString('en-US', { month: 'short' });
+  return sameYear ? `${day} ${month}` : `${day} ${month} ${date.getFullYear()}`;
+}

package/src/shared/lib/workspace/right-panels.ts

@@ -0,0 +1,51 @@
+/**
+ * Right developer panel catalog: the activity-bar views, the width each one
+ * opens at, and the floor at which its content starts to clip.
+ *
+ * The list lives here rather than in the activity bar component so the layout
+ * can key one remembered width per view (`panel-widths.ts`) and validate a
+ * stored blob without importing UI.
+ */
+export const RIGHT_PANEL_TYPES = [
+  'files',
+  'search',
+  'git',
+  'terminal',
+  'context',
+  'user-browser',
+  'browser',
+  'usage',
+] as const;
+
+export type RightPanelType = (typeof RIGHT_PANEL_TYPES)[number];
+
+/** Width (px) a view opens at the first time it is shown. */
+export const DEFAULT_RIGHT_PANEL_WIDTHS: Record<RightPanelType, number> = {
+  files: 268,
+  search: 268,
+  git: 268,
+  terminal: 536,
+  context: 536,
+  'user-browser': 804,
+  browser: 804,
+  usage: 536,
+};
+
+/** Minimum width (px) each view needs before its toolbar or list breaks. */
+export const MIN_RIGHT_PANEL_WIDTHS: Record<RightPanelType, number> = {
+  files: 200,
+  search: 200,
+  git: 260,
+  terminal: 200,
+  context: 420,
+  'user-browser': 320,
+  browser: 320,
+  usage: 420,
+};
+
+export const MAX_RIGHT_PANEL_WIDTH = 1200;
+
+/** Guards a persisted or URL-provided view id before it keys a width. */
+export function isRightPanelType(value: unknown): value is RightPanelType {
+  return typeof value === 'string' && (RIGHT_PANEL_TYPES as readonly string[]).includes(value);
+}