@yancyyu/openhermit 1.5.8

package/src/renderer/utils/openCodeRuntimeDeliveryDiagnostics.ts

@@ -0,0 +1,79 @@
+import type { SendMessageResult } from '@shared/types';
+
+export interface OpenCodeRuntimeDeliveryDebugDetails {
+  messageId: string;
+  providerId: string;
+  delivered: boolean | null;
+  responsePending: boolean | null;
+  responseState: string | null;
+  ledgerStatus: string | null;
+  acceptanceUnknown: boolean | null;
+  reason: string | null;
+  diagnostics: string[];
+}
+
+interface OpenCodeRuntimeDeliveryDiagnostics {
+  warning: string | null;
+  debugDetails: OpenCodeRuntimeDeliveryDebugDetails | null;
+}
+
+const PENDING_WARNING =
+  'OpenCode runtime delivery is still being checked. Message was saved and will be retried if needed.';
+const FAILED_WARNING =
+  'OpenCode runtime delivery failed. Message was saved to inbox, but live delivery did not complete.';
+
+export function buildOpenCodeRuntimeDeliveryDiagnostics(
+  result: SendMessageResult
+): OpenCodeRuntimeDeliveryDiagnostics {
+  const runtimeDelivery = result.runtimeDelivery;
+  if (runtimeDelivery?.attempted !== true) {
+    return { warning: null, debugDetails: null };
+  }
+
+  const isFailed = runtimeDelivery.delivered === false;
+  const isPending = runtimeDelivery.responsePending === true;
+  if (!isFailed && !isPending) {
+    return { warning: null, debugDetails: null };
+  }
+
+  return {
+    warning: isFailed ? FAILED_WARNING : PENDING_WARNING,
+    debugDetails: {
+      messageId: result.messageId,
+      providerId: runtimeDelivery.providerId,
+      delivered: typeof runtimeDelivery.delivered === 'boolean' ? runtimeDelivery.delivered : null,
+      responsePending:
+        typeof runtimeDelivery.responsePending === 'boolean'
+          ? runtimeDelivery.responsePending
+          : null,
+      responseState: runtimeDelivery.responseState ?? null,
+      ledgerStatus: runtimeDelivery.ledgerStatus ?? null,
+      acceptanceUnknown:
+        typeof runtimeDelivery.acceptanceUnknown === 'boolean'
+          ? runtimeDelivery.acceptanceUnknown
+          : null,
+      reason: runtimeDelivery.reason ?? null,
+      diagnostics: runtimeDelivery.diagnostics ?? [],
+    },
+  };
+}
+
+export function formatOpenCodeRuntimeDeliveryDebugDetails(
+  details: OpenCodeRuntimeDeliveryDebugDetails
+): string {
+  return JSON.stringify(
+    {
+      messageId: details.messageId,
+      providerId: details.providerId,
+      delivered: details.delivered,
+      responsePending: details.responsePending,
+      responseState: details.responseState,
+      ledgerStatus: details.ledgerStatus,
+      acceptanceUnknown: details.acceptanceUnknown,
+      reason: details.reason,
+      diagnostics: details.diagnostics,
+    },
+    null,
+    2
+  );
+}

package/src/renderer/utils/pathDisplay.ts

