@yancyyu/openhermit 1.5.8

package/src/features/recent-projects/core/domain/policies/mergeRecentProjectCandidates.ts

@@ -0,0 +1,88 @@
+import type { ProviderId } from '../models/ProviderId';
+import type { RecentProjectAggregate } from '../models/RecentProjectAggregate';
+import type { RecentProjectCandidate } from '../models/RecentProjectCandidate';
+
+function uniquePaths(paths: readonly string[], primaryPath: string): string[] {
+  const ordered = [primaryPath, ...paths];
+  const seen = new Set<string>();
+  const result: string[] = [];
+
+  for (const path of ordered) {
+    if (!path || seen.has(path)) {
+      continue;
+    }
+    seen.add(path);
+    result.push(path);
+  }
+
+  return result;
+}
+
+function uniqueProviders(providerIds: readonly ProviderId[]): ProviderId[] {
+  return Array.from(new Set(providerIds));
+}
+
+function selectPreferredCandidate(
+  candidates: readonly RecentProjectCandidate[]
+): RecentProjectCandidate {
+  const existingWorktreeCandidates = candidates.filter(
+    (candidate) => candidate.openTarget.type === 'existing-worktree'
+  );
+  const pool = existingWorktreeCandidates.length > 0 ? existingWorktreeCandidates : candidates;
+
+  return [...pool].sort((left, right) => {
+    if (right.lastActivityAt !== left.lastActivityAt) {
+      return right.lastActivityAt - left.lastActivityAt;
+    }
+    return left.displayName.localeCompare(right.displayName);
+  })[0];
+}
+
+function mergeBranchName(candidates: readonly RecentProjectCandidate[]): string | undefined {
+  const branchNames = Array.from(
+    new Set(candidates.map((candidate) => candidate.branchName?.trim()).filter(Boolean))
+  );
+
+  return branchNames.length === 1 ? branchNames[0] : undefined;
+}
+
+export function mergeRecentProjectCandidates(
+  candidates: readonly RecentProjectCandidate[]
+): RecentProjectAggregate[] {
+  const grouped = new Map<string, RecentProjectCandidate[]>();
+
+  for (const candidate of candidates) {
+    if (!candidate.identity || candidate.lastActivityAt <= 0) {
+      continue;
+    }
+    const bucket = grouped.get(candidate.identity);
+    if (bucket) {
+      bucket.push(candidate);
+    } else {
+      grouped.set(candidate.identity, [candidate]);
+    }
+  }
+
+  const aggregates = Array.from(grouped.values()).map((group): RecentProjectAggregate => {
+    const preferred = selectPreferredCandidate(group);
+    const providerIds = uniqueProviders(group.flatMap((candidate) => candidate.providerIds));
+    const sourceKinds = new Set(group.map((candidate) => candidate.sourceKind));
+
+    return {
+      identity: preferred.identity,
+      displayName: preferred.displayName,
+      primaryPath: preferred.primaryPath,
+      associatedPaths: uniquePaths(
+        group.flatMap((candidate) => candidate.associatedPaths),
+        preferred.primaryPath
+      ),
+      lastActivityAt: Math.max(...group.map((candidate) => candidate.lastActivityAt)),
+      providerIds,
+      source: sourceKinds.size > 1 ? 'mixed' : sourceKinds.has('codex') ? 'codex' : 'claude',
+      openTarget: preferred.openTarget,
+      branchName: mergeBranchName(group),
+    };
+  });
+
+  return aggregates.sort((left, right) => right.lastActivityAt - left.lastActivityAt);
+}

package/src/features/recent-projects/main/adapters/input/http/registerRecentProjectsHttp.ts

@@ -0,0 +1,30 @@
+import {
+  DASHBOARD_RECENT_PROJECTS_ROUTE,
+  type DashboardRecentProjectsPayload,
+  normalizeDashboardRecentProjectsPayload,
+} from '@features/recent-projects/contracts';
+import { createLogger } from '@shared/utils/logger';
+
+import type { RecentProjectsFeatureFacade } from '@features/recent-projects/main/composition/createRecentProjectsFeature';
+import type { FastifyInstance } from 'fastify';
+
+const logger = createLogger('Feature:RecentProjects:HTTP');
+
+export function registerRecentProjectsHttp(
+  app: FastifyInstance,
+  feature: RecentProjectsFeatureFacade
+): void {
+  app.get(DASHBOARD_RECENT_PROJECTS_ROUTE, async (): Promise<DashboardRecentProjectsPayload> => {
+    try {
+      return (
+        normalizeDashboardRecentProjectsPayload(await feature.listDashboardRecentProjects()) ?? {
+          projects: [],
+          degraded: true,
+        }
+      );
+    } catch (error) {
+      logger.error('Failed to load dashboard recent projects via HTTP', error);
+      return { projects: [], degraded: true };
+    }
+  });
+}

