@oh-my-pi/pi-coding-agent 16.2.6 → 16.2.7

package/src/system-prompt.test.ts

@@ -0,0 +1,158 @@
+import { describe, expect, it } from "bun:test";
+import * as fs from "node:fs/promises";
+import * as os from "node:os";
+import * as path from "node:path";
+
+interface ProbeRunResult {
+	elapsedMs: number;
+	childElapsedMs: number;
+	cached: unknown;
+	count: number;
+}
+
+async function runProbeScenario(options: {
+	runs: number;
+	sleepSeconds?: number;
+	holdStdoutOpen?: boolean;
+	descendantHoldsStdout?: boolean;
+	validOutput?: string;
+}): Promise<ProbeRunResult> {
+	const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "omp-gpu-probe-"));
+	try {
+		const binDir = path.join(tempRoot, "bin");
+		const cacheRoot = path.join(tempRoot, "cache");
+		const probeCountPath = path.join(tempRoot, "probe-count");
+		await fs.mkdir(binDir, { recursive: true });
+		await fs.mkdir(path.join(cacheRoot, "omp"), { recursive: true });
+		const lspciPath = path.join(binDir, "lspci");
+		await Bun.write(
+			lspciPath,
+			'#!/usr/bin/env sh\nprintf x >> "$OMP_GPU_PROBE_COUNT"\nif [ -n "$OMP_GPU_PROBE_VALID_OUTPUT" ]; then printf "%s\\n" "$OMP_GPU_PROBE_VALID_OUTPUT"; fi\nif [ "$OMP_GPU_PROBE_DESCENDANT_HOLDS_STDOUT" = "true" ]; then sleep "$OMP_GPU_PROBE_SLEEP" & exit 0; fi\nif [ "$OMP_GPU_PROBE_HOLD_STDOUT_OPEN" = "true" ]; then sleep "$OMP_GPU_PROBE_SLEEP" & wait "$!"; fi\nif [ -n "$OMP_GPU_PROBE_SLEEP" ]; then exec sleep "$OMP_GPU_PROBE_SLEEP"; fi\nexit 0\n',
+		);
+		await fs.chmod(lspciPath, 0o755);
+
+		const scenarioPath = path.join(tempRoot, "scenario.ts");
+		await Bun.write(
+			scenarioPath,
+			`import { getGpuCachePath, refreshDirsFromEnv } from ${JSON.stringify(path.resolve(import.meta.dir, "../../utils/src/index.ts"))};
+import { buildSystemPrompt } from ${JSON.stringify(path.join(import.meta.dir, "system-prompt.ts"))};
+
+refreshDirsFromEnv();
+const buildOptions = {
+	contextFiles: [],
+	skills: [],
+	toolNames: [],
+	workspaceTree: {
+		rootPath: process.cwd(),
+		rendered: "",
+		truncated: false,
+		totalLines: 0,
+		agentsMdFiles: [],
+	},
+	activeRepoContext: null,
+};
+const startedAt = performance.now();
+for (let index = 0; index < Number(process.env.OMP_GPU_PROBE_RUNS ?? "1"); index += 1) {
+	await buildSystemPrompt(buildOptions);
+}
+const cacheFile = Bun.file(getGpuCachePath());
+const cached = await cacheFile.exists() ? await cacheFile.json() : null;
+const countFile = Bun.file(process.env.OMP_GPU_PROBE_COUNT ?? "");
+const count = await countFile.exists() ? (await countFile.text()).length : 0;
+console.log(JSON.stringify({ elapsedMs: Math.round(performance.now() - startedAt), cached, count }));
+`,
+		);
+
+		const env: Record<string, string | undefined> = {
+			...process.env,
+			PATH: `${binDir}:${process.env.PATH ?? ""}`,
+			XDG_CACHE_HOME: cacheRoot,
+			OMP_GPU_PROBE_COUNT: probeCountPath,
+			OMP_GPU_PROBE_RUNS: String(options.runs),
+		};
+		// Strip inherited dirs-resolver overrides so XDG_CACHE_HOME above wins and
+		// the test cannot touch the developer/CI profile's real gpu_cache.json.
+		for (const key of ["PI_CODING_AGENT_DIR", "OMP_PROFILE", "PI_PROFILE", "PI_CONFIG_DIR"]) {
+			delete env[key];
+		}
+		if (options.sleepSeconds === undefined) {
+			delete env.OMP_GPU_PROBE_SLEEP;
+		} else {
+			env.OMP_GPU_PROBE_SLEEP = String(options.sleepSeconds);
+		}
+		if (options.holdStdoutOpen) {
+			env.OMP_GPU_PROBE_HOLD_STDOUT_OPEN = "true";
+		} else {
+			delete env.OMP_GPU_PROBE_HOLD_STDOUT_OPEN;
+		}
+		if (options.descendantHoldsStdout) {
+			env.OMP_GPU_PROBE_DESCENDANT_HOLDS_STDOUT = "true";
+		} else {
+			delete env.OMP_GPU_PROBE_DESCENDANT_HOLDS_STDOUT;
+		}
+		if (options.validOutput !== undefined) {
+			env.OMP_GPU_PROBE_VALID_OUTPUT = options.validOutput;
+		} else {
+			delete env.OMP_GPU_PROBE_VALID_OUTPUT;
+		}
+
+		const childStartedAt = performance.now();
+		const child = Bun.spawn([process.execPath, scenarioPath], { stdout: "pipe", stderr: "pipe", env });
+		const [stdout, stderr, exitCode] = await Promise.all([
+			new Response(child.stdout).text(),
+			new Response(child.stderr).text(),
+			child.exited,
+		]);
+		const childElapsedMs = Math.round(performance.now() - childStartedAt);
+		if (exitCode !== 0) {
+			throw new Error(`GPU probe scenario failed with exit ${exitCode}: ${stderr}`);
+		}
+		return { ...JSON.parse(stdout.trim()), childElapsedMs };
+	} finally {
+		await fs.rm(tempRoot, { recursive: true, force: true });
+	}
+}
+
+describe.skipIf(process.platform !== "linux")("system prompt GPU probe", () => {
+	it("caches empty GPU probe results", async () => {
+		const result = await runProbeScenario({ runs: 2 });
+
+		expect(result.cached).toEqual({ gpu: null });
+		expect(result.count).toBe(1);
+	}, 15_000);
+
+	it("kills the GPU probe at the prep deadline", async () => {
+		const result = await runProbeScenario({ runs: 1, sleepSeconds: 7, holdStdoutOpen: true });
+
+		expect(result.cached).toEqual({ gpu: null });
+		expect(result.elapsedMs).toBeLessThan(6500);
+		// Codex#3838: the child process MUST exit shortly after the deadline,
+		// not linger until a descendant holding stdout (sleep 7) exits on its own.
+		expect(result.childElapsedMs).toBeLessThan(6500);
+	}, 15_000);
+
+	it("does not wait on stdout held by a descendant after a successful probe", async () => {
+		const result = await runProbeScenario({ runs: 1, sleepSeconds: 3, descendantHoldsStdout: true });
+
+		expect(result.cached).toEqual({ gpu: null });
+		// Probe exits 0 immediately but leaves a backgrounded sleep holding the stdout
+		// pipe. The success path MUST bound the drain wait, not block until sleep exits.
+		expect(result.elapsedMs).toBeLessThan(2000);
+		expect(result.childElapsedMs).toBeLessThan(2000);
+	}, 15_000);
+
+	it("keeps probe output captured before a descendant delays EOF", async () => {
+		const result = await runProbeScenario({
+			runs: 1,
+			sleepSeconds: 3,
+			descendantHoldsStdout: true,
+			validOutput: "00:02.0 VGA compatible controller: NVIDIA TestGPU",
+		});
+
+		// Probe exited 0 with valid output before bg sleep held stdout open.
+		// Captured stdout MUST be cached, not discarded as if the probe failed.
+		expect(result.cached).toEqual({ gpu: "02.0 VGA compatible controller: NVIDIA TestGPU" });
+		expect(result.elapsedMs).toBeLessThan(2000);
+		expect(result.childElapsedMs).toBeLessThan(2000);
+	}, 15_000);
+});

