@gitkraken/core-gitlens 0.6.0 → 0.7.0

package/src/ipc/discovery.ts

@@ -1,186 +0,0 @@
-import { mkdir, readdir, readFile, unlink, writeFile } from 'fs/promises';
-import { tmpdir } from 'os';
-import { join } from 'path';
-import { kill, ppid } from 'process';
-
-/**
- * Directory scanned by `gk` binaries (and `@gitkraken/core-gitlens` consumers) for the
- * extension's CLI-capable IPC server discovery file. Anything written here is assumed
- * by older `gk` versions to be a CLI server — do NOT write agent-only files here.
- */
-export const cliDiscoveryDir = join(tmpdir(), 'gitkraken', 'gitlens');
-
-/**
- * Directory scanned by peer GitLens windows for agent-session-capable IPC servers.
- * Stable across GitLens versions; older windows still scan it, so don't move it.
- */
-export const agentDiscoveryDir = join(tmpdir(), 'gitkraken', 'gitlens', 'agents');
-
-export interface IpcDiscoveryData {
-	token: string;
-	address: string;
-	port: number;
-	workspacePaths: string[];
-	// Optional fields — present when the writing capability needs them.
-	// Old gk binaries ignore unknown fields, so this stays back-compat.
-	ideName?: string;
-	ideDisplayName?: string;
-	scheme?: string;
-	pid?: number;
-	createdAt: string;
-}
-
-export function getDiscoveryFileName(port: number): string {
-	return `gitlens-ipc-server-${ppid}-${port}.json`;
-}
-
-const discoveryFileNameRegex = /^gitlens-ipc-server-(\d+)-(\d+)\.json$/;
-
-/** Parses a discovery file name back into its `ppid`/`port` parts; returns `undefined` if it doesn't match. */
-export function parseDiscoveryFileName(name: string): { ppid: number; port: number } | undefined {
-	const match = discoveryFileNameRegex.exec(name);
-	if (match == null) return undefined;
-
-	return { ppid: Number(match[1]), port: Number(match[2]) };
-}
-
-export function getDiscoveryFilePath(dir: string, port: number): string {
-	return join(dir, getDiscoveryFileName(port));
-}
-
-export async function writeDiscoveryFile(dir: string, data: IpcDiscoveryData): Promise<string> {
-	const filePath = getDiscoveryFilePath(dir, data.port);
-	await mkdir(dir, { recursive: true, mode: 0o700 });
-	await writeFile(filePath, JSON.stringify(data, null, 2), { mode: 0o600 });
-	return filePath;
-}
-
-export async function cleanupDiscoveryFile(filePath: string | undefined): Promise<void> {
-	if (filePath == null) return;
-
-	try {
-		await unlink(filePath);
-	} catch {
-		// Ignore cleanup errors
-	}
-}
-
-export interface SweepDiscoveryFilesOptions {
-	/** Ports to never touch (e.g. our own live server). */
-	excludePorts?: number[];
-	/** Absolute file paths to never touch (e.g. our own files). */
-	excludePaths?: string[];
-}
-
-/**
- * Best-effort sweep of orphaned discovery files left by processes that crashed or were
- * hard-killed without cleaning up. Reachability is the source of truth: a file is removed
- * only when its owning process is provably gone (pid reports `ESRCH`) or its server is
- * unreachable (the probe fails with anything other than a timeout). Anything reachable — or
- * ambiguous (timeouts, parse errors) — is kept, so a live peer's file is never deleted.
- */
-export async function sweepStaleDiscoveryFiles(
-	dirs: string[],
-	options?: SweepDiscoveryFilesOptions,
-): Promise<{ scanned: number; pruned: number }> {
-	const excludePorts = options?.excludePorts;
-	const excludePaths = options?.excludePaths;
-
-	let scanned = 0;
-	let pruned = 0;
-
-	for (const dir of dirs) {
-		let names: string[];
-		try {
-			names = await readdir(dir);
-		} catch {
-			// Dir doesn't exist yet (nothing ever published here) — nothing to sweep.
-			continue;
-		}
-
-		const candidates: string[] = [];
-		for (const name of names) {
-			const parsed = parseDiscoveryFileName(name);
-			if (parsed == null) continue;
-			if (excludePorts?.includes(parsed.port)) continue;
-
-			const filePath = join(dir, name);
-			if (excludePaths?.includes(filePath)) continue;
-
-			candidates.push(filePath);
-		}
-
-		scanned += candidates.length;
-
-		const results = await Promise.allSettled(
-			candidates.map(async filePath => {
-				if (await isDiscoveryFileStale(filePath)) {
-					await cleanupDiscoveryFile(filePath);
-					return true;
-				}
-				return false;
-			}),
-		);
-
-		for (const r of results) {
-			if (r.status === 'fulfilled' && r.value) {
-				pruned++;
-			}
-		}
-	}
-
-	return { scanned: scanned, pruned: pruned };
-}
-
-/** Returns true only when the file's server is provably gone (dead pid or unreachable server). */
-async function isDiscoveryFileStale(filePath: string): Promise<boolean> {
-	let data: IpcDiscoveryData;
-	try {
-		data = JSON.parse(await readFile(filePath, 'utf8')) as IpcDiscoveryData;
-	} catch {
-		// Can't read/parse — don't delete files we don't understand.
-		return false;
-	}
-
-	// Cheap short-circuit: if the owning process is gone, the file is orphaned.
-	if (data.pid != null && !isProcessAlive(data.pid)) return true;
-
-	// Otherwise reachability is the source of truth.
-	if (!data.address) return false;
-
-	try {
-		await fetch(`${data.address}/ping`, { signal: AbortSignal.timeout(1000) });
-		// Any HTTP response (even 401/404) means a server is listening — keep.
-		return false;
-	} catch (ex) {
-		// A timeout is ambiguous — the server may be alive but slow to answer — so keep. Any other
-		// failure (connection refused, reset, host unreachable, bad address) means nothing is
-		// serving on that localhost port, so the file is stale. A healthy local server always
-		// answers near-instantly, so this never deletes a reachable peer.
-		return !isTimeoutError(ex);
-	}
-}
-
-function isProcessAlive(pid: number): boolean {
-	// `kill(0, ...)` / `kill(<negative>, ...)` have process-group semantics and don't probe a
-	// specific pid, so a malformed pid (from a foreign or corrupt file) can't prove death — treat
-	// it as inconclusive so the sweep falls through to the reachability probe rather than deleting
-	// on a bad pid. (Note: the agents session-card tracker's `isProcessAlive` biases the opposite
-	// way — toward dead — because expiring a live card there is harmless; deleting a live file is
-	// not, so this copy intentionally keeps on uncertainty.)
-	if (!Number.isInteger(pid) || pid <= 0) return true;
-
-	try {
-		kill(pid, 0);
-		return true;
-	} catch (ex) {
-		// ESRCH → no such process (dead). EPERM/EACCES → exists but not ours (alive). Anything
-		// else is inconclusive → treat as alive so we never delete a file on uncertainty.
-		return (ex as NodeJS.ErrnoException | null)?.code !== 'ESRCH';
-	}
-}
-
-function isTimeoutError(ex: unknown): boolean {
-	// `AbortSignal.timeout` rejects with a `TimeoutError`; a bare abort yields an `AbortError`.
-	return ex instanceof Error && (ex.name === 'TimeoutError' || ex.name === 'AbortError');
-}