@@ -0,0 +1,149 @@
+/**
+ * Path display utilities for shortening file paths in tight UI spaces.
+ *
+ * Strategy:
+ * 1. Strip project root to make relative
+ * 2. Replace home directory with ~
+ * 3. Middle-truncate if still too long, preserving first and last segments
+ *
+ * Also provides resolveAbsolutePath() for clipboard copy (~ → real home, relative → absolute).
+ */
+
+import { splitPath } from '@shared/utils/platformPath';
+
+function isWindowsAbsolutePath(input: string): boolean {
+  return /^[A-Za-z]:[/\\]/.test(input) || input.startsWith('\\\\') || input.startsWith('//');
+}
+
+function pathSeparatorFor(root: string): '/' | '\\' {
+  return root.includes('\\') && !root.includes('/') ? '\\' : '/';
+}
+
+function joinDisplayPath(root: string, child: string): string {
+  const sep = pathSeparatorFor(root);
+  return root.replace(/[/\\]$/, '') + sep + child.replace(/[/\\]/g, sep);
+}
+
+/**
+ * Shorten a file path for display in compact UI elements.
+ * Full path should still be available via tooltip (title attribute).
+ *
+ * Examples:
+ * - `/Users/name/.claude/projects/-Users-name-project/memory/MEMORY.md` → `~/.claude/…/memory/MEMORY.md`
+ * - `/Users/name/project/.claude/rules/tailwind.md` (with projectRoot) → `.claude/rules/tailwind.md`
+ * - `~/.claude/CLAUDE.md` → `~/.claude/CLAUDE.md` (already short)
+ */
+export function shortenDisplayPath(fullPath: string, projectRoot?: string, maxLength = 40): string {
+  let p = fullPath;
+
+  // 1. Make relative to project root
+  if (projectRoot) {
+    const root = projectRoot.replace(/[/\\]$/, '');
+    const caseInsensitive = isWindowsAbsolutePath(p) || isWindowsAbsolutePath(root);
+    const pathForCompare = caseInsensitive ? p.toLowerCase() : p;
+    const rootForCompare = caseInsensitive ? root.toLowerCase() : root;
+    if (
+      pathForCompare.startsWith(rootForCompare + '/') ||
+      pathForCompare.startsWith(rootForCompare + '\\')
+    ) {
+      p = p.slice(root.length + 1);
+    }
+  }
+
+  // 2. Replace home directory with ~
+  p = p
+    .replace(/^\/Users\/[^/]+/, '~')
+    .replace(/^\/home\/[^/]+/, '~')
+    .replace(/^[A-Z]:\\Users\\[^\\]+/i, '~');
+
+  // 3. If short enough, return as-is
+  if (p.length <= maxLength) return p;
+
+  // 4. Middle-truncate: keep first meaningful segments + … + last 2 segments
+  const sep = p.includes('\\') ? '\\' : '/';
+  const segments = p.split(sep);
+
+  // Determine where content starts (skip leading empty segment from absolute paths or ~)
+  let startIdx = 0;
+  if (segments[0] === '' || segments[0] === '~') startIdx = 1;
+
+  // Need at least 4 content segments to truncate the middle
+  if (segments.length - startIdx <= 3) return p;
+
+  const head = segments.slice(0, startIdx + 1).join(sep);
+  const tail = segments.slice(-2).join(sep);
+
+  return `${head}${sep}\u2026${sep}${tail}`;
+}
+
+/**
+ * Infer the user's home directory from a known absolute project path.
+ * Works for macOS (/Users/x), Linux (/home/x), and Windows (C:\Users\x).
+ */
+function inferHomeDir(projectRoot: string): string | null {
+  const match =
+    /^(\/Users\/[^/]+)/.exec(projectRoot) ??
+    /^(\/home\/[^/]+)/.exec(projectRoot) ??
+    /^([A-Z]:\\Users\\[^\\]+)/i.exec(projectRoot);
+  return match?.[1] ?? null;
+}
+
+/**
+ * Resolve a possibly-shortened path to its full absolute form for clipboard copy.
+ *
+ * - `~/...` → `/Users/username/...` (home dir inferred from projectRoot)
+ * - `src/foo/bar` → `{projectRoot}/src/foo/bar`
+ * - Already absolute → returned as-is
+ */
+/**
+ * Truncate a project path to ~/relative/path format.
+ * Works for macOS (/Users/...), Linux (/home/...) and Windows (C:\Users\...).
+ */
+export function formatProjectPath(path: string): string {
+  const p = path.replace(/\\/g, '/');
+
+  if (p.startsWith('/Users/') || p.startsWith('/home/')) {
+    const parts = splitPath(p);
+    if (parts.length >= 2) {
+      const rest = parts.slice(2).join('/');
+      return rest ? `~/${rest}` : '~';
+    }
+  }
+
+  if (isWindowsUserPath(path)) {
+    const parts = splitPath(p);
+    if (parts.length >= 3) {
+      const rest = parts.slice(3).join('/');
+      return rest ? `~/${rest}` : '~';
+    }
+  }
+
+  return p;
+}
+
+function isWindowsUserPath(input: string): boolean {
+  if (input.length < 10) return false;
+  const drive = input.charCodeAt(0);
+  const hasDriveLetter =
+    ((drive >= 65 && drive <= 90) || (drive >= 97 && drive <= 122)) && input[1] === ':';
+  return hasDriveLetter && input.slice(2, 9).toLowerCase() === '\\users\\';
+}
+
+export function resolveAbsolutePath(filePath: string, projectRoot?: string): string {
+  let p = filePath;
+
+  // Resolve ~ using home dir inferred from projectRoot
+  if ((p.startsWith('~/') || p.startsWith('~\\')) && projectRoot) {
+    const homeDir = inferHomeDir(projectRoot);
+    if (homeDir) {
+      p = joinDisplayPath(homeDir, p.slice(2));
+    }
+  }
+
+  // Make relative paths absolute by prepending projectRoot
+  if (projectRoot && !p.startsWith('/') && !p.startsWith('~') && !isWindowsAbsolutePath(p)) {
+    p = joinDisplayPath(projectRoot, p);
+  }
+
+  return p;
+}