package/src/features/recent-projects/main/adapters/output/presenters/DashboardRecentProjectsPresenter.ts

@@ -0,0 +1,27 @@
+import type {
+  DashboardRecentProject,
+  DashboardRecentProjectsPayload,
+} from '@features/recent-projects/contracts';
+import type { ListDashboardRecentProjectsResponse } from '@features/recent-projects/core/application/models/ListDashboardRecentProjectsResponse';
+import type { ListDashboardRecentProjectsOutputPort } from '@features/recent-projects/core/application/ports/ListDashboardRecentProjectsOutputPort';
+
+export class DashboardRecentProjectsPresenter implements ListDashboardRecentProjectsOutputPort<DashboardRecentProjectsPayload> {
+  present(response: ListDashboardRecentProjectsResponse): DashboardRecentProjectsPayload {
+    return {
+      degraded: response.degraded,
+      projects: response.projects.map(
+        (aggregate): DashboardRecentProject => ({
+          id: aggregate.identity,
+          name: aggregate.displayName,
+          primaryPath: aggregate.primaryPath,
+          associatedPaths: aggregate.associatedPaths,
+          mostRecentActivity: aggregate.lastActivityAt,
+          providerIds: aggregate.providerIds,
+          source: aggregate.source,
+          openTarget: aggregate.openTarget,
+          primaryBranch: aggregate.branchName,
+        })
+      ),
+    };
+  }
+}

package/src/features/recent-projects/main/adapters/output/sources/ClaudeRecentProjectsSourceAdapter.ts

@@ -0,0 +1,91 @@
+import { normalizeIdentityPath } from '@features/recent-projects/main/infrastructure/identity/normalizeIdentityPath';
+import { WorktreeGrouper } from '@main/services/discovery/WorktreeGrouper';
+import { getProjectsBasePath } from '@main/utils/pathDecoder';
+import { isEphemeralProjectPath } from '@shared/utils/ephemeralProjectPath';
+
+import type { LoggerPort } from '@features/recent-projects/core/application/ports/LoggerPort';
+import type {
+  RecentProjectsSourcePort,
+  RecentProjectsSourceResult,
+} from '@features/recent-projects/core/application/ports/RecentProjectsSourcePort';
+import type { RecentProjectCandidate } from '@features/recent-projects/core/domain/models/RecentProjectCandidate';
+import type { ServiceContext } from '@main/services';
+import type { RepositoryGroup, Worktree } from '@main/types';
+
+function selectPreferredWorktree(worktrees: readonly Worktree[]): Worktree | undefined {
+  return worktrees.find((worktree) => worktree.isMainWorktree) ?? worktrees[0];
+}
+
+function toCandidate(repo: RepositoryGroup): RecentProjectCandidate | null {
+  const selectableWorktrees = repo.worktrees.filter(
+    (worktree) => !isEphemeralProjectPath(worktree.path)
+  );
+
+  if (!selectableWorktrees.length || !repo.mostRecentSession) {
+    return null;
+  }
+
+  const preferredWorktree = selectPreferredWorktree(selectableWorktrees);
+  if (!preferredWorktree) {
+    return null;
+  }
+
+  return {
+    identity: repo.identity?.id ?? `path:${normalizeIdentityPath(preferredWorktree.path)}`,
+    displayName: repo.name,
+    primaryPath: preferredWorktree.path,
+    associatedPaths: selectableWorktrees.map((worktree) => worktree.path),
+    lastActivityAt: repo.mostRecentSession,
+    providerIds: ['anthropic'],
+    sourceKind: 'claude',
+    openTarget: {
+      type: 'existing-worktree',
+      repositoryId: repo.id,
+      worktreeId: preferredWorktree.id,
+    },
+    branchName: preferredWorktree.gitBranch,
+  };
+}
+
+export class ClaudeRecentProjectsSourceAdapter implements RecentProjectsSourcePort {
+  readonly #localWorktreeGrouper = new WorktreeGrouper(getProjectsBasePath());
+
+  constructor(
+    private readonly getActiveContext: () => ServiceContext,
+    private readonly logger: LoggerPort
+  ) {}
+
+  async list(): Promise<RecentProjectsSourceResult> {
+    const activeContext = this.getActiveContext();
+    const groups =
+      activeContext.type === 'local'
+        ? await this.#groupLocalProjects(activeContext)
+        : await activeContext.projectScanner.scanWithWorktreeGrouping();
+
+    const candidates = groups
+      .map((group) => toCandidate(group))
+      .filter((candidate): candidate is RecentProjectCandidate => candidate !== null);
+
+    this.logger.info('claude recent-projects source loaded', {
+      count: candidates.length,
+      contextId: activeContext.id,
+    });
+
+    return {
+      candidates,
+      degraded: false,
+    };
+  }
+
+  async #groupLocalProjects(activeContext: ServiceContext): Promise<RepositoryGroup[]> {
+    try {
+      const projects = await activeContext.projectScanner.scan();
+      return await this.#localWorktreeGrouper.groupByRepository(projects);
+    } catch (error) {
+      this.logger.warn('claude recent-projects fell back to simplified grouping', {
+        error: error instanceof Error ? error.message : String(error),
+      });
+      return activeContext.projectScanner.scanWithWorktreeGrouping();
+    }
+  }
+}