package/src/system-prompt.ts

@@ -7,7 +7,6 @@ import type { AgentTool } from "@oh-my-pi/pi-agent-core";
 import type { ToolExample, TSchema } from "@oh-my-pi/pi-ai";
 import { renderToolInventory } from "@oh-my-pi/pi-ai/dialect";
 import { $env, getGpuCachePath, getProjectDir, hasFsCode, isEnoent, logger, prompt } from "@oh-my-pi/pi-utils";
-import { $ } from "bun";
 import { contextFileCapability } from "./capability/context-file";
 import { systemPromptCapability } from "./capability/system-prompt";
 import { findConfigFile } from "./config";
@@ -112,21 +111,60 @@ function parseWmicTable(output: string, header: string): string | null {
 }
 
 const SYSTEM_PROMPT_PREP_TIMEOUT_MS = 5000;
+/** Kept below prep timeout so timed-out probes can still write the null cache before fallback. */
+const GPU_PROBE_TIMEOUT_MS = SYSTEM_PROMPT_PREP_TIMEOUT_MS - 500;
+/** Drop stdout from a probe descendant that inherited the pipe after the probe exited. */
+const GPU_PROBE_STDOUT_DRAIN_MS = 250;
+
+async function runGpuProbe(cmd: string[]): Promise<string | null> {
+	try {
+		const proc = Bun.spawn({
+			cmd,
+			stdout: "pipe",
+			stderr: "ignore",
+			stdin: "ignore",
+			timeout: GPU_PROBE_TIMEOUT_MS,
+			// SIGKILL so a probe ignoring SIGTERM (PATH wrapper, wedged WMI) still
+			// dies at the deadline and lets getCachedGpu reach the null-cache write.
+			killSignal: "SIGKILL",
+		});
+		const stdoutReader = proc.stdout.getReader();
+		let stdout = "";
+		const decoder = new TextDecoder();
+		const stdoutDone = (async () => {
+			while (true) {
+				const chunk = await stdoutReader.read();
+				if (chunk.done) break;
+				stdout += decoder.decode(chunk.value, { stream: true });
+			}
+			stdout += decoder.decode();
+		})();
+		const exitCode = await proc.exited;
+		// Even on exit 0, a probe wrapper can leave a descendant holding stdout open.
+		// Bound the EOF wait so getCachedGpu cannot outlive the probe in either path;
+		// keep whatever bytes the reader already captured before cancelling.
+		const drained = await Promise.race([
+			stdoutDone.then(() => "ok" as const).catch(() => "err" as const),
+			Bun.sleep(GPU_PROBE_STDOUT_DRAIN_MS).then(() => "timeout" as const),
+		]);
+		if (drained !== "ok") {
+			await stdoutReader.cancel().catch(() => undefined);
+			await stdoutDone.catch(() => undefined);
+		}
+		return exitCode === 0 ? stdout : null;
+	} catch {
+		return null;
+	}
+}
 
 async function getGpuModel(): Promise<string | null> {
 	switch (process.platform) {
 		case "win32": {
-			const output = await $`wmic path win32_VideoController get name`
-				.quiet()
-				.text()
-				.catch(() => null);
+			const output = await runGpuProbe(["wmic", "path", "win32_VideoController", "get", "name"]);
 			return output ? parseWmicTable(output, "Name") : null;
 		}
 		case "linux": {
-			const output = await $`lspci`
-				.quiet()
-				.text()
-				.catch(() => null);
+			const output = await runGpuProbe(["lspci"]);
 			if (!output) return null;
 			const gpus: Array<{ name: string; priority: number }> = [];
 			for (const line of output.split("\n")) {
@@ -176,20 +214,20 @@ function getTerminalName(): string | undefined {
 	return term ?? undefined;
 }
 
-/** Cached system info structure */
+/** Cached GPU probe result. */
 interface GpuCache {
-	gpu: string;
-}
-
-function getSystemInfoCachePath(): string {
-	return getGpuCachePath();
+	gpu: string | null;
 }
 
 async function loadGpuCache(): Promise<GpuCache | null> {
 	try {
-		const cachePath = getSystemInfoCachePath();
+		const cachePath = getGpuCachePath();
 		const content = await Bun.file(cachePath).json();
-		return content as GpuCache;
+		if (content && typeof content === "object" && "gpu" in content) {
+			const gpu = content.gpu;
+			return { gpu: typeof gpu === "string" ? gpu : null };
+		}
+		return null;
 	} catch {
 		return null;
 	}
@@ -197,7 +235,7 @@ async function loadGpuCache(): Promise<GpuCache | null> {
 
 async function saveGpuCache(info: GpuCache): Promise<void> {
 	try {
-		const cachePath = getSystemInfoCachePath();
+		const cachePath = getGpuCachePath();
 		await Bun.write(cachePath, JSON.stringify(info, null, "\t"));
 	} catch {
 		// Silently ignore cache write failures
@@ -206,15 +244,12 @@ async function saveGpuCache(info: GpuCache): Promise<void> {
 
 async function getCachedGpu(): Promise<string | undefined> {
 	const cached = await logger.time("getCachedGpu:loadGpuCache", loadGpuCache);
-	if (cached) return cached.gpu;
+	if (cached) return cached.gpu ?? undefined;
 	const gpu = await logger.time("getCachedGpu:getGpuModel", getGpuModel);
-	if (gpu) {
-		await logger.time("getCachedGpu:saveGpuCache", saveGpuCache, { gpu });
-	}
+	await logger.time("getCachedGpu:saveGpuCache", saveGpuCache, { gpu });
 	return gpu ?? undefined;
 }
-async function getEnvironmentInfo(): Promise<Array<{ label: string; value: string }>> {
-	const gpu = await getCachedGpu();
+function getEnvironmentInfo(gpu: string | undefined): Array<{ label: string; value: string }> {
 	let cpuModel: string | undefined;
 	try {
 		cpuModel = os.cpus()[0]?.model;
@@ -500,9 +535,13 @@ export async function buildSystemPrompt(options: BuildSystemPromptOptions = {}):
 			agentsMdFiles: [],
 		} satisfies WorkspaceTree,
 		activeRepoContext: null as ActiveRepoContext | null,
+		gpu: undefined as string | undefined,
 	};
 
-	const deadline = Bun.sleep(SYSTEM_PROMPT_PREP_TIMEOUT_MS).then(() => "__timeout__" as const);
+	const { promise: deadline, resolve: fireDeadline } = Promise.withResolvers<"__timeout__">();
+	const deadlineTimer = setTimeout(() => fireDeadline("__timeout__"), SYSTEM_PROMPT_PREP_TIMEOUT_MS);
+	// Unref so a fast prep does not hold a one-shot CLI alive waiting for this timer.
+	deadlineTimer.unref();
 	const timedOut: string[] = [];
 	const failed: Array<{ name: string; error: unknown }> = [];
 
@@ -566,6 +605,7 @@ export async function buildSystemPrompt(options: BuildSystemPromptOptions = {}):
 		providedActiveRepoContext !== undefined
 			? Promise.resolve(providedActiveRepoContext)
 			: logger.time("resolveActiveRepoContext", () => resolveActiveRepoContext(resolvedCwd));
+	const gpuPromise = logger.time("getCachedGpu", getCachedGpu);
 
 	const [
 		resolvedCustomPrompt,
@@ -575,6 +615,7 @@ export async function buildSystemPrompt(options: BuildSystemPromptOptions = {}):
 		skills,
 		workspaceTree,
 		activeRepoContext,
+		gpu,
 	] = await Promise.all([
 		withDeadline(
 			"customPrompt",
@@ -597,7 +638,9 @@ export async function buildSystemPrompt(options: BuildSystemPromptOptions = {}):
 		withDeadline("loadSkills", skillsPromise, prepDefaults.skills),
 		withDeadline("buildWorkspaceTree", workspaceTreePromise, prepDefaults.workspaceTree),
 		withDeadline("resolveActiveRepoContext", activeRepoContextPromise, prepDefaults.activeRepoContext),
+		withDeadline("getCachedGpu", gpuPromise, prepDefaults.gpu),
 	]);
+	clearTimeout(deadlineTimer);
 	const agentsMdFiles = Array.from(new Set(workspaceTree.agentsMdFiles)).sort().slice(0, AGENTS_MD_LIMIT);
 
 	if (timedOut.length > 0) {
@@ -675,7 +718,7 @@ export async function buildSystemPrompt(options: BuildSystemPromptOptions = {}):
 	];
 	const injectedAlwaysApplyRules = dedupeAlwaysApplyRules(alwaysApplyRules, promptSources);
 
-	const environment = await logger.time("getEnvironmentInfo", getEnvironmentInfo);
+	const environment = getEnvironmentInfo(gpu);
 	const data = {
 		systemPromptCustomization: effectiveSystemPromptCustomization,
 		customPrompt: resolvedCustomPrompt,

package/src/task/executor.ts

@@ -7,7 +7,7 @@
 import path from "node:path";
 import type { AgentEvent, AgentIdentity, AgentTelemetryConfig, ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import { recordHandoff, resolveTelemetry } from "@oh-my-pi/pi-agent-core";
-import type { Api, Model, ServiceTier, Usage } from "@oh-my-pi/pi-ai";
+import type { Api, Model, ServiceTierByFamily, Usage } from "@oh-my-pi/pi-ai";
 import { logger, popLoopPhase, prompt, pushLoopPhase, untilAborted } from "@oh-my-pi/pi-utils";
 import type { Rule } from "../capability/rule";
 import { ModelRegistry } from "../config/model-registry";
@@ -18,7 +18,7 @@ import {
 	resolveModelOverrideWithAuthFallback,
 } from "../config/model-resolver";
 import type { PromptTemplate } from "../config/prompt-templates";
-import { resolveSubagentServiceTier } from "../config/service-tier";
+import { buildServiceTierByFamily, resolveSubagentServiceTier } from "../config/service-tier";
 import { Settings } from "../config/settings";
 import { SETTINGS_SCHEMA, type SettingPath } from "../config/settings-schema";
 import type { ToolPathWithSource } from "../extensibility/custom-tools";
@@ -344,12 +344,12 @@ export interface ExecutorOptions {
 	modelRegistry?: ModelRegistry;
 	settings?: Settings;
 	/**
-	 * Parent session's live effective service tier, the source of truth for a
-	 * subagent whose `serviceTierSubagent` is `"inherit"`. `null` = the parent
+	 * Parent session's live per-family service tiers, the source of truth for a
+	 * subagent whose `tier.subagent` is `"inherit"`. `null` = the parent
 	 * explicitly has no tier (e.g. `/fast off`); omitted = no live session, so
-	 * inherit falls back to the configured `serviceTier` setting.
+	 * inherit falls back to the subagent's configured `tier.*` settings.
 	 */
-	parentServiceTier?: ServiceTier | null;
+	parentServiceTier?: ServiceTierByFamily | null;
 	/** Override local:// protocol options so subagent shares parent's local:// root */
 	localProtocolOptions?: LocalProtocolOptions;
 	/**
@@ -739,21 +739,28 @@ export function createMCPProxyTools(mcpManager: MCPManager): CustomTool[] {
 export function createSubagentSettings(
 	baseSettings: Settings,
 	overrides?: Partial<Record<SettingPath, unknown>>,
-	inheritedServiceTier?: ServiceTier | null,
+	inheritedServiceTier?: ServiceTierByFamily | null,
 ): Settings {
 	const snapshot: Partial<Record<SettingPath, unknown>> = {};
 	for (const key of Object.keys(SETTINGS_SCHEMA) as SettingPath[]) {
 		snapshot[key] = baseSettings.get(key);
 	}
-	// Resolve the subagent's service tier from `serviceTierSubagent` ("inherit" =
-	// match the parent's live tier when a live session supplied one, else the
-	// configured `serviceTier`). The result is stamped back onto the snapshot so
-	// createAgentSession's `settings.get("serviceTier")` read picks it up.
-	snapshot.serviceTier = resolveSubagentServiceTier(
-		baseSettings.get("serviceTierSubagent"),
-		baseSettings.get("serviceTier"),
-		inheritedServiceTier,
-	);
+	// Resolve the subagent's per-family tiers from `tier.subagent` ("inherit" =
+	// match the parent's live tiers when a live session supplied them, else the
+	// subagent's own configured tier.* settings). The result is stamped back onto
+	// the snapshot so createAgentSession's tier.* reads pick it up.
+	const inheritedTiers =
+		inheritedServiceTier === undefined
+			? buildServiceTierByFamily(
+					baseSettings.get("tier.openai"),
+					baseSettings.get("tier.anthropic"),
+					baseSettings.get("tier.google"),
+				)
+			: (inheritedServiceTier ?? {});
+	const subagentTiers = resolveSubagentServiceTier(baseSettings.get("tier.subagent"), inheritedTiers);
+	snapshot["tier.openai"] = subagentTiers.openai ?? "none";
+	snapshot["tier.anthropic"] = subagentTiers.anthropic ?? "none";
+	snapshot["tier.google"] = subagentTiers.google ?? "none";
 	return Settings.isolated({
 		...snapshot,
 		"async.enabled": false,

package/src/task/index.ts

@@ -1296,11 +1296,13 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 				parentTelemetry: this.session.getTelemetry?.(),
 				parentEvalSessionId,
 				parentAgentId: this.session.getAgentId?.() ?? MAIN_AGENT_ID,
-				// Live source of truth for `serviceTierSubagent: inherit`. When the
-				// session exposes a tier accessor, pass tier-or-null (null = explicit
-				// none, e.g. /fast off); otherwise leave undefined so inherit falls
-				// back to the configured serviceTier setting.
-				parentServiceTier: this.session.getServiceTier ? (this.session.getServiceTier() ?? null) : undefined,
+				// Live source of truth for `tier.subagent: inherit`. When the session
+				// exposes a tier accessor, pass the per-family map or null (null =
+				// explicit none, e.g. /fast off); otherwise leave undefined so inherit
+				// falls back to the subagent's configured tier.* settings.
+				parentServiceTier: this.session.getServiceTierByFamily
+					? (this.session.getServiceTierByFamily() ?? null)
+					: undefined,
 			};
 
 			const runTask = async (): Promise<SingleResult> => {

package/src/task/isolation-runner.ts

@@ -154,6 +154,7 @@ export async function runIsolatedSubprocess(opts: IsolatedRunOptions): Promise<S
 				return {
 					...result,
 					branchName: commitResult?.branchName,
+					branchBaseSha: commitResult?.baseSha,
 					nestedPatches: commitResult?.nestedPatches,
 				};
 			} catch (mergeErr) {
@@ -222,6 +223,14 @@ export async function mergeIsolatedChanges(opts: IsolationMergeOptions): Promise
 	const { result, repoRoot, mergeMode } = opts;
 	try {
 		if (mergeMode === "branch") {
+			if (!result.branchName && result.exitCode === 0 && !result.aborted && result.error) {
+				return {
+					summary: `\n\n<system-notification>Branch merge failed before a task branch could be created: ${result.error}\nTask outputs are preserved but changes were not applied.</system-notification>`,
+					changesApplied: false,
+					hadAnyChanges: false,
+					mergedBranchForNestedPatches: false,
+				};
+			}
 			const canApplyNestedOnly =
 				!result.branchName && result.exitCode === 0 && !result.aborted && (result.nestedPatches?.length ?? 0) > 0;
 			if (!result.branchName || result.exitCode !== 0 || result.aborted) {
@@ -235,7 +244,12 @@ export async function mergeIsolatedChanges(opts: IsolationMergeOptions): Promise
 				};
 			}
 			const mergeResult = await mergeTaskBranches(repoRoot, [
-				{ branchName: result.branchName, taskId: result.id, description: result.description },
+				{
+					branchName: result.branchName,
+					taskId: result.id,
+					description: result.description,
+					baseSha: result.branchBaseSha,
+				},
 			]);
 			const mergedBranchForNestedPatches = mergeResult.merged.includes(result.branchName);
 			const changesApplied = mergeResult.failed.length === 0;

package/src/task/types.ts

@@ -383,6 +383,12 @@ export interface SingleResult {
 	patchPath?: string;
 	/** Branch name for isolated branch-mode output */
 	branchName?: string;
+	/**
+	 * Baseline commit SHA the task branch was created from. Passed to
+	 * `mergeTaskBranches` so cherry-pick uses the inclusive range
+	 * `branchBaseSha..branchName` and preserves every agent commit's message.
+	 */
+	branchBaseSha?: string;
 	/** Nested repo patches to apply after parent merge */
 	nestedPatches?: NestedRepoPatch[];
 	/** Data extracted by registered subprocess tool handlers (keyed by tool name) */