package/src/renderer/utils/pathNormalize.ts

@@ -0,0 +1,61 @@
+import type { GlobalTask } from '@shared/types';
+
+export function normalizePath(p: string): string {
+  let s = p.replace(/\\/g, '/');
+  // Preserve root paths like "/" or "C:/"
+  if (s !== '/' && !/^[A-Za-z]:\/$/.test(s)) {
+    while (s.endsWith('/')) s = s.slice(0, -1);
+  }
+  return s.toLowerCase();
+}
+
+export interface TaskStatusCounts {
+  pending: number;
+  inProgress: number;
+  completed: number;
+}
+
+function incrementStatus(counts: TaskStatusCounts, status: string): TaskStatusCounts {
+  if (status === 'pending') return { ...counts, pending: counts.pending + 1 };
+  if (status === 'in_progress') return { ...counts, inProgress: counts.inProgress + 1 };
+  if (status === 'completed') return { ...counts, completed: counts.completed + 1 };
+  return counts;
+}
+
+/** Build a map of normalized project path -> task status counts */
+export function buildTaskCountsByProject(tasks: GlobalTask[]): Map<string, TaskStatusCounts> {
+  const map = new Map<string, TaskStatusCounts>();
+  for (const task of tasks) {
+    if (!task.projectPath) continue;
+    const key = normalizePath(task.projectPath);
+    const counts = map.get(key) ?? { pending: 0, inProgress: 0, completed: 0 };
+    map.set(key, incrementStatus(counts, task.status));
+  }
+  return map;
+}
+
+/** Build a map of team name -> task status counts */
+export function buildTaskCountsByTeam(tasks: GlobalTask[]): Map<string, TaskStatusCounts> {
+  const map = new Map<string, TaskStatusCounts>();
+  for (const task of tasks) {
+    const key = task.teamName;
+    const counts = map.get(key) ?? { pending: 0, inProgress: 0, completed: 0 };
+    map.set(key, incrementStatus(counts, task.status));
+  }
+  return map;
+}
+
+/** Build a map of owner name (lowercase) -> task status counts (ignores deleted). */
+export function buildTaskCountsByOwner(
+  tasks: { owner?: string | null; status: string }[]
+): Map<string, TaskStatusCounts> {
+  const map = new Map<string, TaskStatusCounts>();
+  for (const task of tasks) {
+    const owner = task.owner?.trim();
+    if (!owner || task.status === 'deleted') continue;
+    const key = owner.toLowerCase();
+    const counts = map.get(key) ?? { pending: 0, inProgress: 0, completed: 0 };
+    map.set(key, incrementStatus(counts, task.status));
+  }
+  return map;
+}

package/src/renderer/utils/pathUtils.ts

@@ -0,0 +1,47 @@
+/**
+ * Cross-platform path utilities for the renderer process.
+ *
+ * The renderer has no access to Node's `path` module, and session data
+ * may originate from any OS, so all helpers handle both `/` and `\`.
+ */
+
+const SEP_RE = /[\\/]/;
+
+/**
+ * Returns the last segment of a path (the file or directory name).
+ * Equivalent to `path.basename()` but handles both separators.
+ */
+export function getBaseName(filePath: string): string {
+  const parts = filePath.split(SEP_RE);
+  return parts[parts.length - 1] || '';
+}
+
+/**
+ * Returns the first meaningful segment of a path.
+ * Leading empty segments (from absolute paths like `/foo`) are skipped.
+ */
+export function getFirstSegment(filePath: string): string {
+  const parts = filePath.split(SEP_RE).filter(Boolean);
+  return parts[0] ?? '';
+}
+
+/**
+ * Splits a path into non-empty segments.
+ */
+export function splitPathSegments(filePath: string): string[] {
+  return filePath.split(SEP_RE).filter(Boolean);
+}
+
+/**
+ * Returns true if the string contains a path separator (`/` or `\`).
+ */
+export function hasPathSeparator(filePath: string): boolean {
+  return SEP_RE.test(filePath);
+}
+
+/**
+ * Returns true if the path starts with `./`, `.\`, `../`, or `..\`.
+ */
+export function isRelativePath(filePath: string): boolean {
+  return /^\.\.?[\\/]/.test(filePath);
+}