package/src/features/recent-projects/main/adapters/output/sources/CodexRecentProjectsSourceAdapter.ts

@@ -0,0 +1,326 @@
+import { normalizeIdentityPath } from '@features/recent-projects/main/infrastructure/identity/normalizeIdentityPath';
+import { isEphemeralProjectPath } from '@shared/utils/ephemeralProjectPath';
+import path from 'path';
+
+import type { LoggerPort } from '@features/recent-projects/core/application/ports/LoggerPort';
+import type {
+  RecentProjectsSourcePort,
+  RecentProjectsSourceResult,
+} from '@features/recent-projects/core/application/ports/RecentProjectsSourcePort';
+import type { RecentProjectCandidate } from '@features/recent-projects/core/domain/models/RecentProjectCandidate';
+import type {
+  CodexAppServerClient,
+  CodexRecentThreadsResult,
+  CodexThreadSummary,
+} from '@features/recent-projects/main/infrastructure/codex/CodexAppServerClient';
+import type { RecentProjectIdentityResolver } from '@features/recent-projects/main/infrastructure/identity/RecentProjectIdentityResolver';
+import type { ServiceContext } from '@main/services';
+
+const CODEX_THREAD_LIMIT = 20;
+const CODEX_INITIALIZE_TIMEOUT_MS = 6_000;
+const CODEX_LIVE_FETCH_TIMEOUT_MS = 18_000;
+const CODEX_ARCHIVED_FETCH_TIMEOUT_MS = 6_000;
+const CODEX_SESSION_OVERHEAD_TIMEOUT_MS = 1_500;
+const CODEX_TOTAL_FETCH_TIMEOUT_MS =
+  CODEX_INITIALIZE_TIMEOUT_MS +
+  CODEX_ARCHIVED_FETCH_TIMEOUT_MS +
+  CODEX_LIVE_FETCH_TIMEOUT_MS +
+  CODEX_SESSION_OVERHEAD_TIMEOUT_MS;
+const CODEX_SOURCE_TIMEOUT_MS = CODEX_TOTAL_FETCH_TIMEOUT_MS + 500;
+const CODEX_LIVE_ONLY_FALLBACK_TOTAL_TIMEOUT_MS =
+  CODEX_INITIALIZE_TIMEOUT_MS + CODEX_LIVE_FETCH_TIMEOUT_MS + CODEX_SESSION_OVERHEAD_TIMEOUT_MS;
+const CODEX_STALE_CANDIDATES_TTL_MS = 5 * 60_000;
+const CODEX_FULL_FAILURE_COOLDOWN_MS = 30_000;
+
+interface StaleCodexCandidatesSnapshot {
+  candidates: RecentProjectCandidate[];
+  capturedAt: number;
+}
+
+function isInteractiveSource(source: unknown): boolean {
+  return source === 'vscode' || source === 'cli';
+}
+
+function normalizeTimestamp(value: number | undefined): number {
+  if (!value) {
+    return 0;
+  }
+  return value < 1_000_000_000_000 ? value * 1000 : value;
+}
+
+function isDegradedThreadResult(result: CodexRecentThreadsResult): boolean {
+  return Boolean(result.live.error || result.archived.error);
+}
+
+function getFullFailureReason(result: CodexRecentThreadsResult): string | null {
+  if (!result.live.error || !result.archived.error) {
+    return null;
+  }
+
+  if (result.live.error === result.archived.error) {
+    return result.live.error;
+  }
+
+  if (result.archived.skipped) {
+    return result.live.error;
+  }
+
+  return `live: ${result.live.error}; archived: ${result.archived.error}`;
+}
+
+export class CodexRecentProjectsSourceAdapter implements RecentProjectsSourcePort {
+  readonly sourceId = 'codex';
+  readonly timeoutMs = CODEX_SOURCE_TIMEOUT_MS;
+  #staleCandidatesSnapshot: StaleCodexCandidatesSnapshot | null = null;
+  #fullFailureCooldownUntil = 0;
+  #fullFailureCooldownReason: string | null = null;
+
+  constructor(
+    private readonly deps: {
+      getActiveContext: () => ServiceContext;
+      getLocalContext: () => ServiceContext | undefined;
+      resolveBinary: () => Promise<string | null>;
+      appServerClient: CodexAppServerClient;
+      identityResolver: RecentProjectIdentityResolver;
+      logger: LoggerPort;
+    }
+  ) {}
+
+  async list(): Promise<RecentProjectsSourceResult> {
+    const activeContext = this.deps.getActiveContext();
+    const localContext = this.deps.getLocalContext();
+
+    if (activeContext.type !== 'local' || activeContext.id !== localContext?.id) {
+      return {
+        candidates: [],
+        degraded: false,
+      };
+    }
+
+    const binaryPath = await this.deps.resolveBinary();
+    if (!binaryPath) {
+      this.deps.logger.info('codex recent-projects source skipped - binary unavailable');
+      return {
+        candidates: [],
+        degraded: false,
+      };
+    }
+
+    const cooldown = this.#getActiveCooldown();
+    if (cooldown) {
+      this.deps.logger.info('codex recent-projects source cooldown active', cooldown);
+      return {
+        candidates: this.#getFreshStaleCandidates() ?? [],
+        degraded: true,
+      };
+    }
+
+    const threadSegments = await this.#listRecentThreadsSafe(binaryPath);
+    const degraded = isDegradedThreadResult(threadSegments);
+    const fullFailureReason = getFullFailureReason(threadSegments);
+    this.#updateFullFailureCooldown(fullFailureReason);
+    this.#logSegmentFailure(threadSegments, 'live');
+    this.#logSegmentFailure(threadSegments, 'archived');
+    const liveThreads = threadSegments.live.threads;
+    const archivedThreads = threadSegments.archived.threads;
+
+    const interactiveThreads = [...liveThreads, ...archivedThreads].filter(
+      (thread) => Boolean(thread.cwd) && isInteractiveSource(thread.source)
+    );
+
+    const candidates = (
+      await Promise.all(interactiveThreads.map((thread) => this.#toCandidate(thread)))
+    ).filter((candidate): candidate is RecentProjectCandidate => candidate !== null);
+
+    if (!degraded) {
+      this.#rememberHealthyCandidates(candidates);
+    }
+
+    if (degraded && candidates.length === 0) {
+      const staleCandidates = this.#getFreshStaleCandidates();
+      if (staleCandidates) {
+        this.deps.logger.info('codex recent-projects served stale candidates', {
+          count: staleCandidates.length,
+          reason: fullFailureReason ?? 'degraded-empty-result',
+        });
+
+        return {
+          candidates: staleCandidates,
+          degraded: true,
+        };
+      }
+    }
+
+    this.deps.logger.info('codex recent-projects source loaded', {
+      count: candidates.length,
+      degraded,
+    });
+
+    return {
+      candidates,
+      degraded,
+    };
+  }
+
+  #getActiveCooldown(): { retryAfterMs: number; reason: string | null } | null {
+    const retryAfterMs = this.#fullFailureCooldownUntil - Date.now();
+    if (retryAfterMs <= 0) {
+      return null;
+    }
+
+    return {
+      retryAfterMs,
+      reason: this.#fullFailureCooldownReason,
+    };
+  }
+
+  #updateFullFailureCooldown(reason: string | null): void {
+    if (!reason) {
+      this.#fullFailureCooldownUntil = 0;
+      this.#fullFailureCooldownReason = null;
+      return;
+    }
+
+    this.#fullFailureCooldownUntil = Date.now() + CODEX_FULL_FAILURE_COOLDOWN_MS;
+    this.#fullFailureCooldownReason = reason;
+  }
+
+  #rememberHealthyCandidates(candidates: RecentProjectCandidate[]): void {
+    this.#staleCandidatesSnapshot =
+      candidates.length > 0
+        ? {
+            candidates,
+            capturedAt: Date.now(),
+          }
+        : null;
+  }
+
+  #getFreshStaleCandidates(): RecentProjectCandidate[] | null {
+    const snapshot = this.#staleCandidatesSnapshot;
+    if (!snapshot) {
+      return null;
+    }
+
+    if (Date.now() - snapshot.capturedAt > CODEX_STALE_CANDIDATES_TTL_MS) {
+      this.#staleCandidatesSnapshot = null;
+      return null;
+    }
+
+    return [...snapshot.candidates];
+  }
+
+  async #listRecentThreads(binaryPath: string): Promise<CodexRecentThreadsResult> {
+    const result = await this.deps.appServerClient.listRecentThreads(binaryPath, {
+      limit: CODEX_THREAD_LIMIT,
+      liveRequestTimeoutMs: CODEX_LIVE_FETCH_TIMEOUT_MS,
+      archivedRequestTimeoutMs: CODEX_ARCHIVED_FETCH_TIMEOUT_MS,
+      initializeTimeoutMs: CODEX_INITIALIZE_TIMEOUT_MS,
+      totalTimeoutMs: CODEX_TOTAL_FETCH_TIMEOUT_MS,
+    });
+
+    this.deps.logger.info('codex recent-projects thread lists loaded', {
+      liveCount: result.live.threads.length,
+      archivedCount: result.archived.threads.length,
+    });
+    return result;
+  }
+
+  #logSegmentFailure(result: CodexRecentThreadsResult, segment: 'live' | 'archived'): void {
+    const error = result[segment].error;
+    if (!error) {
+      return;
+    }
+
+    if (result[segment].skipped) {
+      this.deps.logger.info('codex recent-projects thread list skipped', {
+        segment,
+        reason: error,
+      });
+      return;
+    }
+
+    if (segment === 'archived' && !result.live.error) {
+      this.deps.logger.info('codex recent-projects archived thread list degraded', {
+        error,
+      });
+      return;
+    }
+
+    this.deps.logger.warn('codex recent-projects thread list failed', {
+      segment,
+      error,
+    });
+  }
+
+  async #listRecentThreadsSafe(binaryPath: string): Promise<CodexRecentThreadsResult> {
+    try {
+      return await this.#listRecentThreads(binaryPath);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      this.deps.logger.warn('codex recent-projects thread list session failed', {
+        error: message,
+      });
+
+      if (message.toLowerCase().includes('timed out')) {
+        return {
+          live: { threads: [], error: message },
+          archived: { threads: [], error: message },
+        };
+      }
+
+      try {
+        const liveFallback = await this.deps.appServerClient.listRecentLiveThreads(binaryPath, {
+          limit: CODEX_THREAD_LIMIT,
+          requestTimeoutMs: CODEX_LIVE_FETCH_TIMEOUT_MS,
+          initializeTimeoutMs: CODEX_INITIALIZE_TIMEOUT_MS,
+          totalTimeoutMs: CODEX_LIVE_ONLY_FALLBACK_TOTAL_TIMEOUT_MS,
+        });
+
+        this.deps.logger.info('codex recent-projects recovered with live-only fallback', {
+          liveCount: liveFallback.threads.length,
+        });
+
+        return {
+          live: liveFallback,
+          archived: { threads: [], error: message },
+        };
+      } catch (fallbackError) {
+        const fallbackMessage =
+          fallbackError instanceof Error ? fallbackError.message : String(fallbackError);
+        this.deps.logger.warn('codex recent-projects live-only fallback failed', {
+          error: fallbackMessage,
+        });
+      }
+
+      return {
+        live: { threads: [], error: message },
+        archived: { threads: [], error: message },
+      };
+    }
+  }
+
+  async #toCandidate(thread: CodexThreadSummary): Promise<RecentProjectCandidate | null> {
+    const cwd = thread.cwd?.trim();
+    if (!cwd || isEphemeralProjectPath(cwd)) {
+      return null;
+    }
+
+    const identity = await this.deps.identityResolver.resolve(cwd);
+    const displayName = identity?.name ?? path.basename(cwd) ?? thread.name?.trim() ?? cwd;
+
+    return {
+      identity: identity?.id ?? `path:${normalizeIdentityPath(cwd)}`,
+      displayName,
+      primaryPath: cwd,
+      associatedPaths: [cwd],
+      lastActivityAt: normalizeTimestamp(thread.updatedAt ?? thread.createdAt),
+      providerIds: ['codex'],
+      sourceKind: 'codex',
+      openTarget: {
+        type: 'synthetic-path',
+        path: cwd,
+      },
+      branchName: thread.gitInfo?.branch ?? undefined,
+    };
+  }
+}

