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

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/eval/agent-bridge.ts

@@ -10,6 +10,7 @@ import { resolveAgentModelPatterns } from "../config/model-resolver";
 import type { LocalProtocolOptions } from "../internal-urls";
 import { MCPManager } from "../mcp/manager";
 import subagentUserPromptTemplate from "../prompts/system/subagent-user-prompt.md" with { type: "text" };
+import { MAIN_AGENT_ID } from "../registry/agent-registry";
 import * as taskDiscovery from "../task/discovery";
 import * as taskExecutor from "../task/executor";
 import { AgentOutputManager } from "../task/output-manager";
@@ -288,6 +289,7 @@ export async function runEvalAgent(args: unknown, options: EvalAgentBridgeOption
 			parentHindsightSessionState: options.session.getHindsightSessionState?.(),
 			parentMnemopiSessionState: options.session.getMnemopiSessionState?.(),
 			parentTelemetry: options.session.getTelemetry?.(),
+			parentAgentId: options.session.getAgentId?.() ?? MAIN_AGENT_ID,
 			// Deliberately omit parentEvalSessionId: the parent's Python kernel is
 			// blocked on this bridge call, so sharing the eval session would deadlock
 			// (subagent queues behind the parent's in-flight execution, parent waits

package/src/eval/js/context-manager.ts

@@ -564,7 +564,7 @@ function spawnInlineWorker(): WorkerHandle {
 		},
 		close: () => {},
 	};
-	new WorkerCore(workerTransport);
+	const core = new WorkerCore(workerTransport);
 	return {
 		mode: "inline",
 		send: msg =>
@@ -600,6 +600,7 @@ function spawnInlineWorker(): WorkerHandle {
 		async terminate() {
 			hostListeners.clear();
 			workerListeners.clear();
+			core.dispose();
 		},
 	};
 }

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

