@oh-my-pi/pi-coding-agent 16.0.1 → 16.0.2

package/dist/types/config/model-resolver.d.ts

@@ -37,7 +37,21 @@ export declare function parseModelString(modelStr: string): {
  * Format a model as "provider/modelId" string.
  */
 export declare function formatModelString(model: Model<Api>): string;
+export declare function formatModelStringWithRouting(model: Model<Api>): string;
 export declare function formatModelSelectorValue(selector: string, thinkingLevel: ThinkingLevel | undefined): string;
+/**
+ * Split a trailing `@<upstream>` provider-routing selector off a model pattern.
+ *
+ * `openrouter/z-ai/glm-4.7@cerebras` -> base `openrouter/z-ai/glm-4.7`, upstream
+ * `cerebras`. A `:thinking` suffix after the slug is kept on the base
+ * (`...@cerebras:high` -> base `...:high`). Returns undefined when there is no
+ * `@` or the suffix is not a bare provider slug, so model ids that legitimately
+ * contain `@` (`claude-opus-4-8@default`, `workers-ai/@cf/...`) are never split.
+ */
+export declare function splitUpstreamRouting(pattern: string): {
+    base: string;
+    upstream: string;
+} | undefined;
 export declare function resolveProviderModelReference(provider: string, modelId: string, availableModels: readonly Model<Api>[]): Model<Api> | undefined;
 export interface ModelMatchPreferences {
     /** Most-recently-used model keys (provider/modelId) to prefer when ambiguous. */

package/dist/types/exec/non-interactive-env.d.ts

@@ -1 +1,3 @@
 export declare const NON_INTERACTIVE_ENV: Readonly<Record<string, string>>;
+/** Builds the per-command environment for non-interactive child processes. */
+export declare function buildNonInteractiveEnv(overrides?: Record<string, string>, baseEnv?: Record<string, string | undefined>, platform?: NodeJS.Platform): Record<string, string>;

package/dist/types/session/messages.d.ts

@@ -55,6 +55,9 @@ export declare function isSilentAbort(errorMessage: string | undefined): boolean
 export declare const USER_INTERRUPT_LABEL = "Interrupted by user";
 export declare function isUserInterruptAbort(errorMessage: string | undefined): boolean;
 export declare function shouldRenderAbortReason(errorMessage: string | undefined): boolean;
+/** Sentinel `errorMessage` the agent stamps on any abort that carried no custom
+ *  reason (bare `abort()`). Renderers treat it as "no specific reason given". */
+export declare const GENERIC_ABORT_SENTINEL = "Request was aborted";
 /** Resolve the operator-facing label for an aborted assistant turn. A custom
  *  abort reason threaded onto `errorMessage` is returned verbatim; aborts with
  *  no threaded reason fall back to the retry-aware generic label. Call

package/dist/types/utils/markit.d.ts

@@ -3,5 +3,13 @@ export interface MarkitConversionResult {
     ok: boolean;
     error?: string;
 }
+interface MuPdfWasmModuleConfig {
+    print?: (...values: unknown[]) => void;
+    printErr?: (...values: unknown[]) => void;
+}
+declare global {
+    var $libmupdf_wasm_Module: MuPdfWasmModuleConfig | undefined;
+}
 export declare function convertFileWithMarkit(filePath: string, signal?: AbortSignal): Promise<MarkitConversionResult>;
 export declare function convertBufferWithMarkit(buffer: Uint8Array, extension: string, signal?: AbortSignal): Promise<MarkitConversionResult>;
+export {};

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "16.0.1",
+	"version": "16.0.2",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -47,17 +47,17 @@
 		"@agentclientprotocol/sdk": "0.25.0",
 		"@babel/parser": "^7.29.7",
 		"@mozilla/readability": "^0.6.0",
-		"@oh-my-pi/hashline": "16.0.1",
-		"@oh-my-pi/omp-stats": "16.0.1",
-		"@oh-my-pi/pi-agent-core": "16.0.1",
-		"@oh-my-pi/pi-ai": "16.0.1",
-		"@oh-my-pi/pi-catalog": "16.0.1",
-		"@oh-my-pi/pi-mnemopi": "16.0.1",
-		"@oh-my-pi/pi-natives": "16.0.1",
-		"@oh-my-pi/pi-tui": "16.0.1",
-		"@oh-my-pi/pi-utils": "16.0.1",
-		"@oh-my-pi/pi-wire": "16.0.1",
-		"@oh-my-pi/snapcompact": "16.0.1",
+		"@oh-my-pi/hashline": "16.0.2",
+		"@oh-my-pi/omp-stats": "16.0.2",
+		"@oh-my-pi/pi-agent-core": "16.0.2",
+		"@oh-my-pi/pi-ai": "16.0.2",
+		"@oh-my-pi/pi-catalog": "16.0.2",
+		"@oh-my-pi/pi-mnemopi": "16.0.2",
+		"@oh-my-pi/pi-natives": "16.0.2",
+		"@oh-my-pi/pi-tui": "16.0.2",
+		"@oh-my-pi/pi-utils": "16.0.2",
+		"@oh-my-pi/pi-wire": "16.0.2",
+		"@oh-my-pi/snapcompact": "16.0.2",
 		"@opentelemetry/api": "^1.9.1",
 		"@opentelemetry/context-async-hooks": "^2.7.1",
 		"@opentelemetry/exporter-trace-otlp-proto": "^0.218.0",

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

@@ -2,6 +2,7 @@ import { describe, expect, it, vi } from "bun:test";
 import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
 import { createAdvisorMessageCard } from "../../modes/components/advisor-message";
 import { getThemeByName } from "../../modes/theme/theme";
+import { formatSessionDumpText } from "../../session/session-dump-format";
 import { formatSessionHistoryMarkdown } from "../../session/session-history-format";
 import { YieldQueue } from "../../session/yield-queue";
 import {
@@ -583,4 +584,47 @@ describe("advisor", () => {
 			expect(text).toContain("truncated.");
 		});
 	});
+	describe("formatSessionDumpText raw thinking", () => {
+		it("does not nest literal thinking envelopes", () => {
+			const md = formatSessionDumpText({
+				messages: [
+					{
+						role: "assistant",
+						content: [
+							{
+								type: "thinking",
+								thinking: "<thinking>\nCheck logs before accepting container health.\n</thinking>",
+							},
+						],
+						timestamp: Date.now(),
+					} as AgentMessage,
+				],
+				thinkingLevel: "high",
+			});
+
+			expect(md).toContain("Assistant: <thinking>\nCheck logs before accepting container health.\n</thinking>");
+			expect(md).not.toContain("<thinking>\n<thinking>");
+		});
+
+		it("unwraps sibling literal thinking envelopes independently", () => {
+			const md = formatSessionDumpText({
+				messages: [
+					{
+						role: "assistant",
+						content: [
+							{ type: "thinking", thinking: "<thinking>\nfirst\n</thinking>" },
+							{ type: "toolCall", id: "tc-1", name: "read", arguments: { path: "file.ts" } },
+							{ type: "thinking", thinking: "<thinking>\nsecond\n</thinking>" },
+						],
+						timestamp: Date.now(),
+					} as AgentMessage,
+				],
+				tools: [{ name: "read", description: "Read a file", parameters: { type: "object" } }],
+				thinkingLevel: "high",
+			});
+
+			expect(md).toContain("Assistant: <thinking>\nfirst\nsecond\n</thinking>");
+			expect(md).not.toContain("first\n</thinking>\n<thinking>\nsecond");
+		});
+	});
 });

package/src/cli/args.ts

@@ -280,6 +280,7 @@ export function getExtraHelpText(): string {
   MISTRAL_API_KEY            - Mistral models
   ZAI_API_KEY                - z.ai models (ZhipuAI/GLM)
   UMANS_AI_CODING_PLAN_API_KEY - Umans AI Coding Plan models
+  UMANS_WEBSEARCH_PROVIDER    - Umans gateway web search backend (native or exa)
   MINIMAX_API_KEY            - MiniMax models
   OPENCODE_API_KEY           - OpenCode Zen/OpenCode Go models
   CURSOR_ACCESS_TOKEN        - Cursor AI models

package/src/config/model-resolver.ts

@@ -92,6 +92,33 @@ export function formatModelString(model: Model<Api>): string {
 	return `${model.provider}/${model.id}`;
 }
 
+function getSingleRoutingOnly(routing: unknown): string | undefined {
+	if (!routing || typeof routing !== "object" || !("only" in routing) || !Array.isArray(routing.only)) {
+		return undefined;
+	}
+	if (routing.only.length !== 1) return undefined;
+	const upstream = routing.only[0];
+	return typeof upstream === "string" && upstream ? upstream : undefined;
+}
+
+function getSingleUpstreamRoute(model: Model<Api>): string | undefined {
+	const compat = model.compat;
+	if (!compat || typeof compat !== "object") return undefined;
+	if (modelMatchesHost(model, "vercelAIGateway") && "vercelGatewayRouting" in compat) {
+		return getSingleRoutingOnly(compat.vercelGatewayRouting);
+	}
+	if (modelMatchesHost(model, "openrouter") && "openRouterRouting" in compat) {
+		return getSingleRoutingOnly(compat.openRouterRouting);
+	}
+	return undefined;
+}
+
+export function formatModelStringWithRouting(model: Model<Api>): string {
+	const selector = formatModelString(model);
+	const upstream = getSingleUpstreamRoute(model);
+	return upstream ? `${selector}@${upstream}` : selector;
+}
+
 export function formatModelSelectorValue(selector: string, thinkingLevel: ThinkingLevel | undefined): string {
 	return thinkingLevel && thinkingLevel !== ThinkingLevel.Inherit ? `${selector}:${thinkingLevel}` : selector;
 }
@@ -161,7 +188,7 @@ const UPSTREAM_ROUTING_SLUG = /^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/i;
  * `@` or the suffix is not a bare provider slug, so model ids that legitimately
  * contain `@` (`claude-opus-4-8@default`, `workers-ai/@cf/...`) are never split.
  */
-function splitUpstreamRouting(pattern: string): { base: string; upstream: string } | undefined {
+export function splitUpstreamRouting(pattern: string): { base: string; upstream: string } | undefined {
 	const at = pattern.lastIndexOf("@");
 	if (at <= 0) return undefined;
 	const rest = pattern.slice(at + 1);
@@ -481,6 +508,13 @@ function matchModel(
 			// The prefix is not a known provider in this candidate set, so treat the
 			// slash as part of the raw model ID and continue with generic matching.
 		} else {
+			// Let the routing fallback apply `@upstream` before fuzzy matching can consume the
+			// slug — but only for aggregator providers (OpenRouter / Vercel Gateway). Other
+			// providers have ids that legitimately end in `@` (Vertex `claude-opus-4-8@default`),
+			// and the fallback never routes them, so they must keep fuzzy matching.
+			if (splitUpstreamRouting(modelId) && providerModels.some(supportsUpstreamRouting)) {
+				return undefined;
+			}
 			const scored = providerModels
 				.map(model => ({ model, match: fuzzyMatch(modelId, model.id) }))
 				.filter(entry => entry.match.matches);

package/src/discovery/github.ts

@@ -11,7 +11,7 @@
  *
  * Capabilities:
  * - context-files: copilot-instructions.md in .github/ and ~/.copilot/; AGENTS.md in each COPILOT_CUSTOM_INSTRUCTIONS_DIRS
- * - instructions: *.instructions.md under .github/instructions/ (project) and <dir>/.github/instructions/ for each custom dir (applyTo frontmatter)
+ * - rules: *.instructions.md under .github/instructions/ and <dir>/.github/instructions/ for each custom dir (applyTo frontmatter)
  * - prompts: *.prompt.md in .github/prompts/ (VS Code Copilot prompt files)
  * - skills: <name>/SKILL.md in .github/skills/ (GitHub Agent Skills layout)
  */
@@ -22,10 +22,12 @@ import { type ContextFile, contextFileCapability } from "../capability/context-f
 import { readFile } from "../capability/fs";
 import { type Instruction, instructionCapability } from "../capability/instruction";
 import { type Prompt, promptCapability } from "../capability/prompt";
+import { type Rule, ruleCapability } from "../capability/rule";
 import { type Skill, skillCapability } from "../capability/skill";
 import type { LoadContext, LoadResult, SourceMeta } from "../capability/types";
 
 import {
+	buildRuleFromMarkdown,
 	calculateDepth,
 	createSourceMeta,
 	getProjectPath,
@@ -152,6 +154,85 @@ function transformInstruction(name: string, content: string, filePath: string, s
 	};
 }
 
+// =============================================================================
+// Rules
+// =============================================================================
+
+async function loadRules(ctx: LoadContext): Promise<LoadResult<Rule>> {
+	const items: Rule[] = [];
+	const warnings: string[] = [];
+
+	const load = async (dir: string, level: "user" | "project") => {
+		const applyToWarnings: string[] = [];
+		const result = await loadFilesFromDir<Rule>(ctx, dir, PROVIDER_ID, level, {
+			extensions: ["md"],
+			transform: (name, content, filePath, source) =>
+				transformInstructionRule(name, content, filePath, source, applyToWarnings),
+			recursive: true,
+		});
+		items.push(...result.items);
+		if (result.warnings) warnings.push(...result.warnings);
+		warnings.push(...applyToWarnings);
+	};
+
+	const instructionsDir = getProjectPath(ctx, "github", "instructions");
+	if (instructionsDir) {
+		await load(instructionsDir, "project");
+	}
+
+	for (const dir of copilotCustomInstructionDirs()) {
+		await load(path.join(dir, ".github", "instructions"), "user");
+	}
+
+	return { items, warnings };
+}
+
+function transformInstructionRule(
+	name: string,
+	content: string,
+	filePath: string,
+	source: SourceMeta,
+	warnings: string[],
+): Rule | null {
+	if (!name.endsWith(".instructions.md")) {
+		return null;
+	}
+
+	const { frontmatter } = parseFrontmatter(content, { source: filePath });
+	const applyToGlobs = normalizeApplyToGlobs(frontmatter.applyTo);
+	if (!applyToGlobs) {
+		warnings.push(`Missing applyTo in ${filePath}; loaded without GitHub glob scoping.`);
+	}
+
+	const rule = buildRuleFromMarkdown(name, content, filePath, source, {
+		stripNamePattern: /\.instructions\.md$/,
+	});
+	if (applyToGlobs?.some(isAlwaysApplyGlob)) {
+		return { ...rule, alwaysApply: true, globs: undefined };
+	}
+
+	const description = rule.description ?? describeInstructionRule(applyToGlobs);
+	return { ...rule, alwaysApply: false, globs: applyToGlobs, description };
+}
+
+function normalizeApplyToGlobs(value: unknown): string[] | undefined {
+	// GitHub documents applyTo as a single comma-separated string (e.g.
+	// "**/*.ts,**/*.tsx"); also tolerate a YAML array of such strings.
+	const raw = Array.isArray(value) ? value : [value];
+	const globs = raw.flatMap(item => (typeof item === "string" ? parseCSV(item) : []));
+	return globs.length > 0 ? globs : undefined;
+}
+
+function isAlwaysApplyGlob(glob: string): boolean {
+	// GitHub treats "*", "**", and "**/*" as matching every file.
+	return glob === "*" || glob === "**" || glob === "**/*";
+}
+
+function describeInstructionRule(globs: string[] | undefined): string {
+	if (!globs) return "GitHub Copilot instructions without applyTo metadata";
+	return `GitHub Copilot instructions for ${globs.join(", ")}`;
+}
+
 // =============================================================================
 // Prompts
 // =============================================================================
@@ -232,6 +313,13 @@ registerProvider(instructionCapability.id, {
 	load: loadInstructions,
 });
 
+registerProvider<Rule>(ruleCapability.id, {
+	id: PROVIDER_ID,
+	displayName: DISPLAY_NAME,
+	description: "Load *.instructions.md from .github/instructions/ as Copilot-scoped rules",
+	priority: PRIORITY,
+	load: loadRules,
+});
 registerProvider<Skill>(skillCapability.id, {
 	id: PROVIDER_ID,
 	displayName: DISPLAY_NAME,

package/src/exec/bash-executor.ts

@@ -11,7 +11,7 @@ import { Settings, type ShellMinimizerSettings } from "../config/settings";
 import { OutputSink } from "../session/streaming-output";
 import { resolveOutputMaxColumns, resolveOutputSinkHeadBytes } from "../tools/output-meta";
 import { getOrCreateSnapshot } from "../utils/shell-snapshot";
-import { NON_INTERACTIVE_ENV } from "./non-interactive-env";
+import { buildNonInteractiveEnv } from "./non-interactive-env";
 
 export interface BashExecutorOptions {
 	cwd?: string;
@@ -184,7 +184,7 @@ export async function executeBash(command: string, options?: BashExecutorOptions
 	const minimizer = buildMinimizerOptions(settings.getGroup("shellMinimizer"));
 
 	const commandCwd = await resolveShellCwd(options?.cwd);
-	const commandEnv = options?.env ? { ...NON_INTERACTIVE_ENV, ...options.env } : NON_INTERACTIVE_ENV;
+	const commandEnv = buildNonInteractiveEnv(options?.env);
 
 	// Apply command prefix if configured
 	const prefixedCommand = prefix ? `${prefix} ${command}` : command;

package/src/exec/non-interactive-env.ts

@@ -46,3 +46,74 @@ export const NON_INTERACTIVE_ENV: Readonly<Record<string, string>> = {
 	COMPOSER_NO_INTERACTION: "1",
 	CLOUDSDK_CORE_DISABLE_PROMPTS: "1",
 };
+
+const WINDOWS_UTF8_ENV_DEFAULT_GROUPS: ReadonlyArray<ReadonlyArray<readonly [key: string, value: string]>> = [
+	[
+		["PYTHONIOENCODING", "utf-8"],
+		["PYTHONUTF8", "1"],
+	],
+	[
+		["LANG", "C.UTF-8"],
+		["LC_ALL", "C.UTF-8"],
+	],
+];
+
+function hasEnvValue(
+	env: Record<string, string | undefined> | undefined,
+	key: string,
+	platform: NodeJS.Platform,
+): boolean {
+	if (!env) return false;
+	if (platform !== "win32") return env[key] !== undefined;
+
+	for (const [existingKey, value] of Object.entries(env)) {
+		if (value !== undefined && existingKey.toLowerCase() === key.toLowerCase()) {
+			return true;
+		}
+	}
+	return false;
+}
+
+function hasLocaleEnvValue(env: Record<string, string | undefined> | undefined, platform: NodeJS.Platform): boolean {
+	if (!env) return false;
+	for (const [key, value] of Object.entries(env)) {
+		if (value === undefined) continue;
+		const normalizedKey = platform === "win32" ? key.toUpperCase() : key;
+		if (normalizedKey === "LANG" || normalizedKey.startsWith("LC_")) return true;
+	}
+	return false;
+}
+
+function hasEnvGroupValue(
+	env: Record<string, string | undefined> | undefined,
+	group: ReadonlyArray<readonly [key: string, value: string]>,
+	platform: NodeJS.Platform,
+): boolean {
+	if (group.some(([key]) => key === "LC_ALL") && hasLocaleEnvValue(env, platform)) return true;
+	for (const [key] of group) {
+		if (hasEnvValue(env, key, platform)) return true;
+	}
+	return false;
+}
+
+/** Builds the per-command environment for non-interactive child processes. */
+export function buildNonInteractiveEnv(
+	overrides?: Record<string, string>,
+	baseEnv: Record<string, string | undefined> = Bun.env,
+	platform: NodeJS.Platform = process.platform,
+): Record<string, string> {
+	if (platform !== "win32") {
+		return overrides ? { ...NON_INTERACTIVE_ENV, ...overrides } : NON_INTERACTIVE_ENV;
+	}
+
+	const env: Record<string, string> = { ...NON_INTERACTIVE_ENV };
+	for (const group of WINDOWS_UTF8_ENV_DEFAULT_GROUPS) {
+		if (hasEnvGroupValue(baseEnv, group, platform) || hasEnvGroupValue(overrides, group, platform)) {
+			continue;
+		}
+		for (const [key, value] of group) {
+			env[key] = value;
+		}
+	}
+	return overrides ? { ...env, ...overrides } : env;
+}

package/src/extensibility/extensions/runner.ts

@@ -543,7 +543,9 @@ export class ExtensionRunner {
 			event.type === "session_before_tree"
 		);
 	}
-
+	#isSessionShutdownEvent(event: RunnerEmitEvent): event is Extract<RunnerEmitEvent, { type: "session_shutdown" }> {
+		return event.type === "session_shutdown";
+	}
 	async #runHandlerWithTimeout<TEvent extends { type: string }, TResult>(
 		handler: (event: TEvent, ctx: ExtensionContext) => Promise<TResult | undefined> | TResult | undefined,
 		event: TEvent,
@@ -588,6 +590,20 @@ export class ExtensionRunner {
 		const ctx = this.createContext();
 		let result: SessionBeforeEventResult | SessionCompactingResult | undefined;
 
+		if (this.#isSessionShutdownEvent(event)) {
+			const timeoutMs = handlerTimeoutForEvent(event.type);
+			const promises: Promise<unknown>[] = [];
+			for (const ext of this.extensions) {
+				const handlers = ext.handlers.get(event.type);
+				if (!handlers || handlers.length === 0) continue;
+				for (const handler of handlers) {
+					promises.push(this.#runHandlerWithTimeout(handler, event, ctx, ext, timeoutMs));
+				}
+			}
+			await Promise.all(promises);
+			return result as RunnerEmitResult<TEvent>;
+		}
+
 		for (const ext of this.extensions) {
 			const handlers = ext.handlers.get(event.type);
 			if (!handlers || handlers.length === 0) continue;