package/src/features/recent-projects/main/composition/createRecentProjectsFeature.ts

@@ -0,0 +1,43 @@
+import {
+  type DashboardRecentProjectsPayload,
+  normalizeDashboardRecentProjectsPayload,
+} from '@features/recent-projects/contracts';
+
+import { ListDashboardRecentProjectsUseCase } from '../../core/application/use-cases/ListDashboardRecentProjectsUseCase';
+import { DashboardRecentProjectsPresenter } from '../adapters/output/presenters/DashboardRecentProjectsPresenter';
+import { ClaudeRecentProjectsSourceAdapter } from '../adapters/output/sources/ClaudeRecentProjectsSourceAdapter';
+import { InMemoryRecentProjectsCache } from '../infrastructure/cache/InMemoryRecentProjectsCache';
+
+import type { ClockPort } from '../../core/application/ports/ClockPort';
+import type { LoggerPort } from '../../core/application/ports/LoggerPort';
+import type { ServiceContext } from '@main/services';
+
+export interface RecentProjectsFeatureFacade {
+  listDashboardRecentProjects(): Promise<DashboardRecentProjectsPayload>;
+}
+
+export function createRecentProjectsFeature(deps: {
+  getActiveContext: () => ServiceContext;
+  getLocalContext: () => ServiceContext | undefined;
+  logger: LoggerPort;
+}): RecentProjectsFeatureFacade {
+  const cache = new InMemoryRecentProjectsCache<DashboardRecentProjectsPayload>();
+  const presenter = new DashboardRecentProjectsPresenter();
+  const clock: ClockPort = { now: () => Date.now() };
+  const sources = [new ClaudeRecentProjectsSourceAdapter(deps.getActiveContext, deps.logger)];
+  const useCase = new ListDashboardRecentProjectsUseCase({
+    sources,
+    cache,
+    output: presenter,
+    clock,
+    logger: deps.logger,
+  });
+
+  return {
+    listDashboardRecentProjects: async () => {
+      const activeContext = deps.getActiveContext();
+      const payload = await useCase.execute(`dashboard-recent-projects:${activeContext.id}`);
+      return normalizeDashboardRecentProjectsPayload(payload) ?? { projects: [], degraded: true };
+    },
+  };
+}