package/src/ipc/ipcServer.ts

@@ -1,171 +0,0 @@
-import type { IncomingMessage, Server, ServerResponse } from 'http';
-import { createServer } from 'http';
-import { uuid } from '../utils/crypto.js';
-import { debug } from '../utils/decorators/log.js';
-import type { UnifiedDisposable } from '../utils/disposable.js';
-import { createDisposable } from '../utils/disposable.js';
-import { Logger } from '../utils/logger.js';
-import { getScopedLogger } from '../utils/logger.scoped.js';
-
-export interface IpcHandler<Request = unknown, Response = void> {
-	(request: Request | undefined, searchParams: URLSearchParams): Promise<Response>;
-}
-
-export async function createIpcServer<Request = unknown, Response = void>(): Promise<IpcServer<Request, Response>> {
-	const server = createServer();
-	const token = uuid();
-
-	return new Promise<IpcServer<Request, Response>>((resolve, reject) => {
-		try {
-			server.on('error', ex => {
-				Logger.error(ex, 'IPC server error');
-				reject(ex);
-			});
-
-			// Let the OS assign an available port by listening on port 0
-			server.listen(0, '127.0.0.1', () => {
-				const address = server.address();
-				if (address == null || typeof address === 'string') {
-					reject(new Error('Failed to get server address'));
-					return;
-				}
-
-				const port = address.port;
-				const serverUrl = `http://127.0.0.1:${port}`;
-				resolve(new IpcServer(serverUrl, port, token, server));
-			});
-		} catch (ex) {
-			// oxlint-disable-next-line typescript/prefer-promise-reject-errors
-			reject(ex);
-		}
-	});
-}
-
-export class IpcServer<Request = unknown, Response = void> implements UnifiedDisposable {
-	private readonly handlers = new Map<string | undefined, IpcHandler<Request, Response>>();
-
-	constructor(
-		readonly ipcAddress: string,
-		readonly ipcPort: number,
-		readonly ipcToken: string,
-		private server: Server,
-	) {
-		server
-			.on('listening', () => {
-				Logger.trace(`IPC server listening on ${this.ipcAddress}`);
-			})
-			.on('request', this.onRequest.bind(this));
-	}
-
-	dispose(): void {
-		this.handlers.clear();
-		this.server.close();
-	}
-
-	[Symbol.dispose](): void {
-		this.dispose();
-	}
-
-	// Awaits server close; use only when deterministic teardown is required (e.g., tests).
-	// Production callers should use dispose() — UnifiedDisposable contract is sync.
-	shutdown(): Promise<void> {
-		this.handlers.clear();
-		return new Promise<void>(resolve => {
-			this.server.close(() => resolve());
-		});
-	}
-
-	registerHandler(name: string, handler: IpcHandler<Request, Response>): UnifiedDisposable {
-		const path = `/${name}`;
-		if (this.handlers.has(path)) {
-			throw new Error(`IPC handler '${name}' is already registered`);
-		}
-
-		this.handlers.set(path, handler);
-		return createDisposable(() => this.handlers.delete(path));
-	}
-
-	@debug({ args: false })
-	private onRequest(req: IncomingMessage, res: ServerResponse): void {
-		const scope = getScopedLogger();
-
-		// Parse URL to extract pathname for routing and query parameters
-		let pathname: string | undefined;
-		let searchParams = new URLSearchParams();
-		try {
-			const url = new URL(req.url ?? '', this.ipcAddress);
-			pathname = url.pathname;
-			searchParams = url.searchParams;
-		} catch {
-			pathname = req.url;
-		}
-
-		const handler = this.handlers.get(pathname);
-		if (handler == null) {
-			scope?.warn(`IPC handler for ${pathname} not found`);
-			res.writeHead(404);
-			res.end();
-			return;
-		}
-
-		// Add bearer token authorization
-		const authHeader = req.headers['authorization'];
-		if (authHeader !== `Bearer ${this.ipcToken}`) {
-			Logger.warn(scope, `IPC handler for ${req.url} unauthorized`);
-			res.writeHead(401);
-			res.end();
-			return;
-		}
-
-		const maxBodySize = 10_485_760; // 10 MB
-		let bodySize = 0;
-		const chunks: Uint8Array[] = [];
-		req.on('data', (d: Uint8Array) => {
-			bodySize += d.length;
-			if (bodySize > maxBodySize) {
-				res.writeHead(413);
-				res.end();
-				req.destroy();
-				return;
-			}
-
-			chunks.push(d);
-		});
-		req.on('end', async () => {
-			if (bodySize > maxBodySize) return;
-
-			const body = Buffer.concat(chunks).toString('utf8');
-
-			let data: Request | undefined;
-			try {
-				data = body ? (JSON.parse(body) as Request) : undefined;
-			} catch (ex) {
-				scope?.error(ex, 'Invalid JSON in IPC request body', { body: body });
-				res.writeHead(400);
-				res.end('Invalid JSON');
-				return;
-			}
-
-			try {
-				const result = await handler(data, searchParams);
-				if (result == null) {
-					res.writeHead(200);
-					res.end();
-					return;
-				}
-
-				if (typeof result === 'string') {
-					res.writeHead(200);
-					res.end(result);
-				} else {
-					res.writeHead(200);
-					res.end(JSON.stringify(result));
-				}
-			} catch (ex) {
-				scope?.error(ex, 'IPC handler error', data);
-				res.writeHead(500);
-				res.end();
-			}
-		});
-	}
-}