package/src/renderer/utils/platformKeys.ts

@@ -0,0 +1,24 @@
+/**
+ * Cross-platform keyboard shortcut display helpers.
+ *
+ * Mac shows symbols (cmd, shift, option, ctrl), Windows/Linux shows words (Ctrl+, Shift+, Alt+).
+ */
+
+function detectMac(): boolean {
+  if (typeof navigator === 'undefined') return false;
+  // Prefer userAgentData (modern API) over deprecated navigator.platform
+  const platform =
+    (navigator as Navigator & { userAgentData?: { platform?: string } }).userAgentData?.platform ??
+    navigator.userAgent;
+  return /mac/i.test(platform);
+}
+
+export const IS_MAC = detectMac();
+
+/** Return platform-appropriate modifier prefix: "cmd" on Mac, "Ctrl+" on others */
+export const MOD = IS_MAC ? '\u2318' : 'Ctrl+';
+
+/** Return platform-appropriate shortcut string */
+export function shortcutLabel(mac: string, other: string): string {
+  return IS_MAC ? mac : other;
+}

package/src/renderer/utils/previewRegistry.ts

@@ -0,0 +1,45 @@
+/**
+ * Preview type registry for binary files.
+ *
+ * Extensible: add a new PreviewType + extension set + component to support new formats.
+ */
+
+export type PreviewType = 'image' | 'unknown';
+
+const IMAGE_EXTENSIONS = new Set(['png', 'jpg', 'jpeg', 'gif', 'webp', 'svg', 'bmp', 'ico']);
+
+const IMAGE_MAX_SIZE = 10 * 1024 * 1024; // 10 MB
+
+const MIME_MAP: Record<string, string> = {
+  png: 'image/png',
+  jpg: 'image/jpeg',
+  jpeg: 'image/jpeg',
+  gif: 'image/gif',
+  webp: 'image/webp',
+  svg: 'image/svg+xml',
+  bmp: 'image/bmp',
+  ico: 'image/x-icon',
+};
+
+function getExtension(fileName: string): string {
+  const dot = fileName.lastIndexOf('.');
+  if (dot === -1) return '';
+  return fileName.slice(dot + 1).toLowerCase();
+}
+
+export function getPreviewType(fileName: string): PreviewType {
+  const ext = getExtension(fileName);
+  if (IMAGE_EXTENSIONS.has(ext)) return 'image';
+  return 'unknown';
+}
+
+export function isPreviewable(fileName: string, size: number): boolean {
+  const type = getPreviewType(fileName);
+  if (type === 'image') return size <= IMAGE_MAX_SIZE;
+  return false;
+}
+
+export function getMimeType(fileName: string): string | null {
+  const ext = getExtension(fileName);
+  return MIME_MAP[ext] ?? null;
+}

package/src/renderer/utils/projectColor.ts

@@ -0,0 +1,54 @@
+import type { TeamColorSet } from '@renderer/constants/teamColors';
+
+function hashStringToHue(str: string): number {
+  if (!str) return 0;
+  let hash = 0;
+  for (let i = 0; i < str.length; i++) {
+    hash = str.charCodeAt(i) + ((hash << 5) - hash);
+  }
+  return ((hash % 360) + 360) % 360;
+}
+
+export interface ProjectColorSet {
+  border: string;
+  glow: string;
+  icon: string;
+  text: string;
+}
+
+export function projectColor(name: string, isLight = false): ProjectColorSet {
+  if (!name) name = '';
+  const hue = hashStringToHue(name);
+  if (isLight) {
+    return {
+      border: `hsla(${hue}, 70%, 40%, 0.7)`,
+      glow: `hsla(${hue}, 70%, 40%, 0.08)`,
+      icon: `hsla(${hue}, 70%, 40%, 0.85)`,
+      text: `hsla(${hue}, 50%, 35%, 0.9)`,
+    };
+  }
+  return {
+    border: `hsla(${hue}, 70%, 55%, 0.5)`,
+    glow: `hsla(${hue}, 70%, 55%, 0.06)`,
+    icon: `hsla(${hue}, 70%, 65%, 0.8)`,
+    text: `hsla(${hue}, 40%, 65%, 0.55)`,
+  };
+}
+
+/** Generate a TeamColorSet from any name (deterministic hue). */
+export function nameColorSet(name: string, isLight = false): TeamColorSet {
+  if (!name) name = '';
+  const hue = hashStringToHue(name);
+  if (isLight) {
+    return {
+      border: `hsl(${hue}, 70%, 40%)`,
+      badge: `hsla(${hue}, 70%, 40%, 0.1)`,
+      text: `hsla(${hue}, 50%, 35%, 0.9)`,
+    };
+  }
+  return {
+    border: `hsl(${hue}, 70%, 55%)`,
+    badge: `hsla(${hue}, 70%, 55%, 0.08)`,
+    text: `hsla(${hue}, 35%, 70%, 0.55)`,
+  };
+}

