@oh-my-pi/pi-coding-agent 15.7.5 → 15.8.0

package/src/cli/session-picker.ts

@@ -1,23 +1,43 @@
 import { ProcessTerminal, TUI } from "@oh-my-pi/pi-tui";
+import { logger } from "@oh-my-pi/pi-utils";
 import { SessionSelectorComponent } from "../modes/components/session-selector";
-import type { SessionInfo } from "../session/session-manager";
+import { HistoryStorage } from "../session/history-storage";
+import { type SessionInfo, SessionManager } from "../session/session-manager";
 import { FileSessionStorage } from "../session/session-storage";
 
-/** Show TUI session selector and return selected session path or null if cancelled */
-export async function selectSession(sessions: SessionInfo[]): Promise<string | null> {
-	const { promise, resolve } = Promise.withResolvers<string | null>();
+/**
+ * Show the TUI session selector and return the selected session, or null if
+ * cancelled. Tab toggles between current-folder and all-projects scope; the
+ * all-projects list is loaded lazily via `SessionManager.listAll`.
+ */
+export async function selectSession(
+	sessions: SessionInfo[],
+	options?: { allSessions?: SessionInfo[]; startInAllScope?: boolean },
+): Promise<SessionInfo | null> {
+	const { promise, resolve } = Promise.withResolvers<SessionInfo | null>();
 	const ui = new TUI(new ProcessTerminal());
 	let resolved = false;
 	const storage = new FileSessionStorage();
 
+	// Rank sessions with prompt-history matches too, recovering prompts the 4KB
+	// session-list prefix never sees. Best-effort: a missing/locked history.db
+	// must not break the picker.
+	let historyMatcher: ((query: string) => string[]) | undefined;
+	try {
+		const history = HistoryStorage.open();
+		historyMatcher = (query: string) => history.matchingSessionIds(query);
+	} catch (error) {
+		logger.warn("History storage unavailable for session ranking", { error: String(error) });
+	}
+
 	const showSelector = () => {
 		const selector = new SessionSelectorComponent(
 			sessions,
-			(path: string) => {
+			(session: SessionInfo) => {
 				if (!resolved) {
 					resolved = true;
 					ui.stop();
-					resolve(path);
+					resolve(session);
 				}
 			},
 			() => {
@@ -34,10 +54,16 @@ export async function selectSession(sessions: SessionInfo[]): Promise<string | n
 					process.exit(0);
 				}
 			},
-			async (session: SessionInfo) => {
-				// Delete handler - SessionList will show confirmation internally
-				await storage.deleteSessionWithArtifacts(session.path);
-				return true;
+			{
+				onDelete: async (session: SessionInfo) => {
+					// Delete handler - SessionList will show confirmation internally
+					await storage.deleteSessionWithArtifacts(session.path);
+					return true;
+				},
+				historyMatcher,
+				loadAllSessions: () => SessionManager.listAll(storage),
+				allSessions: options?.allSessions,
+				startInAllScope: options?.startInAllScope,
 			},
 		);
 		return selector;

package/src/cli/update-cli.ts

@@ -14,6 +14,18 @@ import { theme } from "../modes/theme/theme";
 
 const REPO = "can1357/oh-my-pi";
 const PACKAGE = "@oh-my-pi/pi-coding-agent";
+/**
+ * Official npm registry origin.
+ *
+ * Pinned across both the version check and the bun install step so the two
+ * agree on which catalog they are talking to. A user's bun may be pointed at
+ * an unofficial mirror (corporate proxy, Taobao, etc.) that lags the upstream
+ * registry by minutes-to-hours, in which case `getLatestRelease` would resolve
+ * a version the mirror has not yet replicated and the install would fail with
+ * `No version matching "X" found for specifier "<pkg>" (but package exists)`.
+ * See #1686.
+ */
+const NPM_REGISTRY = "https://registry.npmjs.org/";
 
 interface ReleaseInfo {
 	tag: string;
@@ -130,7 +142,7 @@ async function resolveUpdateTarget(): Promise<UpdateTarget> {
  * Uses npm instead of GitHub API to avoid unauthenticated rate limiting.
  */
 async function getLatestRelease(): Promise<ReleaseInfo> {
-	const response = await fetch(`https://registry.npmjs.org/${PACKAGE}/latest`);
+	const response = await fetch(`${NPM_REGISTRY}${PACKAGE}/latest`);
 	if (!response.ok) {
 		throw new Error(`Failed to fetch release info: ${response.statusText}`);
 	}
@@ -292,12 +304,33 @@ export async function replaceBinaryForUpdate(options: BinaryReplacementOptions):
 	}
 }
 
+/**
+ * Build the bun argv used to globally install a specific omp version.
+ *
+ * The version is selected by hitting {@link NPM_REGISTRY} directly in
+ * {@link getLatestRelease}, so the install MUST observe the same catalog:
+ *
+ * - `--registry=${NPM_REGISTRY}` pins the install to the official registry
+ *   regardless of the user's bunfig/`.npmrc`. A mirror (corporate proxy,
+ *   Taobao, …) that hasn't yet replicated the release would otherwise reject
+ *   a version the upstream registry already advertises.
+ * - `--no-cache` tells bun to ignore its on-disk manifest snapshot so it
+ *   re-fetches metadata from that registry on every invocation.
+ *
+ * Together these two flags make `omp update` produce exactly the registry
+ * lookup the version check just performed. See #1686.
+ */
+export function buildBunInstallArgs(expectedVersion: string): string[] {
+	return ["install", "-g", "--no-cache", `--registry=${NPM_REGISTRY}`, `${PACKAGE}@${expectedVersion}`];
+}
+
 /**
  * Update via bun package manager.
  */
 async function updateViaBun(expectedVersion: string): Promise<void> {
 	console.log(chalk.dim("Updating via bun..."));
-	const result = await $`bun install -g ${PACKAGE}@${expectedVersion}`.nothrow();
+	const args = buildBunInstallArgs(expectedVersion);
+	const result = await $`bun ${args}`.nothrow();
 	if (result.exitCode !== 0) {
 		throw new Error(`bun install failed with exit code ${result.exitCode}`);
 	}

package/src/commands/launch.ts

@@ -90,6 +90,9 @@ export default class Index extends Command {
 			description: `Set thinking level: ${THINKING_EFFORTS.join(", ")}`,
 			options: [...THINKING_EFFORTS],
 		}),
+		"hide-thinking": Flags.boolean({
+			description: "Hide thinking blocks in TUI output (display only, does not disable model thinking)",
+		}),
 		hook: Flags.string({
 			description: "Load a hook/extension file (can be used multiple times)",
 			multiple: true,

package/src/config/keybindings.ts

@@ -32,6 +32,7 @@ interface AppKeybindings {
 	"app.message.followUp": true;
 	"app.message.dequeue": true;
 	"app.clipboard.pasteImage": true;
+	"app.clipboard.pasteTextRaw": true;
 	"app.clipboard.copyLine": true;
 	"app.clipboard.copyPrompt": true;
 	"app.session.new": true;
@@ -122,6 +123,10 @@ export const KEYBINDINGS = {
 		defaultKeys: process.platform === "win32" ? "alt+v" : "ctrl+v",
 		description: "Paste image from clipboard",
 	},
+	"app.clipboard.pasteTextRaw": {
+		defaultKeys: ["ctrl+shift+v", "alt+shift+v"],
+		description: "Paste text from clipboard as raw text (no collapse)",
+	},
 	"app.clipboard.copyLine": {
 		defaultKeys: "alt+shift+l",
 		description: "Copy current line",
@@ -214,6 +219,7 @@ const KEYBINDING_NAME_MIGRATIONS = {
 	followUp: "app.message.followUp",
 	dequeue: "app.message.dequeue",
 	pasteImage: "app.clipboard.pasteImage",
+	pasteTextRaw: "app.clipboard.pasteTextRaw",
 	copyLine: "app.clipboard.copyLine",
 	copyPrompt: "app.clipboard.copyPrompt",
 	newSession: "app.session.new",

package/src/config/model-registry.ts

@@ -27,6 +27,32 @@ import {
 // any provider module at startup. Must match `DEFAULT_LOCAL_TOKEN` in oauth/lm-studio.ts.
 const DEFAULT_LOCAL_TOKEN = "lm-studio-local";
 
+// Default cap on `max_tokens` for auto-discovered models that do not advertise
+// their own output limit (OpenAI-models-list, Ollama, llama.cpp, new-api/
+// one-api proxies). 32K matches the upper end of what mainstream
+// OpenAI-compatible providers (DeepSeek, MiMo, OpenRouter, etc.) actually
+// accept and keeps `min(contextWindow, …)` honoring smaller local windows.
+// Conservative caps below this caused providers to drop the connection
+// mid-stream when models hit the cap on legitimate large tool calls (see
+// issue #1528: `write` payloads >~5KB on deepseek-v4-pro surfaced as
+// "socket connection was closed unexpectedly").
+const DISCOVERY_DEFAULT_MAX_TOKENS = 32_768;
+
+// Anthropic-safe variant of the discovery cap. The Anthropic stream converter
+// in `packages/ai/src/providers/anthropic.ts` derives the request limit as
+// `(model.maxTokens / 3) | 0`, so the 32K default would surface as 10,922
+// requested output tokens — above the 8,192 hard cap on classic Claude 3.x
+// Sonnet/Haiku/Opus endpoints. Discovered models routed through
+// `anthropic-messages` (proxy `supported_endpoint_types: ["anthropic"]` or a
+// custom provider with `api: anthropic-messages` + openai-models-list
+// discovery) fall back to this conservative value.
+const DISCOVERY_DEFAULT_MAX_TOKENS_ANTHROPIC = 8_192;
+
+/** Routes discovered-model `maxTokens` defaults around Anthropic's 3× output divisor. */
+function discoveryDefaultMaxTokens(api: Api | undefined): number {
+	return api === "anthropic-messages" ? DISCOVERY_DEFAULT_MAX_TOKENS_ANTHROPIC : DISCOVERY_DEFAULT_MAX_TOKENS;
+}
+
 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";
@@ -1690,7 +1716,7 @@ export class ModelRegistry {
 				input: metadata?.input ?? ["text"],
 				cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
 				contextWindow: metadata?.contextWindow ?? 128000,
-				maxTokens: Math.min(metadata?.contextWindow ?? Number.POSITIVE_INFINITY, 8192),
+				maxTokens: Math.min(metadata?.contextWindow ?? Number.POSITIVE_INFINITY, DISCOVERY_DEFAULT_MAX_TOKENS),
 				headers: providerConfig.headers,
 			});
 		});
@@ -1760,7 +1786,10 @@ export class ModelRegistry {
 					input: serverMetadata?.input ?? ["text"],
 					cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
 					contextWindow: serverMetadata?.contextWindow ?? 128000,
-					maxTokens: Math.min(serverMetadata?.contextWindow ?? Number.POSITIVE_INFINITY, 8192),
+					maxTokens: Math.min(
+						serverMetadata?.contextWindow ?? Number.POSITIVE_INFINITY,
+						DISCOVERY_DEFAULT_MAX_TOKENS,
+					),
 					headers,
 					compat: {
 						supportsStore: false,
@@ -1807,7 +1836,7 @@ export class ModelRegistry {
 					input: ["text"],
 					cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
 					contextWindow: 128000,
-					maxTokens: 8192,
+					maxTokens: discoveryDefaultMaxTokens(providerConfig.api),
 					headers,
 					compat: {
 						supportsStore: false,
@@ -1890,7 +1919,7 @@ export class ModelRegistry {
 					// we successfully recover the upstream model identity.
 					cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
 					contextWindow: reference?.contextWindow ?? 128000,
-					maxTokens: reference?.maxTokens ?? 8192,
+					maxTokens: reference?.maxTokens ?? discoveryDefaultMaxTokens(api),
 					headers,
 					// OpenAI-compat fields are no-ops on anthropic models; the
 					// Anthropic SDK ignores them. Provider-level disableStrictTools

package/src/config/settings-schema.ts

@@ -1966,6 +1966,16 @@ export const SETTINGS_SCHEMA = {
 		},
 	},
 
+	"lsp.diagnosticsDeduplicate": {
+		type: "boolean",
+		default: true,
+		ui: {
+			tab: "editing",
+			label: "Deduplicate Diagnostics",
+			description: "Suppress post-edit LSP diagnostics already shown for a file; only surface new or changed ones",
+		},
+	},
+
 	// Bash interceptor
 	"bashInterceptor.enabled": {
 		type: "boolean",
@@ -2884,7 +2894,7 @@ export const SETTINGS_SCHEMA = {
 					label: "Auto",
 					description: "Preferred web-search provider",
 				},
-				{ value: "exa", label: "Exa", description: "Uses Exa API when EXA_API_KEY is set; falls back to Exa MCP" },
+				{ value: "exa", label: "Exa", description: "Requires EXA_API_KEY" },
 				{ value: "brave", label: "Brave", description: "Requires BRAVE_API_KEY" },
 				{ value: "jina", label: "Jina", description: "Requires JINA_API_KEY" },
 				{ value: "kimi", label: "Kimi", description: "Requires MOONSHOT_SEARCH_API_KEY or MOONSHOT_API_KEY" },
@@ -2910,7 +2920,7 @@ export const SETTINGS_SCHEMA = {
 				},
 				{ value: "zai", label: "Z.AI", description: "Calls Z.AI webSearchPrime MCP" },
 				{ value: "tavily", label: "Tavily", description: "Requires TAVILY_API_KEY" },
-				{ value: "kagi", label: "Kagi", description: "Requires KAGI_API_KEY and Kagi Search API beta access" },
+				{ value: "kagi", label: "Kagi", description: "Requires KAGI_API_KEY (Kagi V1 Search API)" },
 				{ value: "synthetic", label: "Synthetic", description: "Requires SYNTHETIC_API_KEY" },
 				{ value: "parallel", label: "Parallel", description: "Requires PARALLEL_API_KEY" },
 				{ value: "searxng", label: "SearXNG", description: "Requires SEARXNG_ENDPOINT or searxng.endpoint" },

package/src/config/settings.ts

@@ -365,6 +365,29 @@ export class Settings {
 		return cloned;
 	}
 
+	/**
+	 * Re-scope this instance to a new working directory *in place*: reload the
+	 * project layer (`.claude/settings.yml` etc.) from `cwd`, re-resolve
+	 * path-scoped settings against it, and re-fire side-effect hooks (theme,
+	 * symbols, tab width, …). Global settings and runtime overrides are preserved.
+	 *
+	 * Unlike {@link cloneForCwd}, this mutates the live instance, so every holder
+	 * (the `settings` proxy, the active session, controllers) observes the new
+	 * project scope without swapping references — used when the process changes
+	 * directory mid-run (`/move`, cross-project resume). No-op when `cwd` is
+	 * already the current scope.
+	 */
+	async reloadForCwd(cwd: string): Promise<void> {
+		const normalized = path.normalize(cwd);
+		if (normalized === this.#cwd) return;
+		this.#cwd = normalized;
+		if (this.#persist) {
+			this.#project = await this.#loadProjectSettings();
+		}
+		this.#rebuildMerged();
+		this.#fireAllHooks();
+	}
+
 	// ─────────────────────────────────────────────────────────────────────────
 	// Accessors
 	// ─────────────────────────────────────────────────────────────────────────

package/src/discovery/claude-plugins.ts

@@ -99,10 +99,8 @@ async function resolvePluginDir(
 async function loadSkills(ctx: LoadContext): Promise<LoadResult<Skill>> {
 	const items: Skill[] = [];
 	const warnings: string[] = [];
-
 	const { roots, warnings: rootWarnings } = await listClaudePluginRoots(ctx.home, ctx.cwd);
 	warnings.push(...rootWarnings);
-
 	const results = await Promise.all(
 		roots.map(async root => {
 			const { dir: skillsDir, warning } = await resolvePluginDir(root, ["skills"], "skills");
@@ -114,16 +112,16 @@ async function loadSkills(ctx: LoadContext): Promise<LoadResult<Skill>> {
 			return { root, result, warning };
 		}),
 	);
-
-	for (const { root, result, warning } of results) {
+	for (const { result, warning } of results) {
 		if (warning) warnings.push(warning);
-		for (const skill of result.items) {
-			if (root.plugin) skill.name = `${root.plugin}:${skill.name}`;
-			items.push(skill);
-		}
+		// Intentionally do NOT prefix skill names with `root.plugin`.
+		// The `plugin:name` format breaks skill:// URL parsing (colons are
+		// ambiguous with port separators) and is unintuitive for callers.
+		// Dedup-by-key in the capability layer already handles name collisions
+		// across providers using priority ordering.
+		items.push(...result.items);
 		if (result.warnings) warnings.push(...result.warnings);
 	}
-
 	return { items, warnings };
 }
 

package/src/discovery/claude.ts

@@ -269,6 +269,29 @@ function readClaudeCommandToggles(): { enableUser: boolean; enableProject: boole
 	}
 }
 
+function getClaudeRelativeCommandName(commandsDir: string, filePath: string): string {
+	return path.relative(commandsDir, filePath).replace(/\.md$/, "");
+}
+
+function addClaudeCommandNamespaceAliases(commands: SlashCommand[], commandsDir: string): SlashCommand[] {
+	const rootCommands: SlashCommand[] = [];
+	const nestedCommands: SlashCommand[] = [];
+	const aliases: SlashCommand[] = [];
+
+	for (const command of commands) {
+		const relativeName = getClaudeRelativeCommandName(commandsDir, command.path);
+		if (!/[\\/]/.test(relativeName)) {
+			rootCommands.push(command);
+			continue;
+		}
+
+		nestedCommands.push(command);
+		aliases.push({ ...command, name: relativeName.replace(/[\\/]+/g, ":") });
+	}
+
+	return nestedCommands.length === 0 ? commands : [...rootCommands, ...nestedCommands, ...aliases];
+}
+
 async function loadSlashCommands(ctx: LoadContext): Promise<LoadResult<SlashCommand>> {
 	const items: SlashCommand[] = [];
 	const warnings: string[] = [];
@@ -280,19 +303,17 @@ async function loadSlashCommands(ctx: LoadContext): Promise<LoadResult<SlashComm
 
 		const userResult = await loadFilesFromDir<SlashCommand>(ctx, userCommandsDir, PROVIDER_ID, "user", {
 			extensions: ["md"],
-			transform: (name, content, path, source) => {
-				const cmdName = name.replace(/\.md$/, "");
-				return {
-					name: cmdName,
-					path,
-					content,
-					level: "user",
-					_source: source,
-				};
-			},
+			recursive: true,
+			transform: (name, content, filePath, source) => ({
+				name: name.replace(/\.md$/, ""),
+				path: filePath,
+				content,
+				level: "user",
+				_source: source,
+			}),
 		});
 
-		items.push(...userResult.items);
+		items.push(...addClaudeCommandNamespaceAliases(userResult.items, userCommandsDir));
 		if (userResult.warnings) warnings.push(...userResult.warnings);
 	}
 
@@ -301,19 +322,17 @@ async function loadSlashCommands(ctx: LoadContext): Promise<LoadResult<SlashComm
 
 		const projectResult = await loadFilesFromDir<SlashCommand>(ctx, projectCommandsDir, PROVIDER_ID, "project", {
 			extensions: ["md"],
-			transform: (name, content, path, source) => {
-				const cmdName = name.replace(/\.md$/, "");
-				return {
-					name: cmdName,
-					path,
-					content,
-					level: "project",
-					_source: source,
-				};
-			},
+			recursive: true,
+			transform: (name, content, filePath, source) => ({
+				name: name.replace(/\.md$/, ""),
+				path: filePath,
+				content,
+				level: "project",
+				_source: source,
+			}),
 		});
 
-		items.push(...projectResult.items);
+		items.push(...addClaudeCommandNamespaceAliases(projectResult.items, projectCommandsDir));
 		if (projectResult.warnings) warnings.push(...projectResult.warnings);
 	}
 

package/src/edit/index.ts

@@ -10,6 +10,7 @@ import {
 	type WritethroughDeferredHandle,
 	writethroughNoop,
 } from "../lsp";
+import { getDiagnosticsLedger } from "../lsp/diagnostics-ledger";
 import applyPatchDescription from "../prompts/tools/apply-patch.md" with { type: "text" };
 import patchDescription from "../prompts/tools/patch.md" with { type: "text" };
 import replaceDescription from "../prompts/tools/replace.md" with { type: "text" };
@@ -102,7 +103,16 @@ function createEditWritethrough(session: ToolSession): WritethroughCallback {
 	const enableLsp = session.enableLsp ?? true;
 	const enableDiagnostics = enableLsp && session.settings.get("lsp.diagnosticsOnEdit");
 	const enableFormat = enableLsp && session.settings.get("lsp.formatOnWrite");
-	return enableLsp ? createLspWritethrough(session.cwd, { enableFormat, enableDiagnostics }) : writethroughNoop;
+	const dedup = enableDiagnostics && session.settings.get("lsp.diagnosticsDeduplicate");
+	return enableLsp
+		? createLspWritethrough(session.cwd, {
+				enableFormat,
+				enableDiagnostics,
+				transformDiagnostics: dedup
+					? (path, result) => getDiagnosticsLedger(session).reduce(path, result)
+					: undefined,
+			})
+		: writethroughNoop;
 }
 
 /** Run apply_patch file operations and aggregate their multi-file result. */
@@ -294,6 +304,7 @@ export class EditTool implements AgentTool<TInput> {
 	readonly #fuzzyThreshold: number;
 	readonly #writethrough: WritethroughCallback;
 	readonly #editMode?: EditMode;
+	readonly #dedupDiagnostics: boolean;
 	readonly #pendingDeferredFetches = new Map<string, AbortController>();
 
 	constructor(private readonly session: ToolSession) {
@@ -306,6 +317,10 @@ export class EditTool implements AgentTool<TInput> {
 		this.#editMode = resolveConfiguredEditMode(envEditVariant);
 		this.#allowFuzzy = resolveAllowFuzzy(session, editFuzzy);
 		this.#fuzzyThreshold = resolveFuzzyThreshold(session, editFuzzyThreshold);
+		this.#dedupDiagnostics =
+			(session.enableLsp ?? true) &&
+			session.settings.get("lsp.diagnosticsOnEdit") &&
+			session.settings.get("lsp.diagnosticsDeduplicate");
 		this.#writethrough = createEditWritethrough(session);
 	}
 
@@ -495,8 +510,13 @@ export class EditTool implements AgentTool<TInput> {
 	}
 
 	#injectLateDiagnostics(path: string, diagnostics: FileDiagnosticsResult): void {
-		const summary = diagnostics.summary ?? "";
-		const lines = diagnostics.messages ?? [];
+		const effective = this.#dedupDiagnostics
+			? getDiagnosticsLedger(this.session).reduce(path, diagnostics)
+			: diagnostics;
+		if (this.#dedupDiagnostics && effective.messages.length === 0) return;
+
+		const summary = effective.summary ?? "";
+		const lines = effective.messages ?? [];
 		const body = [`Late LSP diagnostics for ${path} (arrived after the edit tool returned):`, summary, ...lines]
 			.filter(Boolean)
 			.join("\n");