package/src/features/recent-projects/main/index.ts

@@ -0,0 +1,3 @@
+export { registerRecentProjectsHttp } from './adapters/input/http/registerRecentProjectsHttp';
+export type { RecentProjectsFeatureFacade } from './composition/createRecentProjectsFeature';
+export { createRecentProjectsFeature } from './composition/createRecentProjectsFeature';

package/src/features/recent-projects/main/infrastructure/cache/InMemoryRecentProjectsCache.ts

@@ -0,0 +1,34 @@
+import type { RecentProjectsCachePort } from '../../../core/application/ports/RecentProjectsCachePort';
+
+interface CacheEntry<T> {
+  value: T;
+  expiresAt: number;
+}
+
+export class InMemoryRecentProjectsCache<T> implements RecentProjectsCachePort<T> {
+  readonly #entries = new Map<string, CacheEntry<T>>();
+
+  async get(key: string): Promise<T | null> {
+    const entry = this.#entries.get(key);
+    if (!entry) {
+      return null;
+    }
+
+    if (entry.expiresAt <= Date.now()) {
+      return null;
+    }
+
+    return entry.value;
+  }
+
+  async getStale(key: string): Promise<T | null> {
+    return this.#entries.get(key)?.value ?? null;
+  }
+
+  async set(key: string, value: T, ttlMs: number): Promise<void> {
+    this.#entries.set(key, {
+      value,
+      expiresAt: Date.now() + ttlMs,
+    });
+  }
+}