package/src/renderer/utils/projectLookup.ts

@@ -0,0 +1,64 @@
+/**
+ * Project lookup utilities — resolve project IDs from filesystem paths.
+ *
+ * The projects list (`projects`) is only populated when the sidebar is in "flat"
+ * view mode, whereas `repositoryGroups` is populated in "grouped" mode.
+ * This helper checks both sources so team pages can always find the matching
+ * encoded project ID regardless of which data set is currently loaded.
+ */
+
+import type { Project, RepositoryGroup } from '@renderer/types/data';
+
+/**
+ * Resolve an encoded project ID from a filesystem path.
+ *
+ * Lookup order:
+ * 1. `projects[]` — flat project list (populated in flat view mode)
+ * 2. `repositoryGroups[].worktrees[]` — worktree entries (populated in grouped view mode)
+ *
+ * @returns The encoded project directory name (e.g. `-Users-belief-dev-project`) or `null`.
+ */
+export function resolveProjectIdByPath(
+  projectPath: string | undefined | null,
+  projects: readonly Pick<Project, 'id' | 'path'>[],
+  repositoryGroups: readonly Pick<RepositoryGroup, 'worktrees'>[]
+): string | null {
+  if (!projectPath) return null;
+
+  const fromProjects = projects.find((p) => p.path === projectPath);
+  if (fromProjects) return fromProjects.id;
+
+  for (const group of repositoryGroups) {
+    const worktree = group.worktrees.find((w) => w.path === projectPath);
+    if (worktree) return worktree.id;
+  }
+
+  return null;
+}
+
+/**
+ * Resolve a filesystem path from an encoded project ID.
+ *
+ * Inverse of `resolveProjectIdByPath`: given a project ID (e.g. `-home-diego-DEV-monorepo-rCAPI`),
+ * returns the decoded path (e.g. `/home/diego/DEV/monorepo/rCAPI`).
+ *
+ * Checks both `projects[]` and `repositoryGroups[].worktrees[]` so the result
+ * is correct regardless of whether the sidebar is in flat or grouped view mode.
+ */
+export function resolveProjectPathById(
+  projectId: string | undefined | null,
+  projects: readonly Pick<Project, 'id' | 'path' | 'name'>[],
+  repositoryGroups: readonly Pick<RepositoryGroup, 'worktrees'>[]
+): { path: string; name: string } | null {
+  if (!projectId) return null;
+
+  const fromProjects = projects.find((p) => p.id === projectId);
+  if (fromProjects) return { path: fromProjects.path, name: fromProjects.name };
+
+  for (const group of repositoryGroups) {
+    const worktree = group.worktrees.find((w) => w.id === projectId);
+    if (worktree) return { path: worktree.path, name: worktree.name };
+  }
+
+  return null;
+}

package/src/renderer/utils/providerBackendIdentity.ts

