@gitkraken/core-gitlens 0.3.1 → 0.4.100

package/src/git-cli/providers/worktrees.ts

@@ -14,9 +14,14 @@ import type { Uri } from '../../utils/uri.js';
 import { fileUri, toFsPath } from '../../utils/uri.js';
 import type { CliGitProviderInternal } from '../cliGitProvider.js';
 import type { Git, GitError } from '../exec/git.js';
-import { getGitCommandError } from '../exec/git.js';
+import { getGitCommandError, GitErrors } from '../exec/git.js';
 import { parseGitWorktrees } from '../parsers/worktreeParser.js';
 
+/** Extracts the lock reason from Git's `cannot remove a locked working tree` output, when it provides one */
+function getLockReason(ex: GitError): string | undefined {
+	return GitErrors.worktreeLockedReason.exec(ex.stderr || ex.stdout || ex.message || '')?.[1].trim() || undefined;
+}
+
 export class WorktreesGitSubProvider implements GitWorktreesSubProvider {
 	constructor(
 		private readonly context: GitServiceContext,
@@ -29,7 +34,13 @@ export class WorktreesGitSubProvider implements GitWorktreesSubProvider {
 	async createWorktree(
 		repoPath: string,
 		path: string,
-		options?: { commitish?: string; createBranch?: string; detach?: boolean; force?: boolean },
+		options?: {
+			commitish?: string;
+			createBranch?: string;
+			detach?: boolean;
+			force?: boolean;
+			noTracking?: boolean;
+		},
 	): Promise<void> {
 		const scope = getScopedLogger();
 
@@ -40,6 +51,9 @@ export class WorktreesGitSubProvider implements GitWorktreesSubProvider {
 		if (options?.createBranch) {
 			args.push('-b', options.createBranch);
 		}
+		if (options?.createBranch && options.noTracking) {
+			args.push('--no-track');
+		}
 		if (options?.detach) {
 			args.push('--detach');
 		}
@@ -76,7 +90,13 @@ export class WorktreesGitSubProvider implements GitWorktreesSubProvider {
 	async createWorktreeWithResult(
 		repoPath: string,
 		path: string,
-		options?: { commitish?: string; createBranch?: string; detach?: boolean; force?: boolean },
+		options?: {
+			commitish?: string;
+			createBranch?: string;
+			detach?: boolean;
+			force?: boolean;
+			noTracking?: boolean;
+		},
 	): Promise<GitWorktree | undefined> {
 		await this.createWorktree(repoPath, path, options);
 		const normalized = normalizePath(path);
@@ -102,7 +122,7 @@ export class WorktreesGitSubProvider implements GitWorktreesSubProvider {
 
 		return this.cache.getWorktrees(
 			repoPath,
-			async (commonPath, _cacheable, signal) => {
+			async (commonPath, cacheable, signal) => {
 				// Prefer the aggregate signal from the cache; fall back to the caller's cancellation.
 				signal ??= cancellation;
 				const [dataResult, branchesResult] = await Promise.allSettled([
@@ -110,6 +130,11 @@ export class WorktreesGitSubProvider implements GitWorktreesSubProvider {
 					this.provider.branches.getBranches(commonPath, undefined, signal),
 				]);
 
+				if (dataResult.status === 'rejected') {
+					// Don't cache a bogus empty result for a transient command failure — retry on next access.
+					cacheable.invalidate();
+				}
+
 				const getWorkspaceFolder: WorkspaceFolderResolver | undefined = this.context.workspace
 					? uri => {
 							const folder = this.context.workspace!.getFolder(uri.fsPath);
@@ -135,7 +160,11 @@ export class WorktreesGitSubProvider implements GitWorktreesSubProvider {
 	}
 
 	@debug()
-	async deleteWorktree(repoPath: string, path: string | Uri, options?: { force?: boolean }): Promise<void> {
+	async deleteWorktree(
+		repoPath: string,
+		path: string | Uri,
+		options?: { force?: boolean | 'locked' },
+	): Promise<void> {
 		const scope = getScopedLogger();
 
 		await this.git.ensureSupports(
@@ -147,6 +176,10 @@ export class WorktreesGitSubProvider implements GitWorktreesSubProvider {
 		const args = ['worktree', 'remove'];
 		if (options?.force) {
 			args.push('--force');
+			// Git requires a second `--force` to remove a locked worktree
+			if (options.force === 'locked') {
+				args.push('--force');
+			}
 		}
 
 		const pathStr = normalizePath(toFsPath(path));
@@ -163,7 +196,11 @@ export class WorktreesGitSubProvider implements GitWorktreesSubProvider {
 				ex as GitError,
 				reason =>
 					new WorktreeDeleteError(
-						{ reason: reason, gitCommand: { repoPath: repoPath, args: args } },
+						{
+							reason: reason,
+							lockReason: reason === 'locked' ? getLockReason(ex as GitError) : undefined,
+							gitCommand: { repoPath: repoPath, args: args },
+						},
 						ex as GitError,
 					),
 			);
@@ -226,4 +263,18 @@ export class WorktreesGitSubProvider implements GitWorktreesSubProvider {
 			}
 		}
 	}
+
+	@debug()
+	async unlockWorktree(repoPath: string, path: string | Uri): Promise<void> {
+		await this.git.ensureSupports(
+			'git:worktrees',
+			'Unlocking worktrees',
+			' Please install a more recent version of Git and try again.',
+		);
+
+		await this.git.run({ cwd: repoPath, errors: 'throw' }, 'worktree', 'unlock', normalizePath(toFsPath(path)));
+
+		this.context.hooks?.cache?.onReset?.(repoPath, 'worktrees');
+		this.context.hooks?.repository?.onChanged?.(repoPath, ['worktrees']);
+	}
 }

package/src/git-cli/service.ts

@@ -70,5 +70,14 @@ export function createCliGitService(options: CliGitServiceOptions): GitService {
 
 	service.register(provider, () => true);
 
+	// Advance the provider cache's status generation clock from the watch session's global events — the standalone
+	// analogue of what the VS Code host wires in `GitProviderService`. Without this, a consumer that passes a
+	// `watchingProvider` and drives watch sessions gets FS events but a FROZEN clock, so `dedupeByStatusGeneration`
+	// degrades to the pre-change/post-change stale-join this branch exists to fix. Standalone has no `Repository`
+	// models, so there are no force-fired `closed`/`lastFetched` bypassing the session for the global repo event to
+	// miss. Subscriptions are torn down with the service (its `watchService`'s emitters are disposed on dispose).
+	service.watchService?.onDidChangeWorkingTree(repoPath => provider.cache.onWorkingTreeChanged(repoPath));
+	service.watchService?.onDidChangeRepository(e => provider.cache.onRepositoryChanged(e.repoPath, e.changes));
+
 	return service;
 }

package/src/ipc/ipcServer.ts

@@ -35,7 +35,7 @@ export async function createIpcServer<Request = unknown, Response = void>(): Pro
 				resolve(new IpcServer(serverUrl, port, token, server));
 			});
 		} catch (ex) {
-			// eslint-disable-next-line @typescript-eslint/prefer-promise-reject-errors
+			// oxlint-disable-next-line typescript/prefer-promise-reject-errors
 			reject(ex);
 		}
 	});

package/src/plus/agents/providers/claudeCodeProvider.ts

@@ -29,6 +29,9 @@ import type {
 	PendingPermissionKind,
 	PermissionDecision,
 	PermissionSuggestion,
+	ResumableAgentSession,
+	ResumableSessionsOptions,
+	ResumableSessionsResult,
 } from '../types.js';
 import { getPhaseForStatus } from '../types.js';
 import { ClaudeCodeTranscriptReader } from './claudeCodeTranscript.js';
@@ -317,6 +320,28 @@ export class ClaudeCodeProvider implements AgentSessionProvider {
 		}
 	}
 
+	/** Reads past sessions out of Claude's transcript store. Claude homes each transcript under the
+	 *  directory encoding the session's current cwd (migrating it if the session `cd`s), so the
+	 *  directory for `cwd` is exactly what `claude --resume <id>` can find when invoked from there —
+	 *  every session returned is resumable from `cwd`. */
+	async listResumableSessions(cwd: string, options?: ResumableSessionsOptions): Promise<ResumableSessionsResult> {
+		const { sessions, total } = await this._transcriptReader.listSessions(cwd, {
+			limit: options?.limit,
+			excludeSessionIds: options?.excludeSessionIds,
+		});
+
+		const resumable = sessions.map<ResumableAgentSession>(s => ({
+			id: s.sessionId,
+			providerId: this.id,
+			cwd: cwd,
+			lastActivity: new Date(s.lastActivityMs),
+			titles: s.titles,
+			lastPrompt: s.lastPrompt,
+		}));
+
+		return { sessions: resumable, total: total };
+	}
+
 	dispose(): void {
 		this._disposed = true;
 		this.stop();

package/src/plus/agents/providers/claudeCodeTranscript.ts

@@ -1,7 +1,7 @@
 import { createReadStream } from 'fs';
-import { readdir, stat } from 'fs/promises';
+import { open, readdir, stat } from 'fs/promises';
 import { homedir } from 'os';
-import { join } from 'path';
+import { basename, join } from 'path';
 
 export interface TranscriptTitles {
 	custom?: string;
@@ -9,6 +9,27 @@ export interface TranscriptTitles {
 	agent?: string;
 }
 
+/** A transcript file discovered by {@link ClaudeCodeTranscriptReader.listSessions}, before its
+ *  contents are read — everything here comes from `readdir` + `stat`. */
+export interface TranscriptSessionEntry {
+	readonly sessionId: string;
+	readonly path: string;
+	readonly lastActivityMs: number;
+	readonly size: number;
+}
+
+/** A {@link TranscriptSessionEntry} enriched with the fields recovered from the file's head/tail. */
+export interface TranscriptSessionSummary extends TranscriptSessionEntry {
+	readonly titles: TranscriptTitles;
+	readonly lastPrompt?: string;
+}
+
+export interface TranscriptSessionListing {
+	readonly sessions: TranscriptSessionSummary[];
+	/** Every transcript in the directory, not just the summarized slice — drives "Showing N of M". */
+	readonly total: number;
+}
+
 interface CacheEntry {
 	path: string;
 	mtimeMs: number;
@@ -17,14 +38,40 @@ interface CacheEntry {
 	titles: TranscriptTitles;
 }
 
+interface ListingCacheEntry {
+	entries: TranscriptSessionEntry[];
+	resolvedAt: number;
+}
+
+interface SummaryCacheEntry {
+	mtimeMs: number;
+	size: number;
+	summary: TranscriptSessionSummary;
+}
+
 interface TitleEntry {
 	type: string;
 	sessionId?: string;
 	customTitle?: string;
 	aiTitle?: string;
 	agentName?: string;
+	lastPrompt?: string;
 }
 
+/** Bytes read from each end of a transcript when summarizing. Titles and prompts cluster at both
+ *  extremes, and files run to tens of MB, so reading whole files is not an option. */
+const summaryWindowSize = 64 * 1024;
+/** Listings are cheap (readdir + stat) but re-run per panel/sheet open; a short TTL absorbs bursts.
+ *  Time-based rather than dir-mtime-based because appends move file mtimes without touching the dir. */
+const listingCacheTtlMs = 10 * 1000;
+/** Summaries are keyed by session, and a busy project has hundreds — unlike the per-live-session
+ *  title cache, this needs a ceiling. */
+const summaryCacheLimit = 200;
+const defaultListLimit = 50;
+/** How far past `limit` the top-up scan may read when transcripts turn out empty — a junk-filled
+ *  store reads at most `limit + listScanSlack` summaries, staying well under {@link summaryCacheLimit}. */
+const listScanSlack = 25;
+
 /**
  * Reads Claude Code transcript JSONL files at `~/.claude/projects/<encoded-cwd>/<sessionId>.jsonl`
  * to surface `custom-title`, `ai-title`, and `agent-name` entries as fallback session names.
@@ -40,6 +87,9 @@ interface TitleEntry {
 export class ClaudeCodeTranscriptReader {
 	private readonly _cache = new Map<string, CacheEntry>();
 	private readonly _generations = new Map<string, number>();
+	private readonly _listings = new Map<string, ListingCacheEntry>();
+	/** Insertion-ordered LRU — re-inserted on hit, oldest key evicted past {@link summaryCacheLimit}. */
+	private readonly _summaries = new Map<string, SummaryCacheEntry>();
 	private _nextGen = 0;
 
 	async resolve(sessionId: string, cwd: string | undefined): Promise<TranscriptTitles | undefined> {
@@ -97,16 +147,233 @@ export class ClaudeCodeTranscriptReader {
 		this._generations.delete(sessionId);
 	}
 
+	/**
+	 * Lists the transcripts of sessions whose working directory is `cwd`, most-recently-active first,
+	 * summarizing until `limit` summarizable transcripts are found (bounded by a small scan slack) —
+	 * not just the first `limit` on disk, since junk transcripts (dropped below) would otherwise starve
+	 * the result. `excludeSessionIds` is skipped before `limit` applies, but excluded entries still
+	 * count toward `total`.
+	 *
+	 * Claude homes a transcript under the directory encoding the session's *current* cwd, migrating the
+	 * file if the session `cd`s — so this directory is exactly the set `claude --resume <id>` can find
+	 * when invoked from `cwd`, and every entry is resumable from there. The transcripts' own recorded
+	 * `cwd` is per-message and lags the move, so it must NOT be used to filter; the directory decides.
+	 *
+	 * Discovery (readdir + stat) covers the whole directory and is cheap; summarizing is not, so it's
+	 * capped. Entries whose summary yields neither a title nor a prompt are dropped — those are aborted
+	 * or empty transcripts with nothing to show or search on.
+	 */
+	async listSessions(
+		cwd: string,
+		options?: { limit?: number; excludeSessionIds?: ReadonlySet<string> },
+	): Promise<TranscriptSessionListing> {
+		const dir = await this.resolveProjectDir(cwd);
+		if (dir == null) return { sessions: [], total: 0 };
+
+		const entries = await this.listEntries(dir);
+		if (entries.length === 0) return { sessions: [], total: 0 };
+
+		const limit = options?.limit ?? defaultListLimit;
+		const exclude = options?.excludeSessionIds;
+		const candidates = exclude?.size ? entries.filter(e => !exclude.has(e.sessionId)) : entries;
+
+		const sessions: TranscriptSessionSummary[] = [];
+		const pushSummaries = (settled: PromiseSettledResult<TranscriptSessionSummary | undefined>[]): void => {
+			for (const result of settled) {
+				if (result.status !== 'fulfilled') continue;
+
+				const summary = result.value;
+				if (summary == null || !hasSummaryContent(summary)) continue;
+
+				sessions.push(summary);
+			}
+		};
+
+		// limit <= 0 means "no ceiling" — summarize every candidate.
+		if (limit <= 0) {
+			pushSummaries(await Promise.allSettled(candidates.map(e => this.resolveSummary(e))));
+			return { sessions: sessions, total: entries.length };
+		}
+
+		const ceiling = Math.min(candidates.length, limit + listScanSlack);
+		let cursor = 0;
+		while (sessions.length < limit && cursor < ceiling) {
+			// Clamped to the remaining ceiling budget too — a run of junk entries must not let a
+			// need-sized batch read past `limit + listScanSlack`.
+			const batch = candidates.slice(cursor, cursor + Math.min(limit - sessions.length, ceiling - cursor));
+			cursor += batch.length;
+			pushSummaries(await Promise.allSettled(batch.map(e => this.resolveSummary(e))));
+		}
+
+		return { sessions: sessions, total: entries.length };
+	}
+
+	/** Discovers every transcript in `dir`, newest first. The directory also holds one sibling
+	 *  subdirectory per session (`<uuid>/subagents`, `<uuid>/tool-results`), so entries must be filtered
+	 *  to files — a busy project has roughly as many subdirectories as transcripts. */
+	private async listEntries(dir: string): Promise<TranscriptSessionEntry[]> {
+		const cached = this._listings.get(dir);
+		if (cached != null && Date.now() - cached.resolvedAt < listingCacheTtlMs) return cached.entries;
+
+		let names: string[];
+		try {
+			const dirents = await readdir(dir, { withFileTypes: true });
+			names = dirents.filter(d => d.isFile() && d.name.endsWith('.jsonl')).map(d => d.name);
+		} catch {
+			return [];
+		}
+
+		const settled = await Promise.allSettled(
+			names.map(async (name): Promise<TranscriptSessionEntry> => {
+				const path = join(dir, name);
+				const stats = await stat(path);
+				return {
+					sessionId: basename(name, '.jsonl'),
+					path: path,
+					lastActivityMs: stats.mtimeMs,
+					size: stats.size,
+				};
+			}),
+		);
+
+		const entries = settled
+			.filter(r => r.status === 'fulfilled')
+			.map(r => r.value)
+			.sort((a, b) => b.lastActivityMs - a.lastActivityMs);
+
+		this._listings.set(dir, { entries: entries, resolvedAt: Date.now() });
+		return entries;
+	}
+
+	/** Summarizes one transcript, reusing the cached result while its mtime and size are unchanged. */
+	private async resolveSummary(entry: TranscriptSessionEntry): Promise<TranscriptSessionSummary | undefined> {
+		const cached = this._summaries.get(entry.sessionId);
+		if (cached != null && cached.mtimeMs === entry.lastActivityMs && cached.size === entry.size) {
+			// Refresh recency for the LRU.
+			this._summaries.delete(entry.sessionId);
+			this._summaries.set(entry.sessionId, cached);
+			return cached.summary;
+		}
+
+		let summary: TranscriptSessionSummary;
+		try {
+			summary = await this.readSummary(entry);
+		} catch {
+			return undefined;
+		}
+
+		this._summaries.set(entry.sessionId, {
+			mtimeMs: entry.lastActivityMs,
+			size: entry.size,
+			summary: summary,
+		});
+		if (this._summaries.size > summaryCacheLimit) {
+			const oldest = this._summaries.keys().next();
+			if (!oldest.done) {
+				this._summaries.delete(oldest.value);
+			}
+		}
+		return summary;
+	}
+
+	/**
+	 * Reads a summary from the first and last {@link summaryWindowSize} bytes of the transcript.
+	 *
+	 * Deliberately does not reuse `resolve` — that scans from the last-read offset and buffers the whole
+	 * range, which for a cold multi-MB transcript means loading the entire file. Titles are written early
+	 * and re-written as they're refined, while prompts land at the tail, so the two windows recover both
+	 * at a fraction of the bytes. The tail is parsed second so the newest value wins.
+	 */
+	protected async readSummary(entry: TranscriptSessionEntry): Promise<TranscriptSessionSummary> {
+		const titles: TranscriptTitles = {};
+		let lastPrompt: string | undefined;
+
+		const apply = (buffer: Buffer, dropPartialFirstLine: boolean): void => {
+			const text = buffer.toString('utf8');
+			const lines = text.split('\n');
+			// A window starting mid-file almost always opens mid-line; that fragment can't be parsed.
+			if (dropPartialFirstLine) {
+				lines.shift();
+			}
+			for (const line of lines) {
+				const parsed = parseSummaryLine(line, entry.sessionId);
+				if (parsed == null) continue;
+
+				applyTitleEntry(parsed, titles);
+				if (parsed.lastPrompt != null && parsed.lastPrompt.length > 0) {
+					lastPrompt = parsed.lastPrompt;
+				}
+			}
+		};
+
+		const handle = await open(entry.path, 'r');
+		try {
+			if (entry.size <= summaryWindowSize * 2) {
+				const whole = Buffer.alloc(entry.size);
+				await handle.read(whole, 0, entry.size, 0);
+				apply(whole, false);
+			} else {
+				const head = Buffer.alloc(summaryWindowSize);
+				await handle.read(head, 0, summaryWindowSize, 0);
+				apply(head, false);
+
+				const tail = Buffer.alloc(summaryWindowSize);
+				await handle.read(tail, 0, summaryWindowSize, entry.size - summaryWindowSize);
+				apply(tail, true);
+			}
+		} finally {
+			await handle.close();
+		}
+
+		return {
+			...entry,
+			titles: titles,
+			lastPrompt: lastPrompt,
+		};
+	}
+
+	protected getProjectsRoot(): string {
+		return join(homedir(), '.claude', 'projects');
+	}
+
+	/** Resolves the `~/.claude/projects` directory holding the sessions whose working directory is
+	 *  `cwd`, or `undefined` when none exists. Falls back to a case-insensitive name match because on
+	 *  Windows our
+	 *  paths carry a lower-cased drive letter (`normalizePath`) while Claude encodes the OS-native
+	 *  `C:\...` — so the exact name never matches by case. */
+	protected async resolveProjectDir(cwd: string | undefined): Promise<string | undefined> {
+		if (cwd == null || cwd.length === 0) return undefined;
+
+		const root = this.getProjectsRoot();
+		const encoded = encodeProjectDirName(cwd);
+
+		const exact = join(root, encoded);
+		if (await directoryExists(exact)) return exact;
+
+		let dirs: string[];
+		try {
+			dirs = await readdir(root);
+		} catch {
+			return undefined;
+		}
+
+		const lowered = encoded.toLowerCase();
+		const match = dirs.find(d => d !== encoded && d.toLowerCase() === lowered);
+		return match != null ? join(root, match) : undefined;
+	}
+
 	protected async locateTranscript(sessionId: string, cwd: string | undefined): Promise<string | undefined> {
-		const root = join(homedir(), '.claude', 'projects');
 		const fileName = `${sessionId}.jsonl`;
 
-		if (cwd != null && cwd.length > 0) {
-			const encoded = cwd.replace(/[/\\:]/g, '-');
-			const candidate = join(root, encoded, fileName);
+		const dir = await this.resolveProjectDir(cwd);
+		if (dir != null) {
+			const candidate = join(dir, fileName);
 			if (await fileExists(candidate)) return candidate;
 		}
 
+		// The recorded cwd drifts whenever the agent `cd`s, so it can encode to a directory the session
+		// doesn't actually live in — scan every project for the file as a last resort.
+		const root = this.getProjectsRoot();
 		let dirs: string[];
 		try {
 			dirs = await readdir(root);
@@ -115,8 +382,8 @@ export class ClaudeCodeTranscriptReader {
 		}
 
 		const candidates = await Promise.all(
-			dirs.map(async dir => {
-				const candidate = join(root, dir, fileName);
+			dirs.map(async d => {
+				const candidate = join(root, d, fileName);
 				return (await fileExists(candidate)) ? candidate : undefined;
 			}),
 		);
@@ -170,6 +437,27 @@ function applyTitleLine(line: string, sessionId: string, titles: TranscriptTitle
 	}
 	if (entry.sessionId != null && entry.sessionId !== sessionId) return;
 
+	applyTitleEntry(entry, titles);
+}
+
+/** Parses one transcript line for {@link ClaudeCodeTranscriptReader.readSummary}, rejecting entries
+ *  that belong to another session. Can't use the `-title` prefilter that {@link isLikelyTitleLine}
+ *  applies: `last-prompt` matches neither of its markers. */
+function parseSummaryLine(line: string, sessionId: string): TitleEntry | undefined {
+	if (line.length === 0 || !line.includes('"type"')) return undefined;
+
+	let entry: TitleEntry;
+	try {
+		entry = JSON.parse(line) as TitleEntry;
+	} catch {
+		return undefined;
+	}
+	if (entry.sessionId != null && entry.sessionId !== sessionId) return undefined;
+
+	return entry;
+}
+
+function applyTitleEntry(entry: TitleEntry, titles: TranscriptTitles): void {
 	switch (entry.type) {
 		case 'custom-title':
 			if (typeof entry.customTitle === 'string' && entry.customTitle.length > 0) {
@@ -189,11 +477,26 @@ function applyTitleLine(line: string, sessionId: string, titles: TranscriptTitle
 	}
 }
 
+/** Encodes a working directory into its `~/.claude/projects` directory name. Claude replaces every
+ *  non-alphanumeric character — not just separators — preserving runs (`/home/e/.claude` →
+ *  `-home-e--claude`) and case. Separators-only would leave the dot in our own worktree convention
+ *  (`<repo>.worktrees/<name>`) intact and compute a directory that never exists. */
+export function encodeProjectDirName(cwd: string): string {
+	return cwd.replace(/[^a-zA-Z0-9]/g, '-');
+}
+
 function isLikelyTitleLine(line: string): boolean {
 	if (!line.includes('"type"')) return false;
 	return line.includes('-title') || line.includes('agent-name');
 }
 
+/** A transcript with no title and no prompt is an aborted or empty session — nothing to name it by,
+ *  nothing to search it on. */
+function hasSummaryContent(summary: TranscriptSessionSummary): boolean {
+	const { custom, ai, agent } = summary.titles;
+	return custom != null || ai != null || agent != null || summary.lastPrompt != null;
+}
+
 async function fileExists(path: string): Promise<boolean> {
 	try {
 		const stats = await stat(path);
@@ -203,6 +506,15 @@ async function fileExists(path: string): Promise<boolean> {
 	}
 }
 
+async function directoryExists(path: string): Promise<boolean> {
+	try {
+		const stats = await stat(path);
+		return stats.isDirectory();
+	} catch {
+		return false;
+	}
+}
+
 function readSlice(path: string, start: number, end: number): Promise<Buffer> {
 	return new Promise((resolve, reject) => {
 		const chunks: Buffer[] = [];

package/src/plus/agents/types.ts

@@ -233,6 +233,40 @@ export interface AgentSessionProvider extends UnifiedDisposable {
 	 *  `vscode.openFolder` and relies on VS Code's window-folder matching to focus the owning
 	 *  window (which works whether or not the peer runs GitLens). */
 	notifyPeerOpenSession?(workspacePath: string, sessionId: string): Promise<boolean>;
+
+	/** Lists past sessions that can be resumed from `cwd`, most-recently-active first. Omitted by
+	 *  providers with no durable per-directory session store to read. Live sessions are excluded by
+	 *  the caller, not here — this reports what the store holds. The caller may also pass its live
+	 *  set via {@link ResumableSessionsOptions.excludeSessionIds} so exclusion happens before `limit`
+	 *  applies rather than after. */
+	listResumableSessions?(cwd: string, options?: ResumableSessionsOptions): Promise<ResumableSessionsResult>;
+}
+
+export interface ResumableSessionsOptions {
+	/** How many sessions to detail. Discovery covers the whole store; only this many are read. */
+	readonly limit?: number;
+	/** Session ids to skip before `limit` applies — typically the caller's live sessions.
+	 *  Excluded entries still count toward `total`. */
+	readonly excludeSessionIds?: ReadonlySet<string>;
+}
+
+/** A session that is no longer running but whose transcript survives, so it can be resumed. */
+export interface ResumableAgentSession {
+	readonly id: string;
+	readonly providerId: string;
+	/** The directory the session must be resumed from — resolving it is the store's whole job. */
+	readonly cwd: string;
+	readonly lastActivity: Date;
+	/** Mirrors {@link AgentSession.transcriptTitles} — kept unresolved so naming stays the display
+	 *  cascade's job rather than being decided here. */
+	readonly titles?: { readonly custom?: string; readonly ai?: string; readonly agent?: string };
+	readonly lastPrompt?: string;
+}
+
+export interface ResumableSessionsResult {
+	readonly sessions: ResumableAgentSession[];
+	/** Everything the store holds for `cwd`, not just the detailed slice — drives "Showing N of M". */
+	readonly total: number;
 }
 
 /**

package/src/plus/ai/constants.ts

@@ -5,7 +5,6 @@ export type AIProviders =
 	| 'azure'
 	| 'deepseek'
 	| 'gemini'
-	| 'github'
 	| 'gitkraken'
 	| 'huggingface'
 	| 'mistral'
@@ -87,14 +86,7 @@ export const deepSeekProviderDescriptor: AIProviderDescriptor<'deepseek'> = {
 } as const;
 export const xAIProviderDescriptor: AIProviderDescriptor<'xai'> = {
 	id: 'xai',
-	name: 'xAI',
-	primary: false,
-	requiresAccount: true,
-	requiresUserKey: true,
-} as const;
-export const githubProviderDescriptor: AIProviderDescriptor<'github'> = {
-	id: 'github',
-	name: 'GitHub Models',
+	name: 'SpaceXAI',
 	primary: false,
 	requiresAccount: true,
 	requiresUserKey: true,