@@ -55,6 +55,32 @@ export interface RuntimeOptions {
 const BASE64_STRICT_RE = /^[A-Za-z0-9+/]+={0,2}$/;
 const DECIMAL_CSV_RE = /^\d{1,3}(?:,\d{1,3})*$/;
 
+const PRELUDE_GLOBAL_KEYS = [
+	"__omp_js_prelude_loaded__",
+	"console",
+	"print",
+	"display",
+	"tool",
+	"completion",
+	"output",
+	"agent",
+	"parallel",
+	"pipeline",
+	"log",
+	"phase",
+	"budget",
+	"__pool",
+	"read",
+	"write",
+	"append",
+	"sort",
+	"uniq",
+	"counter",
+	"diff",
+	"tree",
+	"env",
+];
+
 function isStrictBase64(s: string): boolean {
 	if (s.length === 0 || s.length % 4 !== 0) return false;
 	return BASE64_STRICT_RE.test(s);
@@ -125,6 +151,22 @@ function describeDataType(data: unknown): string {
  * concern.
  */
 export class JsRuntime {
+	#globalOwner = Symbol("JsRuntime globals");
+	#ownedGlobalKeys = new Set<string>();
+	#disposed = false;
+	#runHookResolver = () => this.#als.getStore()?.hooks;
+
+	#ownGlobal(key: string): void {
+		if (this.#ownedGlobalKeys.has(key)) return;
+		claimGlobalKey(key, this.#globalOwner);
+		this.#ownedGlobalKeys.add(key);
+	}
+
+	#activateGlobals(action: string): void {
+		if (this.#disposed) throw new Error(`Cannot ${action} on a disposed JS runtime`);
+		activateGlobalOwner(this.#globalOwner, this.#ownedGlobalKeys, action);
+	}
+
 	readonly helpers: HelperBundle;
 	#cwd: string;
 	readonly sessionId: string;
@@ -153,6 +195,7 @@ export class JsRuntime {
 	}
 
 	setCwd(cwd: string): void {
+		this.#activateGlobals("set cwd");
 		this.#cwd = cwd;
 		const session = (globalThis as { __omp_session__?: { cwd?: string } }).__omp_session__;
 		if (session) session.cwd = cwd;
@@ -164,6 +207,7 @@ export class JsRuntime {
 	 * cleanup it wants.
 	 */
 	setRunScope(scope: Record<string, unknown>): void {
+		this.#activateGlobals("set run scope");
 		Object.assign(globalThis, scope);
 	}
 
@@ -173,6 +217,8 @@ export class JsRuntime {
 		hooks: RuntimeHooks,
 		options: { runId?: string; cwd?: string } = {},
 	): Promise<unknown> {
+		this.#activateGlobals("run code");
+		const leaveRun = enterGlobalRun(this.#globalOwner, "run code");
 		const context: RunContext = {
 			runId: options.runId ?? crypto.randomUUID(),
 			hooks,
@@ -180,21 +226,25 @@ export class JsRuntime {
 			finalExpressionSet: false,
 			finalExpressionValue: undefined,
 		};
-		return await this.#als.run(context, async () => {
-			const wrapped = await wrapCode(code);
-			const value = indirectEval(wrapped.source, filename);
-			if (wrapped.finalExpressionReturned) {
-				const awaited = await awaitMaybePromise(value);
-				if (context.finalExpressionSet) {
-					const finalValue = context.finalExpressionValue;
-					context.finalExpressionSet = false;
-					context.finalExpressionValue = undefined;
-					return await awaitMaybePromise(finalValue);
+		try {
+			return await this.#als.run(context, async () => {
+				const wrapped = await wrapCode(code);
+				const value = indirectEval(wrapped.source, filename);
+				if (wrapped.finalExpressionReturned) {
+					const awaited = await awaitMaybePromise(value);
+					if (context.finalExpressionSet) {
+						const finalValue = context.finalExpressionValue;
+						context.finalExpressionSet = false;
+						context.finalExpressionValue = undefined;
+						return await awaitMaybePromise(finalValue);
+					}
+					return awaited;
 				}
-				return awaited;
-			}
-			return await awaitMaybePromise(value);
-		});
+				return await awaitMaybePromise(value);
+			});
+		} finally {
+			leaveRun();
+		}
 	}
 
 	displayValue(value: unknown, hooks: RuntimeHooks | undefined = this.#als.getStore()?.hooks): void {
@@ -338,13 +388,137 @@ export class JsRuntime {
 			createRequire,
 			fs,
 		};
+
+		const allGlobalKeys = new Set<string>([
+			...Object.keys(injected),
+			...Object.keys(extraGlobals ?? {}),
+			...PRELUDE_GLOBAL_KEYS,
+		]);
+
+		for (const key of allGlobalKeys) {
+			this.#ownGlobal(key);
+		}
+
 		Object.assign(globalThis, injected, extraGlobals ?? {});
 		// Prelude assigns console bridge + short aliases (`read`, `write`, `tool`, `display`, ...)
 		// onto globalThis. Must run after helpers are in place.
 		indirectEval(JAVASCRIPT_PRELUDE_SOURCE);
-		RUN_HOOK_RESOLVERS.add(() => this.#als.getStore()?.hooks);
+		for (const key of allGlobalKeys) recordGlobalValue(key, this.#globalOwner);
+		RUN_HOOK_RESOLVERS.add(this.#runHookResolver);
 		patchStdioOnce();
 	}
+
+	dispose(): void {
+		if (this.#disposed) return;
+		this.#disposed = true;
+		RUN_HOOK_RESOLVERS.delete(this.#runHookResolver);
+		for (const key of this.#ownedGlobalKeys) releaseGlobalKey(key, this.#globalOwner);
+		this.#ownedGlobalKeys.clear();
+	}
+}
+
+interface GlobalSnapshot {
+	exists: boolean;
+	value: unknown;
+}
+
+interface GlobalOwnerEntry {
+	owner: symbol;
+	value: unknown;
+}
+
+interface GlobalStack {
+	base: GlobalSnapshot;
+	entries: GlobalOwnerEntry[];
+}
+
+// Inline fallback and cmux tabs can create multiple JsRuntime instances in one Bun realm.
+// Track reserved helper globals by owner so disposing one runtime restores the next active
+// owner (or the original process global after the last owner), not a stale snapshot.
+const GLOBAL_STACKS = new Map<string, GlobalStack>();
+
+function snapshotGlobal(key: string): GlobalSnapshot {
+	return {
+		exists: key in globalThis,
+		value: (globalThis as Record<string, unknown>)[key],
+	};
+}
+
+function restoreGlobal(key: string, state: GlobalSnapshot): void {
+	if (state.exists) {
+		(globalThis as Record<string, unknown>)[key] = state.value;
+	} else {
+		delete (globalThis as Record<string, unknown>)[key];
+	}
+}
+
+function claimGlobalKey(key: string, owner: symbol): void {
+	let stack = GLOBAL_STACKS.get(key);
+	if (!stack) {
+		stack = { base: snapshotGlobal(key), entries: [] };
+		GLOBAL_STACKS.set(key, stack);
+	}
+	stack.entries.push({ owner, value: (globalThis as Record<string, unknown>)[key] });
+}
+
+function recordGlobalValue(key: string, owner: symbol): void {
+	const stack = GLOBAL_STACKS.get(key);
+	const entry = stack?.entries.findLast(item => item.owner === owner);
+	if (entry) entry.value = (globalThis as Record<string, unknown>)[key];
+}
+
+function releaseGlobalKey(key: string, owner: symbol): void {
+	const stack = GLOBAL_STACKS.get(key);
+	if (!stack) return;
+	const index = stack.entries.findIndex(entry => entry.owner === owner);
+	if (index === -1) return;
+	const wasTop = index === stack.entries.length - 1;
+	stack.entries.splice(index, 1);
+	if (!wasTop) return;
+	const next = stack.entries.at(-1);
+	if (next) {
+		(globalThis as Record<string, unknown>)[key] = next.value;
+		return;
+	}
+	restoreGlobal(key, stack.base);
+	GLOBAL_STACKS.delete(key);
+}
+
+// Plain globalThis cannot safely serve two different runtimes at the same instant:
+// helpers dereference reserved globals on every call. Sequential cmux tab revisits
+// re-activate their owner stack; overlapping cross-runtime runs fail explicitly.
+let activeGlobalRunOwner: symbol | null = null;
+let activeGlobalRunDepth = 0;
+
+function assertCanUseGlobalOwner(owner: symbol, action: string): void {
+	if (activeGlobalRunOwner === null || activeGlobalRunOwner === owner) return;
+	throw new Error(`Cannot ${action} while another same-realm JS runtime is running`);
+}
+
+function activateGlobalOwner(owner: symbol, keys: Iterable<string>, action: string): void {
+	assertCanUseGlobalOwner(owner, action);
+	for (const key of keys) {
+		const stack = GLOBAL_STACKS.get(key);
+		const index = stack?.entries.findIndex(entry => entry.owner === owner) ?? -1;
+		if (!stack || index === -1) throw new Error(`Cannot ${action} on a disposed JS runtime`);
+		const entry = stack.entries[index];
+		stack.entries.splice(index, 1);
+		stack.entries.push(entry);
+		(globalThis as Record<string, unknown>)[key] = entry.value;
+	}
+}
+
+function enterGlobalRun(owner: symbol, action: string): () => void {
+	assertCanUseGlobalOwner(owner, action);
+	activeGlobalRunOwner = owner;
+	activeGlobalRunDepth++;
+	let left = false;
+	return () => {
+		if (left) return;
+		left = true;
+		activeGlobalRunDepth--;
+		if (activeGlobalRunDepth === 0) activeGlobalRunOwner = null;
+	};
 }
 
 /** Resolvers for each live runtime's active-run hooks (one per JsRuntime instance). */

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

@@ -124,9 +124,28 @@ export class WorkerCore {
 			active.pendingTools.clear();
 		}
 		this.#runs.clear();
+		this.#runtime?.dispose?.();
 		this.#runtime = null;
 		this.#transport.send({ type: "closed" });
 		this.#unsubscribe();
 		this.#transport.close();
 	}
+
+	dispose(): void {
+		for (const active of this.#runs.values()) {
+			for (const pending of active.pendingTools.values()) {
+				pending.reject(new ToolError("JS worker closed"));
+			}
+			active.pendingTools.clear();
+		}
+		this.#runs.clear();
+		this.#runtime?.dispose?.();
+		this.#runtime = null;
+		this.#unsubscribe();
+		try {
+			this.#transport.close();
+		} catch {
+			// Ignore
+		}
+	}
 }

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/export/html/index.ts

@@ -242,7 +242,7 @@ export async function exportFromFile(inputPath: string, options?: ExportOptions
 
 	let sm: SessionManager;
 	try {
-		sm = await SessionManager.open(inputPath);
+		sm = await SessionManager.open(inputPath, undefined, undefined, { suppressBreadcrumb: true });
 	} catch (err) {
 		if (isEnoent(err)) throw new Error(`File not found: ${inputPath}`);
 		throw err;