@oh-my-pi/pi-coding-agent 15.9.67 → 15.10.1

package/src/config/keybindings.ts

@@ -21,6 +21,7 @@ interface AppKeybindings {
 	"app.clear": true;
 	"app.exit": true;
 	"app.suspend": true;
+	"app.display.reset": true;
 	"app.thinking.cycle": true;
 	"app.thinking.toggle": true;
 	"app.model.cycleForward": true;
@@ -86,6 +87,10 @@ export const KEYBINDINGS = {
 		defaultKeys: "ctrl+z",
 		description: "Suspend application",
 	},
+	"app.display.reset": {
+		defaultKeys: "ctrl+l",
+		description: "Reset terminal display",
+	},
 	"app.thinking.cycle": {
 		defaultKeys: "shift+tab",
 		description: "Cycle thinking level",
@@ -103,7 +108,7 @@ export const KEYBINDINGS = {
 		description: "Cycle to previous model",
 	},
 	"app.model.select": {
-		defaultKeys: "ctrl+l",
+		defaultKeys: "alt+m",
 		description: "Select model",
 	},
 	"app.model.selectTemporary": {
@@ -216,6 +221,7 @@ const KEYBINDING_NAME_MIGRATIONS = {
 	clear: "app.clear",
 	exit: "app.exit",
 	suspend: "app.suspend",
+	displayReset: "app.display.reset",
 	cycleThinkingLevel: "app.thinking.cycle",
 	cycleModelForward: "app.model.cycleForward",
 	cycleModelBackward: "app.model.cycleBackward",
@@ -444,7 +450,6 @@ function migrateKeybindingsConfigFile(agentDir: string): void {
 
 const FOLLOW_UP_KEYBINDING: AppKeybinding = "app.message.followUp";
 const WINDOWS_FOLLOW_UP_FALLBACK_KEY: KeyId = "ctrl+q";
-
 function keyListIncludes(keys: KeyId | KeyId[] | undefined, target: KeyId): boolean {
 	if (keys === undefined) return false;
 	const keyList = Array.isArray(keys) ? keys : [keys];
@@ -525,10 +530,14 @@ export class KeybindingsManager extends TuiKeybindingsManager {
 
 	getKeys(keybinding: Keybinding): KeyId[] {
 		const keys = super.getKeys(keybinding);
-		if (keybinding !== FOLLOW_UP_KEYBINDING) return keys;
-		if (this.#userBindings[FOLLOW_UP_KEYBINDING] !== undefined) return keys;
-		if (!userBindingClaimsKey(this.#userBindings, WINDOWS_FOLLOW_UP_FALLBACK_KEY, FOLLOW_UP_KEYBINDING)) return keys;
-		return removeKey(keys, WINDOWS_FOLLOW_UP_FALLBACK_KEY);
+		if (keybinding === FOLLOW_UP_KEYBINDING) {
+			if (this.#userBindings[FOLLOW_UP_KEYBINDING] !== undefined) return keys;
+			if (!userBindingClaimsKey(this.#userBindings, WINDOWS_FOLLOW_UP_FALLBACK_KEY, FOLLOW_UP_KEYBINDING)) {
+				return keys;
+			}
+			return removeKey(keys, WINDOWS_FOLLOW_UP_FALLBACK_KEY);
+		}
+		return keys;
 	}
 
 	getResolvedBindings(): KeybindingsConfig {

package/src/config/model-equivalence.ts

@@ -58,7 +58,7 @@ const EMPTY_COMPILED_EQUIVALENCE: CompiledEquivalenceConfig = {
 };
 const kModelResolutionCache = Symbol("model-equivalence.resolutionCache");
 interface CompiledEquivalenceConfigWithCache extends CompiledEquivalenceConfig {
-	[kModelResolutionCache]?: WeakMap<Model<Api>, ResolvedCanonicalModel>;
+	[kModelResolutionCache]?: Map<string, ResolvedCanonicalModel>;
 }
 const FAMILY_EXTRACTION_PATTERNS = [
 	/(?:^|[/:._-])((?:claude|gemini|gpt|grok|glm|qwen|minimax|kimi|deepseek|llama|gemma|nova|mistral|ministral|pixtral|codestral|devstral|magistral|ernie|doubao|seed|aion|olmo|molmo|nemotron|palmyra|command|codex|coder|o[1345])[-a-z0-9.]+)(?::|$)/i,
@@ -128,10 +128,18 @@ function normalizeCanonicalIdKey(canonicalId: string): string {
 	return canonicalId.trim().toLowerCase();
 }
 
+function getCanonicalSuffixAliasKey(candidate: string): string {
+	return PENALTY_HAS_UPPERCASE.test(candidate) ? normalizeCanonicalIdKey(candidate) : candidate;
+}
+
 export function formatCanonicalVariantSelector(model: Model<Api>): string {
 	return `${model.provider}/${model.id}`;
 }
 
+function getModelResolutionCacheKey(model: Model<Api>): string {
+	return `${model.provider}\0${model.id}`;
+}
+
 function buildOverrideMap(overrides: Record<string, string> | undefined): Map<string, string> {
 	const result = new Map<string, string>();
 	if (!overrides) {
@@ -159,13 +167,24 @@ function buildExclusionSet(exclusions: readonly string[] | undefined): Set<strin
 	return result;
 }
 
+const compiledEquivalenceCache = new WeakMap<ModelEquivalenceConfig, CompiledEquivalenceConfig>();
 function compileEquivalenceConfig(config: ModelEquivalenceConfig | undefined): CompiledEquivalenceConfig {
+	if (config) {
+		const cached = compiledEquivalenceCache.get(config);
+		if (cached) {
+			return cached;
+		}
+	}
 	const overrides = buildOverrideMap(config?.overrides);
 	const exclude = buildExclusionSet(config?.exclude);
 	if (overrides.size === 0 && exclude.size === 0) {
 		return EMPTY_COMPILED_EQUIVALENCE;
 	}
-	return { overrides, exclude };
+	const compiled: CompiledEquivalenceConfig = { overrides, exclude };
+	if (config) {
+		compiledEquivalenceCache.set(config, compiled);
+	}
+	return compiled;
 }
 
 function addCanonicalCandidate(candidates: Set<string>, candidate: string): void {
@@ -277,7 +296,7 @@ function expandCompactSeriesMinorVersions(candidate: string): string[] {
 // safely return the same instance. Cap keeps memory bounded under adversarial
 // model-id churn.
 const QUALIFIED_NAMESPACE_SUFFIX_CACHE = new Map<string, string[]>();
-const QUALIFIED_NAMESPACE_SUFFIX_CACHE_CAP = 256;
+const QUALIFIED_NAMESPACE_SUFFIX_CACHE_CAP = 4096;
 function getQualifiedNamespaceSuffixes(candidate: string): string[] {
 	const cached = QUALIFIED_NAMESPACE_SUFFIX_CACHE.get(candidate);
 	if (cached !== undefined) {
@@ -670,7 +689,7 @@ function expandHeavyCanonicalCandidates(normalized: string, queue: string[]): vo
 // is unused — kept for signature stability). The returned array is consumed via
 // `.filter` at every callsite, so sharing the cached instance is safe.
 const HEURISTIC_CANDIDATES_CACHE = new Map<string, string[]>();
-const HEURISTIC_CANDIDATES_CACHE_CAP = 256;
+const HEURISTIC_CANDIDATES_CACHE_CAP = 4096;
 function getHeuristicCanonicalCandidates(modelId: string, _officialIds?: ReadonlySet<string>): string[] {
 	const cached = HEURISTIC_CANDIDATES_CACHE.get(modelId);
 	if (cached !== undefined) {
@@ -728,10 +747,10 @@ function getPreferredFallbackCanonicalCandidate(modelId: string, candidates: rea
 
 function resolveCanonicalIdForModel(
 	model: Model<Api>,
+	selector: string,
 	equivalence: CompiledEquivalenceConfig,
 	referenceData: CanonicalReferenceData,
 ): ResolvedCanonicalModel {
-	const selector = formatCanonicalVariantSelector(model);
 	const normalizedSelector = normalizeSelectorKey(selector);
 
 	if (equivalence.overrides.has(normalizedSelector)) {
@@ -753,9 +772,12 @@ function resolveCanonicalIdForModel(
 	}
 
 	const heuristicCandidates = getHeuristicCanonicalCandidates(model.id, referenceData.officialIds);
-	const officialMatches = new Set(heuristicCandidates.filter(candidate => referenceData.officialIds.has(candidate)));
+	const officialMatches = new Set<string>();
 	for (const candidate of heuristicCandidates) {
-		const aliased = referenceData.suffixAliases.get(normalizeCanonicalIdKey(candidate));
+		if (referenceData.officialIds.has(candidate)) {
+			officialMatches.add(candidate);
+		}
+		const aliased = referenceData.suffixAliases.get(getCanonicalSuffixAliasKey(candidate));
 		if (aliased) {
 			officialMatches.add(aliased);
 		}
@@ -814,17 +836,18 @@ export function buildCanonicalModelIndex(
 	const compiledWithCache = compiledEquivalence as CompiledEquivalenceConfigWithCache;
 	let modelCache = compiledWithCache[kModelResolutionCache];
 	if (!modelCache) {
-		modelCache = new WeakMap<Model<Api>, ResolvedCanonicalModel>();
+		modelCache = new Map<string, ResolvedCanonicalModel>();
 		compiledWithCache[kModelResolutionCache] = modelCache;
 	}
 
 	for (const model of models) {
-		let canonical = modelCache.get(model);
+		const selector = formatCanonicalVariantSelector(model);
+		const cacheKey = getModelResolutionCacheKey(model);
+		let canonical = modelCache.get(cacheKey);
 		if (!canonical) {
-			canonical = resolveCanonicalIdForModel(model, compiledEquivalence, referenceData);
-			modelCache.set(model, canonical);
+			canonical = resolveCanonicalIdForModel(model, selector, compiledEquivalence, referenceData);
+			modelCache.set(cacheKey, canonical);
 		}
-		const selector = formatCanonicalVariantSelector(model);
 		const variant: CanonicalModelVariant = {
 			canonicalId: canonical.id,
 			selector,

package/src/config/model-id-affixes.ts

@@ -4,34 +4,49 @@ const MODEL_ID_SEGMENT_PATTERN = /[a-z0-9.:-]+/g;
 const MODEL_FAMILY_PREFIX_PATTERN =
 	/^(claude|gemini|gpt|grok|glm|qwen|deepseek|kimi|mimo|doubao|ernie|gpt-oss|gemma|minimax|step|command|jamba|llama|o[1345])/i;
 
-function hasDigit(value: string): boolean {
-	return /\d/.test(value);
+function normalizeModelIdWhitespace(value: string): string {
+	return value.trim().replace(/\s+/g, " ");
 }
 
+/** Ordering for model-like segments: longest first, ties broken lexicographically. */
 function compareSegmentPreference(left: string, right: string): number {
-	if (left.length !== right.length) {
-		return right.length - left.length;
-	}
-	return left.localeCompare(right);
+	return left.length !== right.length ? right.length - left.length : left.localeCompare(right);
 }
 
 export function getModelLikeIdSegments(modelId: string): string[] {
-	const normalized = normalizeModelIdWhitespace(modelId).toLowerCase();
-	if (!normalized) return [];
-	const segments = (normalized.match(MODEL_ID_SEGMENT_PATTERN) ?? []).filter(
-		segment => MODEL_FAMILY_PREFIX_PATTERN.test(segment) && hasDigit(segment),
-	);
-	const unique = [...new Set(segments)];
-	unique.sort(compareSegmentPreference);
-	return unique;
+	const matches = normalizeModelIdWhitespace(modelId).toLowerCase().match(MODEL_ID_SEGMENT_PATTERN);
+	if (!matches) return [];
+	const segments = new Set<string>();
+	for (const segment of matches) {
+		if (MODEL_FAMILY_PREFIX_PATTERN.test(segment) && /\d/.test(segment)) segments.add(segment);
+	}
+	return [...segments].sort(compareSegmentPreference);
 }
 
 export function getLongestModelLikeIdSegment(modelId: string): string | undefined {
-	return getModelLikeIdSegments(modelId)[0];
+	const matches = normalizeModelIdWhitespace(modelId).toLowerCase().match(MODEL_ID_SEGMENT_PATTERN);
+	if (!matches) return undefined;
+	let best: string | undefined;
+	for (const segment of matches) {
+		if (
+			MODEL_FAMILY_PREFIX_PATTERN.test(segment) &&
+			/\d/.test(segment) &&
+			(best === undefined || compareSegmentPreference(segment, best) < 0)
+		) {
+			best = segment;
+		}
+	}
+	return best;
 }
 
-function normalizeModelIdWhitespace(value: string): string {
-	return value.trim().replace(/\s+/g, " ");
+function hasBracketAffixMarker(value: string): boolean {
+	for (let index = 0; index < value.length; index++) {
+		const code = value.charCodeAt(index);
+		if (code === 91 || code === 93 || code === 0x3010 || code === 0x3011) {
+			return true;
+		}
+	}
+	return false;
 }
 
 /**
@@ -39,18 +54,20 @@ function normalizeModelIdWhitespace(value: string): string {
  * upstream model id, e.g.
  *   "[Kiro] claude-opus-4-8"                -> "claude-opus-4-8"
  *   "[gcli转] gemini-3.1-pro-preview [假流]" -> "gemini-3.1-pro-preview"
+ *
+ * Candidates are returned most-stripped first: both ends, then leading-only, then trailing-only.
  */
 export function getBracketStrippedModelIdCandidates(modelId: string): string[] {
+	if (!hasBracketAffixMarker(modelId)) return [];
 	const normalized = normalizeModelIdWhitespace(modelId);
 	if (!normalized) return [];
 
-	const candidates = new Set<string>();
-	const withoutLeading = normalizeModelIdWhitespace(normalized.replace(LEADING_BRACKETED_AFFIX_PATTERN, ""));
+	const strippedLeading = normalized.replace(LEADING_BRACKETED_AFFIX_PATTERN, "");
+	const withoutLeading = normalizeModelIdWhitespace(strippedLeading);
 	const withoutTrailing = normalizeModelIdWhitespace(normalized.replace(TRAILING_BRACKETED_AFFIX_PATTERN, ""));
-	const withoutBoth = normalizeModelIdWhitespace(
-		normalized.replace(LEADING_BRACKETED_AFFIX_PATTERN, "").replace(TRAILING_BRACKETED_AFFIX_PATTERN, ""),
-	);
+	const withoutBoth = normalizeModelIdWhitespace(strippedLeading.replace(TRAILING_BRACKETED_AFFIX_PATTERN, ""));
 
+	const candidates = new Set<string>();
 	for (const candidate of [withoutBoth, withoutLeading, withoutTrailing]) {
 		if (candidate && candidate !== normalized) {
 			candidates.add(candidate);

package/src/config/model-registry.ts

@@ -1,27 +1,19 @@
 import * as path from "node:path";
+import { registerCustomApi, unregisterCustomApis } from "@oh-my-pi/pi-ai/api-registry";
+import { readModelCache } from "@oh-my-pi/pi-ai/model-cache";
+import { createModelManager, type ModelManagerOptions, type ModelRefreshStrategy } from "@oh-my-pi/pi-ai/model-manager";
+import { enrichModelThinking } from "@oh-my-pi/pi-ai/model-thinking";
+import { getBundledModels, getBundledProviders } from "@oh-my-pi/pi-ai/models";
 import {
-	type Api,
-	type AssistantMessageEventStream,
-	type Context,
-	createModelManager,
-	enrichModelThinking,
-	getBundledModels,
-	getBundledProviders,
 	googleAntigravityModelManagerOptions,
 	googleGeminiCliModelManagerOptions,
-	type Model,
-	type ModelManagerOptions,
-	type ModelRefreshStrategy,
 	openaiCodexModelManagerOptions,
 	PROVIDER_DESCRIPTORS,
-	readModelCache,
-	registerCustomApi,
-	type SimpleStreamOptions,
-	type ThinkingConfig,
 	UNK_CONTEXT_WINDOW,
 	UNK_MAX_TOKENS,
-	unregisterCustomApis,
-} from "@oh-my-pi/pi-ai";
+} from "@oh-my-pi/pi-ai/provider-models";
+import type { Api, Context, Model, SimpleStreamOptions, ThinkingConfig } from "@oh-my-pi/pi-ai/types";
+import type { AssistantMessageEventStream } from "@oh-my-pi/pi-ai/utils/event-stream";
 
 // Sentinel for local-only OAuth token (LM Studio, vLLM) — declared inline to avoid loading
 // any provider module at startup. Must match `DEFAULT_LOCAL_TOKEN` in oauth/lm-studio.ts.
@@ -103,12 +95,14 @@ const STARTUP_MODEL_CACHE_PROVIDER_IDS: readonly string[] = [
 	...SPECIAL_MODEL_MANAGER_PROVIDER_IDS,
 ];
 
+import type { ApiKeyResolver } from "@oh-my-pi/pi-ai";
 import { registerOAuthProvider, unregisterOAuthProviders } from "@oh-my-pi/pi-ai/utils/oauth";
 import type { OAuthCredentials, OAuthLoginCallbacks } from "@oh-my-pi/pi-ai/utils/oauth/types";
 import { isRecord, logger } from "@oh-my-pi/pi-utils";
 import { parseModelString, resolveProviderModelReference } from "../config/model-resolver";
 import { isValidThemeColor, type ThemeColor } from "../modes/theme/theme";
 import type { AuthStorage, OAuthCredential } from "../session/auth-storage";
+import { type ApiKeyResolverOptions, createApiKeyResolver } from "./api-key-resolver";
 import { type ConfigError, ConfigFile } from "./config-file";
 import {
 	buildCanonicalModelIndex,
@@ -2373,12 +2367,33 @@ export class ModelRegistry {
 
 	/**
 	 * Get API key for a provider (e.g., "openai").
+	 *
+	 * `options.forceRefresh` powers step (b) of the auth-retry policy — it
+	 * re-mints the session-sticky OAuth token even when the cached copy still
+	 * looks valid. `options.signal` is threaded into any broker-bound refresh.
 	 */
-	async getApiKeyForProvider(provider: string, sessionId?: string, baseUrl?: string): Promise<string | undefined> {
+	async getApiKeyForProvider(
+		provider: string,
+		sessionId?: string,
+		options?: { baseUrl?: string; forceRefresh?: boolean; signal?: AbortSignal },
+	): Promise<string | undefined> {
 		if (this.#keylessProviders.has(provider) && !this.authStorage.hasAuth(provider)) {
 			return kNoAuth;
 		}
-		return this.authStorage.getApiKey(provider, sessionId, { baseUrl });
+		return this.authStorage.getApiKey(provider, sessionId, {
+			baseUrl: options?.baseUrl,
+			forceRefresh: options?.forceRefresh,
+			signal: options?.signal,
+		});
+	}
+
+	/**
+	 * Build an {@link ApiKeyResolver} for this provider, implementing the
+	 * central a/b/c auth-retry policy. Callers that need the initial key for
+	 * a guard can call `resolveApiKeyOnce(resolver)`.
+	 */
+	resolver(provider: string, options?: ApiKeyResolverOptions): ApiKeyResolver {
+		return createApiKeyResolver(this, provider, options);
 	}
 
 	async #peekApiKeyForProvider(provider: string): Promise<string | undefined> {
@@ -2609,6 +2624,14 @@ export class ModelRegistry {
 		}
 		return true;
 	}
+
+	/**
+	 * Clear all cooldown suppressions recorded via {@link suppressSelector}.
+	 * Used to reset retry-fallback cooldown state without a full {@link refresh}.
+	 */
+	clearSuppressedSelectors(): void {
+		this.#suppressedSelectors.clear();
+	}
 }
 
 /**

package/src/config/settings-schema.ts

@@ -660,6 +660,16 @@ export const SETTINGS_SCHEMA = {
 		},
 	},
 
+	"display.smoothStreaming": {
+		type: "boolean",
+		default: true,
+		ui: {
+			tab: "appearance",
+			label: "Smooth Streaming",
+			description: "Reveal assistant text smoothly while streamed chunks arrive",
+		},
+	},
+
 	"display.showTokenUsage": {
 		type: "boolean",
 		default: false,
@@ -3059,13 +3069,26 @@ export const SETTINGS_SCHEMA = {
 			],
 		},
 	},
-	"providers.parallelFetch": {
-		type: "boolean",
-		default: true,
+	"providers.fetch": {
+		type: "enum",
+		values: ["auto", "native", "trafilatura", "lynx", "parallel", "jina"] as const,
+		default: "auto",
 		ui: {
 			tab: "providers",
-			label: "Parallel Fetch",
-			description: "Use Parallel extract API for URL fetching when credentials are available",
+			label: "Fetch Provider",
+			description: "Reader backend priority for the fetch/read URL tool",
+			options: [
+				{
+					value: "auto",
+					label: "Auto",
+					description: "Priority: native > trafilatura > lynx > parallel > jina",
+				},
+				{ value: "native", label: "Native", description: "In-process HTML→Markdown converter (always available)" },
+				{ value: "trafilatura", label: "Trafilatura", description: "Auto-installs via uv/pip" },
+				{ value: "lynx", label: "Lynx", description: "Requires lynx system package" },
+				{ value: "parallel", label: "Parallel", description: "Requires PARALLEL_API_KEY" },
+				{ value: "jina", label: "Jina", description: "Uses r.jina.ai reader (JINA_API_KEY optional)" },
+			],
 		},
 	},
 	"provider.appendOnlyContext": {

package/src/config/settings.ts

@@ -240,11 +240,13 @@ export class Settings {
 		return promise.then(
 			instance => {
 				globalInstance = instance;
+				clearBoundSettingsMethods();
 				globalInstancePromise = Promise.resolve(instance);
 				return instance;
 			},
 			error => {
 				globalInstance = null;
+				clearBoundSettingsMethods();
 				throw error;
 			},
 		);
@@ -712,6 +714,17 @@ export class Settings {
 			}
 		}
 
+		// providers.parallelFetch (boolean) replaced by the providers.fetch reader
+		// priority enum. The new default ("auto") supersedes both old values —
+		// Parallel is now a deep fallback in the auto chain rather than the first
+		// choice — so drop the legacy key (flat and nested) and let the enum
+		// default apply.
+		const providersObj = raw.providers as Record<string, unknown> | undefined;
+		if (providersObj && "parallelFetch" in providersObj) {
+			delete providersObj.parallelFetch;
+		}
+		delete raw["providers.parallelFetch"];
+
 		// Map legacy `memories.enabled` boolean to the explicit `memory.backend`
 		// enum if the latter hasn't been set yet. Idempotent: subsequent
 		// migrations are no-ops once memory.backend is materialised.
@@ -967,6 +980,13 @@ export function onHindsightScopeChanged(cb: () => void): () => void {
 
 let globalInstance: Settings | null = null;
 let globalInstancePromise: Promise<Settings> | null = null;
+let boundSettingsInstance: Settings | null = null;
+let boundSettingsMethods = new Map<PropertyKey, unknown>();
+
+function clearBoundSettingsMethods(): void {
+	boundSettingsInstance = null;
+	boundSettingsMethods = new Map<PropertyKey, unknown>();
+}
 
 export function isSettingsInitialized(): boolean {
 	return globalInstance !== null;
@@ -979,6 +999,7 @@ export function isSettingsInitialized(): boolean {
 export function resetSettingsForTest(): void {
 	globalInstance = null;
 	globalInstancePromise = null;
+	clearBoundSettingsMethods();
 }
 
 /**
@@ -990,9 +1011,17 @@ export const settings = new Proxy({} as Settings, {
 		if (!globalInstance) {
 			throw new Error("Settings not initialized. Call Settings.init() first.");
 		}
-		const value = (globalInstance as unknown as Record<string | symbol, unknown>)[prop];
+		if (boundSettingsInstance !== globalInstance) {
+			clearBoundSettingsMethods();
+			boundSettingsInstance = globalInstance;
+		}
+		const value = (globalInstance as unknown as Record<PropertyKey, unknown>)[prop];
 		if (typeof value === "function") {
-			return value.bind(globalInstance);
+			const cached = boundSettingsMethods.get(prop);
+			if (cached) return cached;
+			const bound = value.bind(globalInstance);
+			boundSettingsMethods.set(prop, bound);
+			return bound;
 		}
 		return value;
 	},

package/src/dap/client.ts

@@ -1,4 +1,5 @@
-import { logger, ptree } from "@oh-my-pi/pi-utils";
+import * as fs from "node:fs/promises";
+import { isEnoent, logger, ptree } from "@oh-my-pi/pi-utils";
 import { NON_INTERACTIVE_ENV } from "../exec/non-interactive-env";
 import { ToolAbortError } from "../tools/tool-errors";
 import type {
@@ -165,19 +166,7 @@ export class DapClient {
 			detached: true,
 		});
 
-		// Wait for the socket file to appear (dlv needs to start listening)
-		await waitForCondition(
-			() => {
-				try {
-					Bun.file(socketPath).size;
-					return true;
-				} catch {
-					return false;
-				}
-			},
-			10_000,
-			proc,
-		);
+		await waitForCondition(() => isUnixSocketReady(socketPath), 10_000, proc);
 
 		const { readable, writeSink, socket } = await connectSocket({ unix: socketPath });
 		const client = new DapClient(adapter, cwd, proc, { readable, writeSink, socket });
@@ -553,15 +542,24 @@ export class DapClient {
 	}
 }
 
+async function isUnixSocketReady(socketPath: string): Promise<boolean> {
+	try {
+		return (await fs.stat(socketPath)).isSocket();
+	} catch (error) {
+		if (isEnoent(error)) return false;
+		throw error;
+	}
+}
+
 /** Poll a condition until it returns true, or timeout/process exit. */
 async function waitForCondition(
-	check: () => boolean,
+	check: () => boolean | Promise<boolean>,
 	timeoutMs: number,
 	proc: { exitCode: number | null },
 ): Promise<void> {
 	const deadline = Date.now() + timeoutMs;
 	while (Date.now() < deadline) {
-		if (check()) return;
+		if (await check()) return;
 		if (proc.exitCode !== null) {
 			throw new Error("Adapter process exited before socket was ready");
 		}

package/src/dap/config.ts

@@ -27,6 +27,7 @@ function normalizeAdapterConfig(config: unknown): DapAdapterConfig | null {
 		rootMarkers: normalizeStringArray(config.rootMarkers),
 		launchDefaults: normalizeObject(config.launchDefaults),
 		attachDefaults: normalizeObject(config.attachDefaults),
+		acceptsDirectoryProgram: config.acceptsDirectoryProgram === true,
 		...(connectMode ? { connectMode } : {}),
 	};
 }
@@ -64,6 +65,7 @@ export function resolveAdapter(adapterName: string, cwd: string): DapResolvedAda
 		launchDefaults: config.launchDefaults ?? {},
 		attachDefaults: config.attachDefaults ?? {},
 		connectMode: config.connectMode ?? "stdio",
+		acceptsDirectoryProgram: config.acceptsDirectoryProgram === true,
 	};
 }
 
@@ -124,12 +126,19 @@ function sortAdaptersForLaunch(program: string, cwd: string, adapters: DapResolv
 	return rootAware.map(entry => entry.adapter);
 }
 
-export function selectLaunchAdapter(program: string, cwd: string, adapterName?: string): DapResolvedAdapter | null {
+export function selectLaunchAdapter(
+	program: string,
+	cwd: string,
+	adapterName?: string,
+	programKind: LaunchProgramKind = "file",
+): DapResolvedAdapter | null {
 	if (adapterName) {
 		return resolveAdapter(adapterName, cwd);
 	}
 	const matches = getMatchingAdapters(program, cwd);
-	const sorted = sortAdaptersForLaunch(program, cwd, matches);
+	const candidates =
+		programKind === "directory" ? matches.filter(adapter => adapter.acceptsDirectoryProgram) : matches;
+	const sorted = sortAdaptersForLaunch(program, cwd, candidates.length > 0 ? candidates : matches);
 	return sorted[0] ?? null;
 }
 
@@ -148,3 +157,33 @@ export function selectAttachAdapter(cwd: string, adapterName?: string, port?: nu
 	}
 	return available[0] ?? null;
 }
+
+/** How the launch `program` resolves on disk. `"missing"` is reserved for
+ *  programs the adapter creates on demand (rare); we treat them like files. */
+export type LaunchProgramKind = "file" | "directory" | "missing";
+
+/** Compute adapter-specific launch arguments that depend on the resolved
+ *  program. Returned values are spread over `adapter.launchDefaults` so they
+ *  take precedence over the static defaults but can still be overridden by
+ *  the fields `DapSessionManager.launch` sets explicitly (program, cwd, args).
+ *
+ *  Currently scoped to dlv, where `mode` selects how the program path is
+ *  interpreted: directories and `.go` source files debug as a Go package
+ *  (`mode=debug`), anything else is treated as a compiled binary (`mode=exec`).
+ */
+export function resolveLaunchOverrides(
+	adapter: DapResolvedAdapter,
+	program: string,
+	programKind: LaunchProgramKind,
+): Record<string, unknown> {
+	if (adapter.name === "dlv") {
+		const extension = path.extname(program).toLowerCase();
+		if (programKind === "directory" || extension === ".go") {
+			return { mode: "debug" };
+		}
+		if (programKind === "file") {
+			return { mode: "exec" };
+		}
+	}
+	return {};
+}

package/src/dap/defaults.json

@@ -65,6 +65,7 @@
 		"languages": ["go"],
 		"fileTypes": [".go"],
 		"rootMarkers": ["go.mod", "go.sum"],
+		"acceptsDirectoryProgram": true,
 		"launchDefaults": {
 			"request": "launch",
 			"mode": "debug",

package/src/dap/session.ts

@@ -259,6 +259,7 @@ export class DapSessionManager {
 			session.needsConfigurationDone = session.capabilities.supportsConfigurationDoneRequest === true;
 			const launchArguments: DapLaunchArguments = {
 				...options.adapter.launchDefaults,
+				...(options.extraLaunchArguments ?? {}),
 				program: options.program,
 				cwd: options.cwd,
 				args: options.args,

package/src/dap/types.ts

@@ -488,6 +488,10 @@ export interface DapAdapterConfig {
 	 *  On Linux, connects via a unix domain socket.
 	 *  On macOS, the adapter dials into a local TCP listener (--client-addr). */
 	connectMode?: "stdio" | "socket";
+	/** When true, the adapter accepts a directory as the launch `program`
+	 *  (e.g. dlv treats it as a Go package path). When false/undefined, the
+	 *  debug tool rejects directory programs upfront. */
+	acceptsDirectoryProgram?: boolean;
 }
 
 export interface DapResolvedAdapter {
@@ -501,6 +505,7 @@ export interface DapResolvedAdapter {
 	launchDefaults: Record<string, unknown>;
 	attachDefaults: Record<string, unknown>;
 	connectMode: "stdio" | "socket";
+	acceptsDirectoryProgram: boolean;
 }
 
 export interface DapBreakpointRecord {
@@ -589,6 +594,11 @@ export interface DapLaunchSessionOptions {
 	program: string;
 	args?: string[];
 	cwd: string;
+	/** Per-launch overrides merged over `adapter.launchDefaults`. Used to
+	 *  inject adapter-specific values that depend on the resolved program
+	 *  (e.g. dlv's `mode` switches between `debug` and `exec` based on
+	 *  whether `program` is a Go package path or a compiled binary). */
+	extraLaunchArguments?: Record<string, unknown>;
 }
 
 export interface DapAttachSessionOptions {