@@ -0,0 +1,43 @@
+import {
+  formatProviderBackendLabel,
+  getDefaultProviderBackendId,
+  isTeamProviderBackendId,
+  migrateProviderBackendId,
+} from '@shared/utils/providerBackend';
+import { normalizeOptionalTeamProviderId } from '@shared/utils/teamProvider';
+
+import type { CliProviderStatus, TeamProviderBackendId, TeamProviderId } from '@shared/types';
+
+function normalizeOptionalBackendId(value: string | null | undefined): string | undefined {
+  const trimmed = value?.trim();
+  return trimmed ? trimmed : undefined;
+}
+
+export { formatProviderBackendLabel, getDefaultProviderBackendId };
+
+export function resolveEffectiveProviderBackendId(
+  provider: Pick<CliProviderStatus, 'selectedBackendId' | 'resolvedBackendId'> | null | undefined
+): TeamProviderBackendId | undefined {
+  const backendId = normalizeOptionalBackendId(
+    provider?.resolvedBackendId ?? provider?.selectedBackendId
+  );
+  return isTeamProviderBackendId(backendId) ? backendId : undefined;
+}
+
+export function resolveUiOwnedProviderBackendId(
+  providerId: TeamProviderId | CliProviderStatus['providerId'] | undefined,
+  provider: Pick<CliProviderStatus, 'selectedBackendId' | 'resolvedBackendId'> | null | undefined
+): TeamProviderBackendId | undefined {
+  const normalizedProviderId = normalizeOptionalTeamProviderId(providerId);
+  return migrateProviderBackendId(
+    normalizedProviderId,
+    provider?.selectedBackendId ?? provider?.resolvedBackendId
+  );
+}
+
+export function formatTeamProviderBackendLabel(
+  providerId: TeamProviderId | undefined,
+  providerBackendId: string | undefined
+): string | undefined {
+  return formatProviderBackendLabel(providerId, providerBackendId);
+}

package/src/renderer/utils/providerSlashCommands.ts

@@ -0,0 +1,122 @@
+import { KNOWN_SLASH_COMMANDS } from '@shared/utils/slashCommands';
+
+import type { TeamProviderId } from '@shared/types';
+import type { KnownSlashCommandDefinition } from '@shared/utils/slashCommands';
+
+const CODEX_SLASH_COMMAND_SUGGESTIONS: readonly KnownSlashCommandDefinition[] = [
+  {
+    name: 'model',
+    command: '/model',
+    description: 'Choose the active model for this session.',
+  },
+  {
+    name: 'fast',
+    command: '/fast',
+    description: 'Toggle Fast mode on or off.',
+  },
+  {
+    name: 'permissions',
+    command: '/permissions',
+    description: 'Adjust approval requirements for tools and commands.',
+  },
+  {
+    name: 'plan',
+    command: '/plan',
+    description: 'Switch to plan mode with an optional prompt.',
+  },
+  {
+    name: 'review',
+    command: '/review',
+    description: 'Ask Codex to review the current working tree.',
+  },
+  {
+    name: 'diff',
+    command: '/diff',
+    description: 'Show the current Git diff, including untracked files.',
+  },
+  {
+    name: 'status',
+    command: '/status',
+    description: 'Show session configuration and token usage.',
+  },
+  {
+    name: 'mcp',
+    command: '/mcp',
+    description: 'List configured MCP tools for this session.',
+  },
+  {
+    name: 'mention',
+    command: '/mention',
+    description: 'Attach a file or folder to the conversation.',
+  },
+  {
+    name: 'apps',
+    command: '/apps',
+    description: 'Browse available apps and connectors.',
+  },
+  {
+    name: 'plugins',
+    command: '/plugins',
+    description: 'Browse and manage installed plugins.',
+  },
+  {
+    name: 'agent',
+    command: '/agent',
+    description: 'Switch to another agent thread.',
+  },
+  {
+    name: 'personality',
+    command: '/personality',
+    description: 'Change Codex response style for the current thread.',
+  },
+  {
+    name: 'compact',
+    command: '/compact',
+    description: 'Summarize the conversation to free tokens.',
+  },
+  {
+    name: 'clear',
+    command: '/clear',
+    description: 'Clear the terminal and start a fresh chat.',
+  },
+  {
+    name: 'new',
+    command: '/new',
+    description: 'Start a new conversation in the current session.',
+  },
+  {
+    name: 'copy',
+    command: '/copy',
+    description: 'Copy the latest completed Codex output.',
+  },
+  {
+    name: 'fork',
+    command: '/fork',
+    description: 'Fork the current conversation into a new thread.',
+  },
+  {
+    name: 'resume',
+    command: '/resume',
+    description: 'Resume a previous conversation.',
+  },
+  {
+    name: 'quit',
+    command: '/quit',
+    description: 'Exit the CLI.',
+  },
+  {
+    name: 'exit',
+    command: '/exit',
+    description: 'Exit the CLI.',
+  },
+] as const;
+
+export function getSuggestedSlashCommandsForProvider(
+  providerId?: TeamProviderId
+): readonly KnownSlashCommandDefinition[] {
+  if (providerId === 'codex') {
+    return CODEX_SLASH_COMMAND_SUGGESTIONS;
+  }
+
+  return KNOWN_SLASH_COMMANDS;
+}