package/src/plus/agents/agentCapabilities.ts

@@ -1,286 +0,0 @@
-import type { AgentHookEvent } from './types.js';
-import { canonicalBlockingHookEvents, canonicalNonBlockingHookEvents } from './types.js';
-
-/** `gk ai hook` client id — the id the GitKraken CLI stamps onto every relayed hook event. NOT
- *  the same namespace as {@link AgentProviderId}. */
-export type AgentHookClientId = 'claude-code' | 'codex' | 'copilot' | 'opencode';
-
-/** GitLens session provider id — what lands on `AgentSession.providerId` and in telemetry. NOT
- *  the same namespace as {@link AgentHookClientId}. */
-export type AgentProviderId = 'claudeCode' | 'codex' | 'copilot' | 'opencode';
-
-/** Icon-font glyph name used to badge the agent in the UI. Every member must name a `ThemeIcon` id
- *  that actually exists: either a codicon glyph name (`codicons-map.ts` is generated from VS Code's
- *  own font, so it isn't ours to extend) or a GitLens-contributed `gitlens-*` id from the `glicons`
- *  font, built from SVGs in `images/icons/`. An agent with no mark of its own uses `robot` — a name
- *  with no glyph renders as tofu, it does not fall back. */
-export type AgentIconName = 'claude' | 'openai' | 'copilot' | 'gitlens-provider-opencode' | 'robot';
-
-/**
- * Flat, data-only description of one supported `gk ai hook` client. Mirrors how the GitKraken CLI
- * models its own clients (`internal/actions/aihook/events.json` + `registry.go`) so the two stay
- * comparable: the CLI relays each agent's native event and tool names verbatim, and this table is
- * what translates them into the canonical (Claude Code) vocabulary.
- */
-export interface AgentCapabilities {
-	/** The `gk ai hook` client id events arrive stamped with. */
-	readonly hookClientId: AgentHookClientId;
-	/** The GitLens session provider id — see {@link AgentProviderId}. */
-	readonly providerId: AgentProviderId;
-	readonly displayName: string;
-	readonly icon: AgentIconName;
-
-	/** Native event name → canonical event. Omitted when the agent's native names are already
-	 *  canonical. */
-	readonly eventMap?: Readonly<Record<string, AgentHookEvent>>;
-	/** Escape hatch for the cases where the native event name alone can't determine the canonical
-	 *  event and the payload has to be consulted. Tried BEFORE {@link eventMap}; returning
-	 *  `undefined` falls through to it. `hookInput` is the ROOT of the JSON the agent piped to
-	 *  `gk ai hook run` (what the CLI relays verbatim as `hookInput`), not a pre-unwrapped payload —
-	 *  navigate the agent's own nesting from there. */
-	readonly resolveEvent?: (
-		nativeEvent: string,
-		hookInput: Record<string, unknown> | undefined,
-	) => AgentHookEvent | undefined;
-	/** Native tool name → canonical (Claude Code) tool name. Omitted when already canonical. */
-	readonly toolNameMap?: Readonly<Record<string, string>>;
-
-	/** Native event names to register as non-blocking hooks at install time. `undefined` means
-	 *  "pass no event flags and let `gk` apply its own per-client defaults". */
-	readonly installEvents?: readonly string[];
-	/** Native event names to register as blocking hooks at install time. `undefined` means
-	 *  "pass no event flags and let `gk` apply its own per-client defaults". */
-	readonly installBlockingEvents?: readonly string[];
-
-	/** The agent can be installed with blocking hooks, so GitLens can answer a permission ask. */
-	readonly supportsBlockingPermissions: boolean;
-	/** The agent writes an on-disk transcript GitLens can tail for titles/prompts. */
-	readonly supportsTranscripts: boolean;
-	/** A past session can be resumed from its cwd. */
-	readonly supportsResume: boolean;
-	/** The agent multiplexes concurrent sessions in one process, so a pid does not identify a
-	 *  session (matches the CLI's `pidSharingClients`). */
-	readonly sharesPids: boolean;
-
-	/** Extra step the agent's own host requires before installed hooks will actually fire. Undefined
-	 *  when installing is sufficient. Not a computed state — we cannot detect whether the step has been
-	 *  done, so consumers surface this unconditionally whenever hooks are installed. */
-	readonly manualActivation?: string;
-}
-
-const canonicalHookEvents = new Set<string>([...canonicalNonBlockingHookEvents, ...canonicalBlockingHookEvents]);
-
-function asRecord(value: unknown): Record<string, unknown> | undefined {
-	return typeof value === 'object' && value != null ? (value as Record<string, unknown>) : undefined;
-}
-
-function isCanonicalHookEvent(event: string): event is AgentHookEvent {
-	return canonicalHookEvents.has(event);
-}
-
-/** Claude Code's install set: its full native vocabulary minus the worktree events, which the CLI
- *  also skips by default (`skippedDefaultEvents` in its `events.json`) and GitLens has no use for. */
-const claudeCodeInstallEvents: readonly AgentHookEvent[] = canonicalNonBlockingHookEvents.filter(
-	e => e !== 'WorktreeCreate' && e !== 'WorktreeRemove',
-);
-
-/** Exported because Claude Code is the wire default: an event with no `providerId` comes from a CLI
- *  too old to stamp one, which predates every other client. */
-export const claudeCodeCapabilities: AgentCapabilities = {
-	hookClientId: 'claude-code',
-	providerId: 'claudeCode',
-	displayName: 'Claude Code',
-	icon: 'claude',
-	// No `eventMap`/`toolNameMap` — Claude Code's vocabulary IS the canonical one.
-	installEvents: claudeCodeInstallEvents,
-	installBlockingEvents: canonicalBlockingHookEvents,
-	supportsBlockingPermissions: true,
-	supportsTranscripts: true,
-	supportsResume: true,
-	sharesPids: false,
-};
-
-const codexCapabilities: AgentCapabilities = {
-	hookClientId: 'codex',
-	providerId: 'codex',
-	displayName: 'Codex',
-	icon: 'openai',
-	// No `eventMap` — Codex emits canonical event names already.
-	toolNameMap: {
-		apply_patch: 'Edit',
-		// `update_plan` is deliberately NOT mapped to `ExitPlanMode`: it's a todo-list update, not a
-		// plan-approval ask, and mapping it would classify routine progress as a permission prompt.
-		// Left unmapped so it falls through to the generic tool path.
-	},
-	// `undefined` install sets: let `gk` apply its per-client defaults for now. Blocking permissions
-	// are supported by the client but not requested until a later phase.
-	supportsBlockingPermissions: true,
-	supportsTranscripts: false,
-	supportsResume: false,
-	// The CLI lists codex in `pidSharingClients` — it multiplexes sessions in one process.
-	sharesPids: true,
-	// Verified empirically, not speculative: running an identical Codex session with
-	// `--dangerously-bypass-hook-trust` fires the installed hooks immediately (a session record
-	// appears); without that flag, zero records — Codex silently refuses to run command hooks it
-	// hasn't trusted yet, with no log line or warning of any kind. Trust is granted via `/hooks`
-	// inside interactive Codex and is bound to the hook's hash, so a reinstall invalidates it. There
-	// is no known way to detect trust state from outside Codex, so this hint is unconditional.
-	manualActivation:
-		"Codex won't run these hooks until you trust them — run `/hooks` in Codex. You'll need to trust them again if the hooks are reinstalled.",
-};
-
-const copilotCapabilities: AgentCapabilities = {
-	hookClientId: 'copilot',
-	providerId: 'copilot',
-	displayName: 'GitHub Copilot CLI',
-	icon: 'copilot',
-	eventMap: {
-		// Copilot's event names are otherwise canonical; `ErrorOccurred` is the one with no canonical
-		// equivalent, so it maps onto Claude's turn-ended-in-error event (which derives to `idle`).
-		ErrorOccurred: 'StopFailure',
-	},
-	// Copilot's own documented tool alias table.
-	toolNameMap: {
-		bash: 'Bash',
-		// `powershell` is deliberately absent. Aliasing it to `Bash` would only be worth the lost
-		// label fidelity (a PowerShell call rendering as `Bash(...)`) if it bought the command detail
-		// `describeToolInput` extracts for shells — and it can't: Copilot relays its args as
-		// `hookInput.toolInput` (camelCase), a key nothing here reads, so no tool input reaches us at
-		// all. Pure label loss today; revisit if Copilot's tool inputs ever become readable.
-		view: 'Read',
-		create: 'Write',
-		edit: 'Edit',
-		str_replace_editor: 'Edit',
-		apply_patch: 'Edit',
-		grep: 'Grep',
-		rg: 'Grep',
-		glob: 'Glob',
-		web_fetch: 'WebFetch',
-		web_search: 'WebSearch',
-		ask_user: 'AskUserQuestion',
-	},
-	supportsBlockingPermissions: true,
-	supportsTranscripts: false,
-	supportsResume: false,
-	sharesPids: false,
-};
-
-/** Reads the status type out of an OpenCode `session.status` hook input. The CLI's generated
- *  OpenCode plugin nests the raw SDK event under `hook_payload.event` (`buildHookInput` sets
- *  `hook_payload: payload`, and the generic event hook passes `{ event }`), so the full path from
- *  the hook-input root is `hook_payload.event.properties.status.type`. The payload is untyped JSON,
- *  so every hop is checked rather than cast. */
-function getOpenCodeSessionStatusType(hookInput: Record<string, unknown> | undefined): string | undefined {
-	const hookPayload = asRecord(hookInput?.hook_payload);
-	const event = asRecord(hookPayload?.event);
-	const properties = asRecord(event?.properties);
-	const status = asRecord(properties?.status);
-	const type = status?.type;
-
-	return typeof type === 'string' ? type : undefined;
-}
-
-const openCodeCapabilities: AgentCapabilities = {
-	hookClientId: 'opencode',
-	providerId: 'opencode',
-	displayName: 'OpenCode',
-	icon: 'gitlens-provider-opencode',
-	eventMap: {
-		'session.created': 'SessionStart',
-		'session.deleted': 'SessionEnd',
-		// `session.idle` is deprecated in OpenCode's own source in favor of `session.status`, which is
-		// why both are handled — older builds still emit it.
-		'session.idle': 'Stop',
-		'session.error': 'StopFailure',
-		'session.compacted': 'PostCompact',
-		'permission.asked': 'PermissionRequest',
-		'permission.replied': 'ElicitationResult',
-		'tool.execute.before': 'PreToolUse',
-		'tool.execute.after': 'PostToolUse',
-		// `session.updated` is intentionally absent — it has no canonical analogue.
-		// `session.status` is resolved by `resolveEvent` below, since its meaning is in the payload.
-	},
-	// Only `idle` resolves. `busy` is deliberately unmapped, and so is everything else (`retry`
-	// included): the canonical event this returns doesn't just pick a status, it selects a branch of
-	// the provider's state-machine switch, so a mapping inherits that event's ENTIRE handler. Naming
-	// `PostToolUse` here would also clear a pending permission ask, decrement the parallel-tool
-	// refcount, and schedule file decorations away — all wrong for a tick OpenCode emits
-	// independently of any tool lifecycle, and the ask-clearing is visibly wrong (the agent is still
-	// blocked on it). There is no tool-free canonical event meaning "resumed working", and `busy`
-	// carries no tool semantics to justify inventing one.
-	resolveEvent: (nativeEvent, hookInput) => {
-		if (nativeEvent !== 'session.status') return undefined;
-
-		return getOpenCodeSessionStatusType(hookInput) === 'idle' ? 'Stop' : undefined;
-	},
-	toolNameMap: {
-		bash: 'Bash',
-		read: 'Read',
-		write: 'Write',
-		edit: 'Edit',
-		grep: 'Grep',
-		glob: 'Glob',
-		webfetch: 'WebFetch',
-		websearch: 'WebSearch',
-		apply_patch: 'Edit',
-	},
-	// The CLI hard-errors when asked to install blocking events for opencode.
-	supportsBlockingPermissions: false,
-	supportsTranscripts: false,
-	supportsResume: false,
-	sharesPids: false,
-	// OpenCode's tool hooks carry no per-call cwd: the CLI's generated plugin supplies the
-	// plugin-init directory once, so a session's reported cwd is frozen at that value and never
-	// reflects later movement. Deliberately prose and NOT a capability flag — it was one, and
-	// nothing could be built on it. Every cwd-driven path in `gkAgentProvider` (the
-	// visited-worktree unions, `cwdTimeline` resolution, the `cliSeatedWorktree` unexplained-move
-	// clear) reacts only to an OBSERVED difference between successive cwds, so a frozen cwd
-	// degrades each one to its already-correct single-value no-op. A flag hands that code no fact
-	// it can act on: it explains why the diff never fires, it does not supply the directory the
-	// hooks never sent. Promote it back to a field if a surface ever needs to caveat the
-	// attribution to the user — that would be its first real consumer.
-};
-
-/** Every supported hook client, in registry order. */
-export const agentCapabilities: readonly AgentCapabilities[] = [
-	claudeCodeCapabilities,
-	codexCapabilities,
-	copilotCapabilities,
-	openCodeCapabilities,
-];
-
-/** Looks up capabilities by `gk ai hook` client id. Returns `undefined` for clients GitLens has no
- *  descriptor for (the CLI supports more than this table does). */
-export function getAgentCapabilities(hookClientId: string): AgentCapabilities | undefined {
-	return agentCapabilities.find(c => c.hookClientId === hookClientId);
-}
-
-/** Looks up capabilities by GitLens session provider id. */
-export function getAgentCapabilitiesByProviderId(providerId: string): AgentCapabilities | undefined {
-	return agentCapabilities.find(c => c.providerId === providerId);
-}
-
-/**
- * Translates an agent's native hook event name into the canonical vocabulary: `resolveEvent` first,
- * then `eventMap`, then an identity pass-through for names that are already canonical. Returns
- * `undefined` for anything else — unknown strings are never assumed to be canonical events.
- */
-export function resolveCanonicalHookEvent(
-	capabilities: AgentCapabilities,
-	nativeEvent: string,
-	hookInput?: Record<string, unknown>,
-): AgentHookEvent | undefined {
-	const resolved = capabilities.resolveEvent?.(nativeEvent, hookInput);
-	if (resolved != null) return resolved;
-
-	const mapped = capabilities.eventMap?.[nativeEvent];
-	if (mapped != null) return mapped;
-
-	return isCanonicalHookEvent(nativeEvent) ? nativeEvent : undefined;
-}
-
-/** Translates an agent's native tool name into the canonical (Claude Code) tool name, falling back
- *  to the input unchanged when the agent has no alias for it. */
-export function resolveCanonicalToolName(capabilities: AgentCapabilities, nativeToolName: string): string {
-	return capabilities.toolNameMap?.[nativeToolName] ?? nativeToolName;
-}