@oh-my-pi/pi-coding-agent 16.3.14 → 16.4.0

package/src/advisor/__tests__/config.test.ts

@@ -5,6 +5,7 @@ import * as path from "node:path";
 import {
 	advisorConfigFilePath,
 	discoverAdvisorConfigs,
+	getOrCreateAdvisorProviderSessionId,
 	loadWatchdogConfigFile,
 	resolveAdvisorConfigEditPath,
 	saveWatchdogConfigFile,
@@ -86,6 +87,89 @@ describe("slugifyAdvisorName", () => {
 	});
 });
 
+describe("getOrCreateAdvisorProviderSessionId", () => {
+	const primarySessionA = "018f8f5d-75b0-7cc6-8a6f-2f1c0b8e4c9d";
+	const primarySessionB = "018f8f5d-75b1-7cc6-8a6f-2f1c0b8e4c9d";
+
+	it("returns the generated UUIDv7 instead of a local advisor label", () => {
+		const generated = "0193c8f2-7b1a-7c4d-9e2f-123456789abc";
+
+		const providerSessionId = getOrCreateAdvisorProviderSessionId(
+			new Map<string, string>(),
+			primarySessionA,
+			"security-advisor",
+			() => generated,
+		);
+
+		expect(providerSessionId).toBe(generated);
+		expect(providerSessionId).not.toContain("-advisor");
+	});
+
+	it("reuses the same generated UUIDv7 for repeated calls with the same primary session and slug", () => {
+		const generatedIds = ["0193c8f2-7b1a-7c4d-9e2f-123456789abc", "0193c8f2-7b1b-7c4d-9e2f-123456789abc"];
+		let nextGeneratedIdIndex = 0;
+		const ids = new Map<string, string>();
+
+		const first = getOrCreateAdvisorProviderSessionId(ids, primarySessionA, "architecture", () => {
+			const generated = generatedIds[nextGeneratedIdIndex];
+			if (!generated) throw new Error("unexpected generator call");
+			nextGeneratedIdIndex += 1;
+			return generated;
+		});
+		const second = getOrCreateAdvisorProviderSessionId(ids, primarySessionA, "architecture", () => {
+			const generated = generatedIds[nextGeneratedIdIndex];
+			if (!generated) throw new Error("unexpected generator call");
+			nextGeneratedIdIndex += 1;
+			return generated;
+		});
+
+		expect(first).toBe(generatedIds[0]);
+		expect(second).toBe(generatedIds[0]);
+		expect(nextGeneratedIdIndex).toBe(1);
+	});
+
+	it("creates distinct UUIDv7 values for different advisor slugs or primary sessions", () => {
+		const generatedIds = [
+			"0193c8f2-7b1a-7c4d-9e2f-123456789abc",
+			"0193c8f2-7b1b-7c4d-9e2f-123456789abc",
+			"0193c8f2-7b1c-7c4d-9e2f-123456789abc",
+		];
+		let nextGeneratedIdIndex = 0;
+		const ids = new Map<string, string>();
+		const nextGeneratedId = () => {
+			const generated = generatedIds[nextGeneratedIdIndex];
+			if (!generated) throw new Error("unexpected generator call");
+			nextGeneratedIdIndex += 1;
+			return generated;
+		};
+
+		const architecture = getOrCreateAdvisorProviderSessionId(ids, primarySessionA, "architecture", nextGeneratedId);
+		const security = getOrCreateAdvisorProviderSessionId(ids, primarySessionA, "security", nextGeneratedId);
+		const architectureForOtherSession = getOrCreateAdvisorProviderSessionId(
+			ids,
+			primarySessionB,
+			"architecture",
+			nextGeneratedId,
+		);
+
+		expect(architecture).toBe(generatedIds[0]);
+		expect(security).toBe(generatedIds[1]);
+		expect(architectureForOtherSession).toBe(generatedIds[2]);
+		expect(new Set([architecture, security, architectureForOtherSession]).size).toBe(3);
+	});
+
+	it("rejects generated values that are not UUIDv7", () => {
+		expect(() =>
+			getOrCreateAdvisorProviderSessionId(
+				new Map<string, string>(),
+				primarySessionA,
+				"architecture",
+				() => "550e8400-e29b-41d4-a716-446655440000",
+			),
+		).toThrow("non-UUIDv7");
+	});
+});
+
 describe("WATCHDOG.yml file round-trip", () => {
 	let tmp: string;
 	beforeEach(async () => {

package/src/advisor/config.ts

@@ -59,6 +59,34 @@ export function slugifyAdvisorName(name: string): string {
 	return slug || "advisor";
 }
 
+const UUID_V7_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+const ADVISOR_PROVIDER_SESSION_KEY_SEPARATOR = "\u0000";
+
+/**
+ * Returns a stable provider-facing UUIDv7 for one advisor within one primary session.
+ *
+ * Codex treats `session_id`/`conversation_id` as a UUID-shaped routing identity,
+ * so advisor labels such as `-advisor` stay local-only.
+ */
+export function getOrCreateAdvisorProviderSessionId(
+	ids: Map<string, string>,
+	primarySessionId: string | undefined,
+	slug: string,
+	randomSessionId: () => string = () => Bun.randomUUIDv7(),
+): string | undefined {
+	if (!primarySessionId) return undefined;
+	const key = `${primarySessionId}${ADVISOR_PROVIDER_SESSION_KEY_SEPARATOR}${slug}`;
+	const existing = ids.get(key);
+	if (existing) return existing;
+
+	const next = randomSessionId();
+	if (!UUID_V7_PATTERN.test(next)) {
+		throw new Error("Advisor provider session id generator returned a non-UUIDv7 value");
+	}
+	ids.set(key, next);
+	return next;
+}
+
 /** Built tool names, for validating an advisor's `tools` list. */
 const KNOWN_TOOL_NAMES = new Set<string>(BUILTIN_TOOL_NAMES);
 

package/src/cli/args.ts

@@ -42,6 +42,7 @@ export interface Args {
 	noSession?: boolean;
 	sessionDir?: string;
 	providerSessionId?: string;
+	providerPromptCacheKey?: string;
 	fork?: string;
 	/** Collab link to join at startup (set by the `join` subcommand; no CLI flag). */
 	join?: string;

package/src/cli/flag-tables.ts

@@ -141,6 +141,9 @@ export const STRING_SETTERS: Record<string, StringSetter> = {
 	"--provider-session-id": (result, value) => {
 		result.providerSessionId = value;
 	},
+	"--prompt-cache-key": (result, value) => {
+		result.providerPromptCacheKey = value;
+	},
 	"--session-dir": (result, value) => {
 		result.sessionDir = value;
 	},

package/src/config/model-registry.ts

@@ -690,7 +690,7 @@ function normalizeSuppressedSelector(
 	const trimmed = selector.trim();
 	if (!trimmed) return trimmed;
 	const parsed = parseModelString(trimmed, {
-		allowMaxAlias: true,
+		allowMaxSuffix: true,
 		allowAutoAlias: true,
 		isLiteralModelId: (provider, id) => hasLiveModel?.(provider, id) === true,
 	});

package/src/config/model-resolver.ts

@@ -79,23 +79,24 @@ export interface ScopedModel {
 }
 
 interface ThinkingSuffixOptions {
-	allowMaxAlias?: boolean;
+	allowMaxSuffix?: boolean;
 	allowAutoAlias?: boolean;
 }
 
 interface ModelStringParseOptions extends ThinkingSuffixOptions {
 	isLiteralModelId?: (provider: string, id: string) => boolean;
 }
-// Alias-suffix recognition for the model-pattern parser: `:max` maps to xhigh
-// and `:auto` maps to the auto sentinel. Both are gated behind the alias flags
-// (and the literal-id / exact-match guards on the callers) so a real model id
-// ending in `:max` / `:auto` isn't silently reinterpreted as a thinking suffix.
-const MAX_THINKING_SUFFIX_OPTIONS: ThinkingSuffixOptions = { allowMaxAlias: true, allowAutoAlias: true };
+// Suffix recognition for the model-pattern parser: `:max` is a real thinking
+// level and `:auto` maps to the auto sentinel. Both are gated behind flags
+// (and the literal-id / exact-match guards on the callers) because real model
+// ids end in `:max` (e.g. `glm-4.7:max`) — an ungated split would silently
+// reinterpret them as a thinking suffix.
+const MAX_THINKING_SUFFIX_OPTIONS: ThinkingSuffixOptions = { allowMaxSuffix: true, allowAutoAlias: true };
 
 function parseThinkingSuffix(value: string, options?: ThinkingSuffixOptions): ConfiguredThinkingLevel | undefined {
 	const level = parseThinkingLevel(value);
+	if (level === ThinkingLevel.Max) return options?.allowMaxSuffix === true ? level : undefined;
 	if (level !== undefined) return level;
-	if (options?.allowMaxAlias === true && value === "max") return ThinkingLevel.XHigh;
 	if (options?.allowAutoAlias === true && value === AUTO_THINKING) return AUTO_THINKING;
 	return undefined;
 }
@@ -104,8 +105,9 @@ function parseThinkingSuffix(value: string, options?: ThinkingSuffixOptions): Co
  * Split a trailing `:<level>` thinking selector off a model pattern.
  *
  * `level` is set when the suffix parses as a concrete thinking level (or, when
- * the caller opts in via `allowMaxAlias`/`allowAutoAlias`, the `:max` / `:auto`
- * aliases); `base` then has the suffix stripped. Otherwise `base` is the input.
+ * the caller opts in via `allowMaxSuffix`/`allowAutoAlias`, the guarded `:max`
+ * level / `:auto` sentinel); `base` then has the suffix stripped. Otherwise
+ * `base` is the input.
  * `minColonIndex` requires the colon to appear strictly after that index —
  * role-alias callers pass `PREFIX_MODEL_ROLE.length` so the base is at least
  * as long as the `pi/` prefix.
@@ -183,7 +185,7 @@ export function parseModelString(
 	// Strip strict thinking level suffixes first (e.g. "claude-sonnet-4-6:high" -> id "claude-sonnet-4-6", thinkingLevel "high").
 	const strict = splitThinkingSuffix(id);
 	if (strict.level) return { provider, id: strict.base, thinkingLevel: strict.level };
-	// `max` is a provider-facing alias for xhigh, but real model IDs can end in
+	// `max` is a real thinking level, but real model IDs can also end in
 	// `:max`. Context-aware callers pass a literal lookup so those models win.
 	const maxAlias = splitThinkingSuffix(id, -1, options);
 	if (maxAlias.level) {
@@ -239,7 +241,7 @@ function getOpenRouterRouteSuffix(modelId: string): { baseId: string; suffix: st
 	}
 
 	const suffix = modelId.slice(colonIdx + 1).trim();
-	// `max` is a thinking-level alias (xhigh), never an OpenRouter route suffix, so
+	// `max` is a thinking-level suffix, never an OpenRouter route suffix, so
 	// `openrouter/<id>:max` falls through to the max-aware selector split instead of
 	// being cloned into a literal `<id>:max` model id with the reasoning level lost.
 	if (!suffix || parseThinkingSuffix(suffix, MAX_THINKING_SUFFIX_OPTIONS)) {
@@ -766,7 +768,7 @@ function parseModelPatternWithContext(
 
 	// No match - try stripping a valid thinking suffix and recursing.
 	// `max` is accepted only after the full pattern failed, so literal model IDs
-	// ending in `:max` keep winning over the alias.
+	// ending in `:max` keep winning over the thinking suffix.
 	const { base, level } = splitThinkingSuffix(pattern, -1, MAX_THINKING_SUFFIX_OPTIONS);
 	if (level) {
 		const result = parseModelPatternWithContext(base, availableModels, context, options);

package/src/config/models-config-schema.ts

@@ -23,6 +23,7 @@ const ReasoningEffortMapSchema = type({
 	"medium?": "string",
 	"high?": "string",
 	"xhigh?": "string",
+	"max?": "string",
 });
 
 const OpenAICompatFields = {
@@ -74,13 +75,13 @@ const ApiSchema = type(
 	'"openai-completions" | "openai-responses" | "openai-codex-responses" | "azure-openai-responses" | "anthropic-messages" | "google-generative-ai" | "google-gemini-cli" | "google-vertex"',
 );
 
-const EffortSchema = type('"minimal" | "low" | "medium" | "high" | "xhigh"');
+const EffortSchema = type('"minimal" | "low" | "medium" | "high" | "xhigh" | "max"');
 
 const ThinkingControlModeSchema = type(
 	'"effort" | "budget" | "google-level" | "anthropic-adaptive" | "anthropic-budget-effort"',
 );
 
-const EFFORT_ORDER = ["minimal", "low", "medium", "high", "xhigh"] as const;
+const EFFORT_ORDER = ["minimal", "low", "medium", "high", "xhigh", "max"] as const;
 
 /**
  * Accepts the canonical `efforts` vocabulary plus the legacy

package/src/config/settings-schema.ts

@@ -936,7 +936,7 @@ export const SETTINGS_SCHEMA = {
 	// Reasoning and prompts
 	defaultThinkingLevel: {
 		type: "enum",
-		values: [...THINKING_EFFORTS, AUTO_THINKING, "max"],
+		values: [...THINKING_EFFORTS, AUTO_THINKING],
 		default: "high",
 		ui: {
 			tab: "model",
@@ -4148,7 +4148,7 @@ export const SETTINGS_SCHEMA = {
 			group: "Subagents",
 			label: "Soft Subagent Request Budget",
 			description:
-				"Soft per-subagent request budget (assistant requests per run). Crossing it can inject a steering notice when task.softRequestBudgetNotice is enabled; at 1.5x the budget the run is aborted gracefully, salvaging partial output. 0 disables the guard. Bundled explore/sonic agents use a lower built-in budget.",
+				"Soft per-subagent request budget (assistant requests per run). Crossing it can inject a steering notice when task.softRequestBudgetNotice is enabled; at 1.5x the budget the run is aborted gracefully, salvaging partial output. 0 disables the guard. Bundled scout/sonic agents use a lower built-in budget.",
 			options: [
 				{ value: "0", label: "Disabled" },
 				{ value: "40", label: "40 requests" },
@@ -4964,6 +4964,8 @@ export const SETTINGS_SCHEMA = {
 	"thinkingBudgets.high": { type: "number", default: 16384 },
 
 	"thinkingBudgets.xhigh": { type: "number", default: 32768 },
+
+	"thinkingBudgets.max": { type: "number", default: 32768 },
 } as const;
 
 // ═══════════════════════════════════════════════════════════════════════════
@@ -5180,6 +5182,7 @@ export interface ThinkingBudgetsSettings {
 	medium: number;
 	high: number;
 	xhigh: number;
+	max: number;
 }
 
 export interface SttSettings {

package/src/dap/config.ts

@@ -1,7 +1,7 @@
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
-import { isRecord, logger } from "@oh-my-pi/pi-utils";
+import { isRecord, logger, WhichCachePolicy } from "@oh-my-pi/pi-utils";
 import { YAML } from "bun";
 import { getConfigDirPaths } from "../config";
 import { getPreloadedPluginRoots } from "../discovery/helpers";
@@ -9,7 +9,7 @@ import { hasRootMarkers, resolveCommand } from "../lsp/config";
 import DEFAULTS from "./defaults.json" with { type: "json" };
 import type { DapAdapterConfig, DapResolvedAdapter } from "./types";
 
-const EXTENSIONLESS_DEBUGGER_ORDER = ["gdb", "lldb-dap"] as const;
+const EXTENSIONLESS_DEBUGGER_ORDER: readonly string[] = ["gdb", "lldb-dap"];
 
 interface NormalizedConfig {
 	adapters: Record<string, unknown>;
@@ -188,10 +188,18 @@ function resolveAdapterFromConfig(
 	adapterName: string,
 	configs: Record<string, DapAdapterConfig>,
 	cwd: string,
+	localRoots?: readonly string[],
 ): DapResolvedAdapter | null {
 	const config = configs[adapterName];
 	if (!config) return null;
-	const resolvedCommand = resolveCommand(normalizeCommandForCwd(config.command, cwd), cwd);
+	const normalizedCommand = normalizeCommandForCwd(config.command, cwd);
+	const commandIsBare =
+		!path.isAbsolute(config.command) && !config.command.includes("/") && !config.command.includes("\\");
+	const resolvedCommand = resolveCommand(normalizedCommand, cwd, {
+		cache: WhichCachePolicy.Fresh,
+		PATH: process.env.PATH,
+		localRoots: commandIsBare ? localRoots : undefined,
+	});
 	if (!resolvedCommand) return null;
 	return {
 		name: adapterName,
@@ -219,33 +227,125 @@ export function getAvailableAdapters(cwd: string): DapResolvedAdapter[] {
 		.filter((adapter): adapter is DapResolvedAdapter => adapter !== null);
 }
 
-function getMatchingAdapters(program: string, cwd: string): DapResolvedAdapter[] {
+/** Launch adapter selection, including a configured adapter whose command is unavailable. */
+export type LaunchAdapterSelection =
+	| { kind: "adapter"; adapter: DapResolvedAdapter }
+	| { kind: "unavailable"; adapterName: string; command: string }
+	| { kind: "none" };
+
+interface LaunchAdapterCandidate {
+	name: string;
+	rootDir: string | null;
+}
+
+function findRootMarkerInLaunchAncestry(
+	program: string,
+	cwd: string,
+	markers: string[],
+	programKind: LaunchProgramKind,
+): string | null {
+	if (markers.length === 0) return null;
+	let dir = programKind === "directory" ? path.resolve(cwd, program) : path.dirname(path.resolve(cwd, program));
+	while (true) {
+		if (hasRootMarkers(dir, markers)) return dir;
+		const parent = path.dirname(dir);
+		if (parent === dir) return null;
+		dir = parent;
+	}
+}
+
+function resolveAdapterForLaunch(
+	adapterName: string,
+	configs: Record<string, DapAdapterConfig>,
+	cwd: string,
+	rootDir: string | null,
+): DapResolvedAdapter | null {
+	const localRoots = rootDir && rootDir !== cwd ? [rootDir, cwd] : undefined;
+	return resolveAdapterFromConfig(adapterName, configs, cwd, localRoots);
+}
+
+function unavailableAdapter(
+	candidate: LaunchAdapterCandidate,
+	configs: Record<string, DapAdapterConfig>,
+): LaunchAdapterSelection {
+	const config = configs[candidate.name];
+	if (!config) return { kind: "none" };
+	return { kind: "unavailable", adapterName: candidate.name, command: config.command };
+}
+
+function selectAutomaticLaunchAdapter(
+	program: string,
+	cwd: string,
+	programKind: LaunchProgramKind,
+	configs: Record<string, DapAdapterConfig>,
+): LaunchAdapterSelection {
 	const extension = path.extname(program).toLowerCase();
-	const available = getAvailableAdapters(cwd);
-	if (!extension) {
-		// For extensionless binaries, only consider native debuggers (gdb, lldb-dap)
-		// or adapters that match by root markers. Don't silently fall back to
-		// unrelated adapters like debugpy for a C binary.
-		const nativeDebuggers: ReadonlySet<string> = new Set(EXTENSIONLESS_DEBUGGER_ORDER);
-		return available.filter(
-			adapter =>
-				nativeDebuggers.has(adapter.name) ||
-				(adapter.rootMarkers.length > 0 && hasRootMarkers(cwd, adapter.rootMarkers)),
-		);
+	if (extension) {
+		const configured: LaunchAdapterCandidate[] = [];
+		const available: DapResolvedAdapter[] = [];
+		for (const name in configs) {
+			const config = configs[name];
+			if (!config || !(config.fileTypes ?? []).includes(extension)) continue;
+			const rootDir = findRootMarkerInLaunchAncestry(program, cwd, config.rootMarkers ?? [], programKind);
+			configured.push({ name, rootDir });
+			const adapter = resolveAdapterForLaunch(name, configs, cwd, rootDir);
+			if (adapter) available.push(adapter);
+		}
+		const selected = sortAdaptersForLaunch(program, cwd, programKind, available)[0];
+		if (selected) return { kind: "adapter", adapter: selected };
+		const rootMatch = configured.find(candidate => candidate.rootDir !== null);
+		const unavailable = rootMatch ?? configured[0];
+		if (unavailable) return unavailableAdapter(unavailable, configs);
 	}
-	const exactMatches = available.filter(adapter => adapter.fileTypes.includes(extension));
-	if (exactMatches.length > 0) {
-		return exactMatches;
+
+	const available: DapResolvedAdapter[] = [];
+	const rootMatches: LaunchAdapterCandidate[] = [];
+	const directoryMatches: LaunchAdapterCandidate[] = [];
+	for (const name in configs) {
+		const config = configs[name];
+		if (!config) continue;
+		const rootDir = findRootMarkerInLaunchAncestry(program, cwd, config.rootMarkers ?? [], programKind);
+		const candidate = { name, rootDir };
+		if (rootDir) {
+			rootMatches.push(candidate);
+			if (config.acceptsDirectoryProgram === true) directoryMatches.push(candidate);
+		}
+		if (!EXTENSIONLESS_DEBUGGER_ORDER.includes(name) && !rootDir) continue;
+		const adapter = resolveAdapterForLaunch(name, configs, cwd, rootDir);
+		if (adapter) available.push(adapter);
+	}
+
+	if (programKind === "directory" && directoryMatches.length > 0) {
+		const matchingNames = new Set(directoryMatches.map(candidate => candidate.name));
+		const directoryAdapters = available.filter(
+			adapter => adapter.acceptsDirectoryProgram && matchingNames.has(adapter.name),
+		);
+		const selected = sortAdaptersForLaunch(program, cwd, programKind, directoryAdapters)[0];
+		if (selected) return { kind: "adapter", adapter: selected };
+		const unavailable = directoryMatches[0];
+		return unavailable ? unavailableAdapter(unavailable, configs) : { kind: "none" };
 	}
-	return available;
+
+	const directoryAdapters =
+		programKind === "directory" ? available.filter(adapter => adapter.acceptsDirectoryProgram) : available;
+	const candidates = directoryAdapters.length > 0 ? directoryAdapters : available;
+	const selected = sortAdaptersForLaunch(program, cwd, programKind, candidates)[0];
+	if (selected) return { kind: "adapter", adapter: selected };
+	const unavailable = rootMatches[0];
+	return unavailable ? unavailableAdapter(unavailable, configs) : { kind: "none" };
 }
 
-function sortAdaptersForLaunch(program: string, cwd: string, adapters: DapResolvedAdapter[]): DapResolvedAdapter[] {
+function sortAdaptersForLaunch(
+	program: string,
+	cwd: string,
+	programKind: LaunchProgramKind,
+	adapters: DapResolvedAdapter[],
+): DapResolvedAdapter[] {
 	const extension = path.extname(program).toLowerCase();
 	const rootAware = adapters.map(adapter => ({
 		adapter,
 		hasExtensionMatch: extension.length > 0 && adapter.fileTypes.includes(extension),
-		hasRootMatch: adapter.rootMarkers.length > 0 && hasRootMarkers(cwd, adapter.rootMarkers),
+		hasRootMatch: findRootMarkerInLaunchAncestry(program, cwd, adapter.rootMarkers, programKind) !== null,
 	}));
 	rootAware.sort((left, right) => {
 		if (left.hasExtensionMatch !== right.hasExtensionMatch) {
@@ -254,36 +354,33 @@ function sortAdaptersForLaunch(program: string, cwd: string, adapters: DapResolv
 		if (left.hasRootMatch !== right.hasRootMatch) {
 			return left.hasRootMatch ? -1 : 1;
 		}
-		const leftDebuggerRank = EXTENSIONLESS_DEBUGGER_ORDER.indexOf(
-			left.adapter.name as (typeof EXTENSIONLESS_DEBUGGER_ORDER)[number],
-		);
-		const rightDebuggerRank = EXTENSIONLESS_DEBUGGER_ORDER.indexOf(
-			right.adapter.name as (typeof EXTENSIONLESS_DEBUGGER_ORDER)[number],
-		);
-		const normalizedLeftRank = leftDebuggerRank === -1 ? Number.MAX_SAFE_INTEGER : leftDebuggerRank;
-		const normalizedRightRank = rightDebuggerRank === -1 ? Number.MAX_SAFE_INTEGER : rightDebuggerRank;
-		if (normalizedLeftRank !== normalizedRightRank) {
-			return normalizedLeftRank - normalizedRightRank;
-		}
+		const leftRank = EXTENSIONLESS_DEBUGGER_ORDER.indexOf(left.adapter.name);
+		const rightRank = EXTENSIONLESS_DEBUGGER_ORDER.indexOf(right.adapter.name);
+		const normalizedLeftRank = leftRank === -1 ? Number.MAX_SAFE_INTEGER : leftRank;
+		const normalizedRightRank = rightRank === -1 ? Number.MAX_SAFE_INTEGER : rightRank;
+		const rankDelta = normalizedLeftRank - normalizedRightRank;
+		if (rankDelta !== 0) return rankDelta;
 		return left.adapter.name.localeCompare(right.adapter.name);
 	});
 	return rootAware.map(entry => entry.adapter);
 }
 
+/** Selects a launch adapter or reports why matching configuration cannot run. */
 export function selectLaunchAdapter(
 	program: string,
 	cwd: string,
 	adapterName?: string,
 	programKind: LaunchProgramKind = "file",
-): DapResolvedAdapter | null {
+): LaunchAdapterSelection {
+	const configs = getAdapterConfigs(cwd);
 	if (adapterName) {
-		return resolveAdapter(adapterName, cwd);
+		const config = configs[adapterName];
+		if (!config) return { kind: "none" };
+		const rootDir = findRootMarkerInLaunchAncestry(program, cwd, config.rootMarkers ?? [], programKind);
+		const adapter = resolveAdapterForLaunch(adapterName, configs, cwd, rootDir);
+		return adapter ? { kind: "adapter", adapter } : { kind: "unavailable", adapterName, command: config.command };
 	}
-	const matches = getMatchingAdapters(program, cwd);
-	const candidates =
-		programKind === "directory" ? matches.filter(adapter => adapter.acceptsDirectoryProgram) : matches;
-	const sorted = sortAdaptersForLaunch(program, cwd, candidates.length > 0 ? candidates : matches);
-	return sorted[0] ?? null;
+	return selectAutomaticLaunchAdapter(program, cwd, programKind, configs);
 }
 
 export function selectAttachAdapter(cwd: string, adapterName?: string, port?: number): DapResolvedAdapter | null {

package/src/dap/defaults.json

@@ -64,7 +64,7 @@
 		"connectMode": "socket",
 		"languages": ["go"],
 		"fileTypes": [".go"],
-		"rootMarkers": ["go.mod", "go.sum"],
+		"rootMarkers": ["go.mod", "go.sum", "go.work"],
 		"acceptsDirectoryProgram": true,
 		"launchDefaults": {
 			"request": "launch",

package/src/eval/js/shared/runtime.ts

@@ -163,6 +163,7 @@ export class JsRuntime {
 
 	readonly helpers: HelperBundle;
 	#cwd: string;
+	#session: { cwd: string; sessionId: string };
 	readonly sessionId: string;
 	#env: Map<string, string>;
 	#als = new AsyncLocalStorage<RunContext>();
@@ -171,6 +172,7 @@ export class JsRuntime {
 
 	constructor(opts: RuntimeOptions) {
 		this.#cwd = opts.initialCwd;
+		this.#session = { cwd: opts.initialCwd, sessionId: opts.sessionId };
 		this.sessionId = opts.sessionId;
 		this.#env = new Map();
 		this.#moduleLoader = new LocalModuleLoader(this.sessionId);
@@ -189,10 +191,19 @@ export class JsRuntime {
 	}
 
 	setCwd(cwd: string): void {
-		this.#activateGlobals("set cwd");
+		if (this.#disposed) throw new Error("Cannot set cwd on a disposed JS runtime");
+		// Always stamp the runtime and session state: WorkerCore/browser/cmux call
+		// setCwd from init and pre-run paths that may race another same-realm
+		// runtime, and a throw here used to escape the inline-worker microtask
+		// path as a fatal unhandledRejection that killed the whole session.
+		// #session is the same object saved in this owner's global stack entry,
+		// so the new cwd survives deferred activation and is visible to this
+		// runtime's next run; run()/setRunScope still assert exclusive ownership.
 		this.#cwd = cwd;
-		const session = (globalThis as { __omp_session__?: { cwd?: string } }).__omp_session__;
-		if (session) session.cwd = cwd;
+		this.#session.cwd = cwd;
+		if (activeGlobalRunOwner === null || activeGlobalRunOwner === this.#globalOwner) {
+			this.#activateGlobals("set cwd");
+		}
 	}
 
 	/**
@@ -318,8 +329,13 @@ export class JsRuntime {
 	}
 
 	#install(extraGlobals: Record<string, unknown> | undefined): void {
+		// Constructing a runtime while another same-realm runtime is mid-run would
+		// silently replace the live runtime's globals (Object.assign + prelude eval
+		// below). Fail before any global/stack mutation; WorkerCore reports it as
+		// init-failed instead of corrupting the active run.
+		assertCanUseGlobalOwner(this.#globalOwner, "initialize a JS runtime");
 		const injected: Record<string, unknown> = {
-			__omp_session__: { cwd: this.#cwd, sessionId: this.sessionId },
+			__omp_session__: this.#session,
 			__omp_helpers__: this.helpers,
 			__omp_call_tool__: async (name: string, args: unknown) => {
 				const hooks = this.#activeHooks("tool");

package/src/eval/js/worker-core.ts

@@ -184,8 +184,15 @@ export class WorkerCore {
 	#handle(msg: WorkerInbound): void {
 		switch (msg.type) {
 			case "init":
-				this.#ensureRuntime(msg.snapshot);
-				this.#transport.send({ type: "ready" });
+				try {
+					this.#ensureRuntime(msg.snapshot);
+					this.#transport.send({ type: "ready" });
+				} catch (error) {
+					// Inline fallback delivers messages on a microtask. A sync throw
+					// from ensureRuntime/setCwd would otherwise become a process-fatal
+					// unhandledRejection on the main thread.
+					this.#transport.send({ type: "init-failed", error: errorPayload(error) });
+				}
 				return;
 			case "run":
 				void this.#runOne(msg.runId, msg.code, msg.filename, msg.snapshot);

package/src/exec/bash-executor.ts

@@ -300,9 +300,16 @@ export async function executeBash(command: string, options?: BashExecutorOptions
 	const requestedTimeoutMs = options?.timeout;
 	const deadlineTimeoutMs = requestedTimeoutMs === 0 ? undefined : Math.max(1_000, requestedTimeoutMs ?? 300_000);
 	const nativeTimeoutMs = requestedTimeoutMs !== undefined && requestedTimeoutMs > 0 ? requestedTimeoutMs : undefined;
+	const nativeOwnsTimeout = nativeTimeoutMs !== undefined;
 	if (deadlineTimeoutMs !== undefined) {
 		timeoutTimer = setTimeout(() => {
-			abortCurrentExecution();
+			// Explicit timeouts are already enforced inside pi-natives via
+			// `timeoutMs`. Do not also abort the JS AbortSignal here: on Windows,
+			// aborting that signal while a piped command is still forwarding output
+			// can terminate the Bun host before the native timeout result resolves.
+			if (!nativeOwnsTimeout) {
+				abortCurrentExecution();
+			}
 			timeoutDeferred.resolve("timeout");
 		}, deadlineTimeoutMs);
 	}

package/src/extensibility/extensions/types.ts

@@ -125,6 +125,10 @@ export interface ExtensionUIDialogOptions {
 	timeout?: number;
 	/** Invoked when the UI times out while waiting for a selection/input */
 	onTimeout?: () => void;
+	/** Invoked when the UI-managed timeout countdown starts */
+	onTimeoutStart?: () => void;
+	/** Invoked when user input resets a UI-managed timeout countdown */
+	onTimeoutReset?: () => void;
 	/** Initial cursor position for select dialogs (0-indexed) */
 	initialIndex?: number;
 	/** Render an outlined list for select dialogs */
@@ -176,6 +180,8 @@ export type AutocompleteProviderFactory = (current: AutocompleteProvider) => Aut
 // and may be invoked from event handlers that have already taken the agent
 // loop's lock — hooks intentionally cannot.
 export interface ExtensionUIContext {
+	/** True when selector timeouts start only after the dialog is presented. */
+	timeoutStartsOnPresentation?: boolean;
 	/** Show a selector and return the selected label, even when an option also includes a description. */
 	select(
 		title: string,