@oh-my-pi/pi-coding-agent 12.8.1 → 12.9.0

package/CHANGELOG.md

@@ -2,6 +2,33 @@
 
 ## [Unreleased]
 
+## [12.9.0] - 2026-02-17
+
+### Added
+
+- Added OpenCode discovery provider to load configuration from ~/.config/opencode/ and .opencode/ directories
+- Added support for loading MCP servers from opencode.json mcp key
+- Added support for loading skills from ~/.config/opencode/skills/ and .opencode/skills/
+- Added support for loading slash commands from ~/.config/opencode/commands/ and .opencode/commands/
+- Added support for loading extension modules (plugins) from ~/.config/opencode/plugins/ and .opencode/plugins/
+- Added support for loading context files (AGENTS.md) from ~/.config/opencode/
+- Added support for loading settings from opencode.json configuration files
+
+### Changed
+
+- Improved path display in status line to strip both `/work/` and `~/Projects/` prefixes when abbreviating paths
+- Refactored session directory naming to use single-dash format for home-relative paths and double-dash format for absolute paths, with automatic migration of legacy session directories on first access
+
+## [12.8.2] - 2026-02-17
+### Changed
+
+- Changed system environment context to use built-in `os` values for distro, kernel, and CPU model instead of native system-info data
+- Changed environment info generation to stop including unavailable native system detail fallbacks
+
+### Removed
+
+- Removed the `Disk` field from generated environment information
+
 ## [12.8.0] - 2026-02-16
 
 ### Changed

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "12.8.1",
+	"version": "12.9.0",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"type": "module",
 	"bin": {
@@ -84,12 +84,12 @@
 	},
 	"dependencies": {
 		"@mozilla/readability": "0.6.0",
-		"@oh-my-pi/omp-stats": "12.8.1",
-		"@oh-my-pi/pi-agent-core": "12.8.1",
-		"@oh-my-pi/pi-ai": "12.8.1",
-		"@oh-my-pi/pi-natives": "12.8.1",
-		"@oh-my-pi/pi-tui": "12.8.1",
-		"@oh-my-pi/pi-utils": "12.8.1",
+		"@oh-my-pi/omp-stats": "12.9.0",
+		"@oh-my-pi/pi-agent-core": "12.9.0",
+		"@oh-my-pi/pi-ai": "12.9.0",
+		"@oh-my-pi/pi-natives": "12.9.0",
+		"@oh-my-pi/pi-tui": "12.9.0",
+		"@oh-my-pi/pi-utils": "12.9.0",
 		"@sinclair/typebox": "^0.34.48",
 		"@xterm/headless": "^6.0.0",
 		"ajv": "^8.18.0",

package/src/discovery/helpers.ts

@@ -60,6 +60,11 @@ export const SOURCE_PATHS = {
 		userAgent: ".gemini",
 		projectDir: ".gemini",
 	},
+	opencode: {
+		userBase: ".config/opencode",
+		userAgent: ".config/opencode",
+		projectDir: ".opencode",
+	},
 	cursor: {
 		userBase: ".cursor",
 		userAgent: ".cursor",

package/src/discovery/index.ts

@@ -29,6 +29,7 @@ import "./agents";
 import "./codex";
 import "./cursor";
 import "./gemini";
+import "./opencode";
 import "./github";
 import "./mcp-json";
 import "./ssh";

package/src/discovery/opencode.ts

@@ -0,0 +1,394 @@
+/**
+ * OpenCode Discovery Provider
+ *
+ * Loads configuration from OpenCode's config directories:
+ * - User: ~/.config/opencode/
+ * - Project: .opencode/ (cwd) and opencode.json (project root)
+ *
+ * Capabilities:
+ * - context-files: AGENTS.md (user-level only at ~/.config/opencode/AGENTS.md)
+ * - mcps: From opencode.json "mcp" key
+ * - settings: From opencode.json
+ * - skills: From skills/ subdirectories
+ * - slash-commands: From commands/ subdirectories
+ * - extension-modules: From plugins/ subdirectories
+ *
+ * Priority: 55 (tool-specific provider)
+ */
+import * as path from "node:path";
+import { logger } from "@oh-my-pi/pi-utils";
+import { registerProvider } from "../capability";
+import { type ContextFile, contextFileCapability } from "../capability/context-file";
+import { type ExtensionModule, extensionModuleCapability } from "../capability/extension-module";
+import { readFile } from "../capability/fs";
+import { type MCPServer, mcpCapability } from "../capability/mcp";
+import { type Settings, settingsCapability } from "../capability/settings";
+import { type Skill, skillCapability } from "../capability/skill";
+import { type SlashCommand, slashCommandCapability } from "../capability/slash-command";
+import type { LoadContext, LoadResult, SourceMeta } from "../capability/types";
+import { parseFrontmatter } from "../utils/frontmatter";
+import {
+	createSourceMeta,
+	discoverExtensionModulePaths,
+	expandEnvVarsDeep,
+	getExtensionNameFromPath,
+	getProjectPath,
+	getUserPath,
+	loadFilesFromDir,
+	loadSkillsFromDir,
+	parseJSON,
+} from "./helpers";
+
+const PROVIDER_ID = "opencode";
+const DISPLAY_NAME = "OpenCode";
+const PRIORITY = 55;
+
+// =============================================================================
+// JSON Config Loading
+// =============================================================================
+
+async function loadJsonConfig(configPath: string): Promise<Record<string, unknown> | null> {
+	const content = await readFile(configPath);
+	if (!content) return null;
+
+	const parsed = parseJSON<Record<string, unknown>>(content);
+	if (!parsed) {
+		logger.warn("Failed to parse OpenCode JSON config", { path: configPath });
+		return null;
+	}
+	return parsed;
+}
+
+// =============================================================================
+// Context Files (AGENTS.md)
+// =============================================================================
+
+async function loadContextFiles(ctx: LoadContext): Promise<LoadResult<ContextFile>> {
+	const items: ContextFile[] = [];
+	const warnings: string[] = [];
+
+	// User-level only: ~/.config/opencode/AGENTS.md
+	const userAgentsMd = getUserPath(ctx, "opencode", "AGENTS.md");
+	if (userAgentsMd) {
+		const content = await readFile(userAgentsMd);
+		if (content) {
+			items.push({
+				path: userAgentsMd,
+				content,
+				level: "user",
+				_source: createSourceMeta(PROVIDER_ID, userAgentsMd, "user"),
+			});
+		}
+	}
+
+	return { items, warnings };
+}
+
+// =============================================================================
+// MCP Servers (opencode.json → mcp)
+// =============================================================================
+
+/** OpenCode MCP server config (from opencode.json "mcp" key) */
+interface OpenCodeMCPConfig {
+	type?: "local" | "remote";
+	command?: string;
+	args?: string[];
+	env?: Record<string, string>;
+	url?: string;
+	headers?: Record<string, string>;
+	enabled?: boolean;
+	timeout?: number;
+}
+
+async function loadMCPServers(ctx: LoadContext): Promise<LoadResult<MCPServer>> {
+	const items: MCPServer[] = [];
+	const warnings: string[] = [];
+
+	// User-level: ~/.config/opencode/opencode.json
+	const userConfigPath = getUserPath(ctx, "opencode", "opencode.json");
+	if (userConfigPath) {
+		const config = await loadJsonConfig(userConfigPath);
+		if (config) {
+			const result = extractMCPServers(config, userConfigPath, "user");
+			items.push(...result.items);
+			if (result.warnings) warnings.push(...result.warnings);
+		}
+	}
+
+	// Project-level: opencode.json in project root
+	const projectConfigPath = path.join(ctx.cwd, "opencode.json");
+	const projectConfig = await loadJsonConfig(projectConfigPath);
+	if (projectConfig) {
+		const result = extractMCPServers(projectConfig, projectConfigPath, "project");
+		items.push(...result.items);
+		if (result.warnings) warnings.push(...result.warnings);
+	}
+
+	return { items, warnings };
+}
+
+function extractMCPServers(
+	config: Record<string, unknown>,
+	configPath: string,
+	level: "user" | "project",
+): LoadResult<MCPServer> {
+	const items: MCPServer[] = [];
+	const warnings: string[] = [];
+
+	if (!config.mcp || typeof config.mcp !== "object") {
+		return { items, warnings };
+	}
+
+	const servers = expandEnvVarsDeep(config.mcp as Record<string, unknown>);
+
+	for (const [name, raw] of Object.entries(servers)) {
+		if (!raw || typeof raw !== "object") {
+			warnings.push(`Invalid MCP config for "${name}" in ${configPath}`);
+			continue;
+		}
+
+		const serverConfig = raw as OpenCodeMCPConfig;
+
+		// Determine transport from OpenCode's "type" field
+		let transport: "stdio" | "sse" | "http" | undefined;
+		if (serverConfig.type === "local") {
+			transport = "stdio";
+		} else if (serverConfig.type === "remote") {
+			transport = "http";
+		} else if (serverConfig.url) {
+			transport = "http";
+		} else if (serverConfig.command) {
+			transport = "stdio";
+		}
+
+		items.push({
+			name,
+			command: serverConfig.command,
+			args: Array.isArray(serverConfig.args) ? (serverConfig.args as string[]) : undefined,
+			env: serverConfig.env && typeof serverConfig.env === "object" ? serverConfig.env : undefined,
+			url: typeof serverConfig.url === "string" ? serverConfig.url : undefined,
+			headers: serverConfig.headers && typeof serverConfig.headers === "object" ? serverConfig.headers : undefined,
+			enabled: serverConfig.enabled,
+			timeout: typeof serverConfig.timeout === "number" ? serverConfig.timeout : undefined,
+			transport,
+			_source: createSourceMeta(PROVIDER_ID, configPath, level),
+		});
+	}
+
+	return { items, warnings };
+}
+
+// =============================================================================
+// Skills (skills/)
+// =============================================================================
+
+async function loadSkills(ctx: LoadContext): Promise<LoadResult<Skill>> {
+	const userSkillsDir = getUserPath(ctx, "opencode", "skills");
+	const projectSkillsDir = getProjectPath(ctx, "opencode", "skills");
+
+	const promises: Promise<LoadResult<Skill>>[] = [];
+
+	if (userSkillsDir) {
+		promises.push(
+			loadSkillsFromDir(ctx, {
+				dir: userSkillsDir,
+				providerId: PROVIDER_ID,
+				level: "user",
+			}),
+		);
+	}
+
+	if (projectSkillsDir) {
+		promises.push(
+			loadSkillsFromDir(ctx, {
+				dir: projectSkillsDir,
+				providerId: PROVIDER_ID,
+				level: "project",
+			}),
+		);
+	}
+
+	const results = await Promise.all(promises);
+	const items = results.flatMap(r => r.items);
+	const warnings = results.flatMap(r => r.warnings || []);
+
+	return { items, warnings };
+}
+
+// =============================================================================
+// Extension Modules (plugins/)
+// =============================================================================
+
+async function loadExtensionModules(ctx: LoadContext): Promise<LoadResult<ExtensionModule>> {
+	const userPluginsDir = getUserPath(ctx, "opencode", "plugins");
+	const projectPluginsDir = getProjectPath(ctx, "opencode", "plugins");
+
+	const [userPaths, projectPaths] = await Promise.all([
+		userPluginsDir ? discoverExtensionModulePaths(ctx, userPluginsDir) : Promise.resolve([]),
+		projectPluginsDir ? discoverExtensionModulePaths(ctx, projectPluginsDir) : Promise.resolve([]),
+	]);
+
+	const items: ExtensionModule[] = [
+		...userPaths.map(extPath => ({
+			name: getExtensionNameFromPath(extPath),
+			path: extPath,
+			level: "user" as const,
+			_source: createSourceMeta(PROVIDER_ID, extPath, "user"),
+		})),
+		...projectPaths.map(extPath => ({
+			name: getExtensionNameFromPath(extPath),
+			path: extPath,
+			level: "project" as const,
+			_source: createSourceMeta(PROVIDER_ID, extPath, "project"),
+		})),
+	];
+
+	return { items, warnings: [] };
+}
+
+// =============================================================================
+// Slash Commands (commands/)
+// =============================================================================
+
+async function loadSlashCommands(ctx: LoadContext): Promise<LoadResult<SlashCommand>> {
+	const userCommandsDir = getUserPath(ctx, "opencode", "commands");
+	const projectCommandsDir = getProjectPath(ctx, "opencode", "commands");
+
+	const transformCommand =
+		(level: "user" | "project") => (name: string, content: string, filePath: string, source: SourceMeta) => {
+			const { frontmatter, body } = parseFrontmatter(content, { source: filePath });
+			const commandName = frontmatter.name || name.replace(/\.md$/, "");
+			return {
+				name: String(commandName),
+				path: filePath,
+				content: body,
+				level,
+				_source: source,
+			};
+		};
+
+	const promises: Promise<LoadResult<SlashCommand>>[] = [];
+
+	if (userCommandsDir) {
+		promises.push(
+			loadFilesFromDir(ctx, userCommandsDir, PROVIDER_ID, "user", {
+				extensions: ["md"],
+				transform: transformCommand("user"),
+			}),
+		);
+	}
+
+	if (projectCommandsDir) {
+		promises.push(
+			loadFilesFromDir(ctx, projectCommandsDir, PROVIDER_ID, "project", {
+				extensions: ["md"],
+				transform: transformCommand("project"),
+			}),
+		);
+	}
+
+	const results = await Promise.all(promises);
+	const items = results.flatMap(r => r.items);
+	const warnings = results.flatMap(r => r.warnings || []);
+
+	return { items, warnings };
+}
+
+// =============================================================================
+// Settings (opencode.json)
+// =============================================================================
+
+async function loadSettings(ctx: LoadContext): Promise<LoadResult<Settings>> {
+	const items: Settings[] = [];
+	const warnings: string[] = [];
+
+	// User-level: ~/.config/opencode/opencode.json
+	const userConfigPath = getUserPath(ctx, "opencode", "opencode.json");
+	if (userConfigPath) {
+		const content = await readFile(userConfigPath);
+		if (content) {
+			const parsed = parseJSON<Record<string, unknown>>(content);
+			if (parsed) {
+				items.push({
+					path: userConfigPath,
+					data: parsed,
+					level: "user",
+					_source: createSourceMeta(PROVIDER_ID, userConfigPath, "user"),
+				});
+			} else {
+				warnings.push(`Invalid JSON in ${userConfigPath}`);
+			}
+		}
+	}
+
+	// Project-level: opencode.json in project root
+	const projectConfigPath = path.join(ctx.cwd, "opencode.json");
+	const content = await readFile(projectConfigPath);
+	if (content) {
+		const parsed = parseJSON<Record<string, unknown>>(content);
+		if (parsed) {
+			items.push({
+				path: projectConfigPath,
+				data: parsed,
+				level: "project",
+				_source: createSourceMeta(PROVIDER_ID, projectConfigPath, "project"),
+			});
+		} else {
+			warnings.push(`Invalid JSON in ${projectConfigPath}`);
+		}
+	}
+
+	return { items, warnings };
+}
+
+// =============================================================================
+// Provider Registration
+// =============================================================================
+
+registerProvider(contextFileCapability.id, {
+	id: PROVIDER_ID,
+	displayName: DISPLAY_NAME,
+	description: "Load AGENTS.md from ~/.config/opencode/",
+	priority: PRIORITY,
+	load: loadContextFiles,
+});
+
+registerProvider(mcpCapability.id, {
+	id: PROVIDER_ID,
+	displayName: DISPLAY_NAME,
+	description: "Load MCP servers from opencode.json mcp key",
+	priority: PRIORITY,
+	load: loadMCPServers,
+});
+
+registerProvider(skillCapability.id, {
+	id: PROVIDER_ID,
+	displayName: DISPLAY_NAME,
+	description: "Load skills from ~/.config/opencode/skills/ and .opencode/skills/",
+	priority: PRIORITY,
+	load: loadSkills,
+});
+
+registerProvider(extensionModuleCapability.id, {
+	id: PROVIDER_ID,
+	displayName: DISPLAY_NAME,
+	description: "Load extension modules from ~/.config/opencode/plugins/ and .opencode/plugins/",
+	priority: PRIORITY,
+	load: loadExtensionModules,
+});
+
+registerProvider(slashCommandCapability.id, {
+	id: PROVIDER_ID,
+	displayName: DISPLAY_NAME,
+	description: "Load slash commands from ~/.config/opencode/commands/ and .opencode/commands/",
+	priority: PRIORITY,
+	load: loadSlashCommands,
+});
+
+registerProvider(settingsCapability.id, {
+	id: PROVIDER_ID,
+	displayName: DISPLAY_NAME,
+	description: "Load settings from opencode.json",
+	priority: PRIORITY,
+	load: loadSettings,
+});

package/src/extensibility/custom-tools/wrapper.ts

@@ -5,7 +5,7 @@ import type { AgentTool, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core
 import type { Static, TSchema } from "@sinclair/typebox";
 import type { Theme } from "../../modes/theme/theme";
 import { applyToolProxy } from "../tool-proxy";
-import type { CustomTool, CustomToolContext, LoadedCustomTool } from "./types";
+import type { CustomTool, CustomToolContext } from "./types";
 
 export class CustomToolAdapter<TParams extends TSchema = TSchema, TDetails = any, TTheme extends Theme = Theme>
 	implements AgentTool<TParams, TDetails, TTheme>
@@ -42,14 +42,4 @@ export class CustomToolAdapter<TParams extends TSchema = TSchema, TDetails = any
 	): AgentTool<TParams, TDetails, TTheme> {
 		return new CustomToolAdapter(tool, getContext);
 	}
-
-	/**
-	 * Wrap all loaded custom tools into AgentTools.
-	 */
-	static wrapTools<TParams extends TSchema = TSchema, TDetails = any, TTheme extends Theme = Theme>(
-		loadedTools: LoadedCustomTool<TParams, TDetails>[],
-		getContext: () => CustomToolContext,
-	): AgentTool<TParams, TDetails, TTheme>[] {
-		return loadedTools.map(lt => CustomToolAdapter.wrap(lt.tool, getContext));
-	}
 }

package/src/modes/components/status-line/segments.ts

@@ -97,8 +97,9 @@ const pathSegment: StatusLineSegment = {
 		if (opts.abbreviate !== false) {
 			pwd = shortenPath(pwd);
 		}
-		if (opts.stripWorkPrefix !== false && pwd.startsWith("/work/")) {
-			pwd = pwd.slice(6);
+		if (opts.stripWorkPrefix !== false) {
+			if (pwd.startsWith("/work/")) pwd = pwd.slice(6);
+			else if (pwd.startsWith("~/Projects/")) pwd = pwd.slice(11);
 		}
 
 		const maxLen = opts.maxLength ?? 40;

package/src/sdk.ts

@@ -79,7 +79,6 @@ import {
 } from "./tools";
 import { ToolContextStore } from "./tools/context";
 import { getGeminiImageTools } from "./tools/gemini-image";
-import { wrapToolsWithMetaNotice } from "./tools/output-meta";
 import { EventBus } from "./utils/event-bus";
 import { time } from "./utils/timings";
 
@@ -762,9 +761,8 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 	);
 
 	debugStartup("sdk:createTools:start");
-	// Create and wrap tools with meta notice formatting
-	const rawBuiltinTools = await createTools(toolSession, options.toolNames);
-	const builtinTools = wrapToolsWithMetaNotice(rawBuiltinTools);
+	// Create built-in tools (already wrapped with meta notice formatting)
+	const builtinTools = await createTools(toolSession, options.toolNames);
 	debugStartup("sdk:createTools");
 	time("createAllTools");
 

package/src/session/session-manager.ts

@@ -1,7 +1,9 @@
 import * as fs from "node:fs";
+import * as os from "node:os";
 import * as path from "node:path";
 import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
 import type { ImageContent, Message, TextContent, Usage } from "@oh-my-pi/pi-ai";
+import { getTerminalId } from "@oh-my-pi/pi-tui";
 import { isEnoent, logger, parseJsonlLenient, Snowflake } from "@oh-my-pi/pi-utils";
 import { getBlobsDir, getAgentDir as getDefaultAgentDir, getProjectDir } from "@oh-my-pi/pi-utils/dirs";
 import { type BlobPutResult, BlobStore, externalizeImageData, isBlobRef, resolveImageData } from "./blob-store";
@@ -302,6 +304,67 @@ export function migrateSessionEntries(entries: FileEntry[]): void {
 	migrateToCurrentVersion(entries);
 }
 
+let sessionDirsMigrated = false;
+
+/**
+ * Migrate old `--<home-encoded>-*--` session dirs to the new `-*` format.
+ * Runs once on first access, best-effort.
+ */
+function migrateHomeSessionDirs(): void {
+	if (sessionDirsMigrated) return;
+	sessionDirsMigrated = true;
+
+	const home = os.homedir();
+	const homeEncoded = home.replace(/^[/\\]/, "").replace(/[/\\:]/g, "-");
+	const oldPrefix = `--${homeEncoded}-`;
+	const oldExact = `--${homeEncoded}--`;
+	const sessionsRoot = path.join(getDefaultAgentDir(), "sessions");
+
+	let entries: string[];
+	try {
+		entries = fs.readdirSync(sessionsRoot);
+	} catch {
+		return;
+	}
+
+	for (const entry of entries) {
+		let remainder: string;
+		if (entry === oldExact) {
+			remainder = "";
+		} else if (entry.startsWith(oldPrefix) && entry.endsWith("--")) {
+			remainder = entry.slice(oldPrefix.length, -2);
+		} else {
+			continue;
+		}
+
+		const newName = `-${remainder}`;
+		const oldPath = path.join(sessionsRoot, entry);
+		const newPath = path.join(sessionsRoot, newName);
+
+		try {
+			const existing = fs.statSync(newPath, { throwIfNoEntry: false });
+			if (existing?.isDirectory()) {
+				// Merge files from old dir into existing new dir
+				for (const file of fs.readdirSync(oldPath)) {
+					const src = path.join(oldPath, file);
+					const dst = path.join(newPath, file);
+					if (!fs.existsSync(dst)) {
+						fs.renameSync(src, dst);
+					}
+				}
+				fs.rmSync(oldPath, { recursive: true, force: true });
+			} else {
+				if (existing) {
+					fs.rmSync(newPath, { recursive: true, force: true });
+				}
+				fs.renameSync(oldPath, newPath);
+			}
+		} catch {
+			// Best effort
+		}
+	}
+}
+
 /** Exported for compaction.test.ts */
 export function parseSessionEntries(content: string): FileEntry[] {
 	return parseJsonlLenient<FileEntry>(content);
@@ -459,13 +522,27 @@ export function buildSessionContext(
 	return { messages, thinkingLevel, models, injectedTtsrRules, mode, modeData };
 }
 
+/**
+ * Encode a cwd into a safe directory name for session storage.
+ * Home-relative paths use single-dash format: `/Users/x/Projects/pi` → `-Projects-pi`
+ * Absolute paths use double-dash format: `/tmp/foo` → `--tmp-foo--`
+ */
+function encodeSessionDirName(cwd: string): string {
+	const home = os.homedir();
+	if (cwd === home || cwd.startsWith(`${home}/`) || cwd.startsWith(`${home}\\`)) {
+		const relative = cwd.slice(home.length).replace(/^[/\\]/, "");
+		return `-${relative.replace(/[/\\:]/g, "-")}`;
+	}
+	return `--${cwd.replace(/^[/\\]/, "").replace(/[/\\:]/g, "-")}--`;
+}
 /**
  * Compute the default session directory for a cwd.
  * Encodes cwd into a safe directory name under ~/.omp/agent/sessions/.
  */
 function getDefaultSessionDir(cwd: string, storage: SessionStorage): string {
-	const safePath = `--${cwd.replace(/^[/\\]/, "").replace(/[/\\:]/g, "-")}--`;
-	const sessionDir = path.join(getDefaultAgentDir(), "sessions", safePath);
+	migrateHomeSessionDirs();
+	const dirName = encodeSessionDirName(cwd);
+	const sessionDir = path.join(getDefaultAgentDir(), "sessions", dirName);
 	storage.ensureDirSync(sessionDir);
 	return sessionDir;
 }
@@ -476,40 +553,6 @@ function getDefaultSessionDir(cwd: string, storage: SessionStorage): string {
 
 const TERMINAL_SESSIONS_DIR = "terminal-sessions";
 
-/**
- * Get a stable identifier for the current terminal.
- * Uses the TTY device path (e.g., /dev/pts/3), falling back to environment
- * variables for terminal multiplexers or terminal emulators.
- * Returns null if no terminal can be identified (e.g., piped input).
- */
-function getTerminalId(): string | null {
-	// TTY device path — most reliable, unique per terminal tab
-	if (process.stdin.isTTY) {
-		try {
-			// On Linux/macOS, /proc/self/fd/0 -> /dev/pts/N
-			const ttyPath = fs.readlinkSync("/proc/self/fd/0");
-			if (ttyPath.startsWith("/dev/")) {
-				return ttyPath.slice(5).replace(/\//g, "-"); // /dev/pts/3 -> pts-3
-			}
-		} catch {}
-	}
-
-	// Fallback to terminal-specific env vars
-	const kittyId = process.env.KITTY_WINDOW_ID;
-	if (kittyId) return `kitty-${kittyId}`;
-
-	const tmuxPane = process.env.TMUX_PANE;
-	if (tmuxPane) return `tmux-${tmuxPane}`;
-
-	const terminalSessionId = process.env.TERM_SESSION_ID; // macOS Terminal.app
-	if (terminalSessionId) return `apple-${terminalSessionId}`;
-
-	const wtSession = process.env.WT_SESSION; // Windows Terminal
-	if (wtSession) return `wt-${wtSession}`;
-
-	return null;
-}
-
 /**
  * Write a breadcrumb linking the current terminal to a session file.
  * The breadcrumb contains the cwd and session path so --continue can

package/src/system-prompt.ts

@@ -2,7 +2,6 @@
  * System prompt construction and project context loading
  */
 import * as os from "node:os";
-import { getSystemInfo as getNativeSystemInfo, type SystemInfo } from "@oh-my-pi/pi-natives";
 import { $env, hasFsCode, isEnoent, logger } from "@oh-my-pi/pi-utils";
 import { getGpuCachePath, getProjectDir } from "@oh-my-pi/pi-utils/dirs";
 import { $ } from "bun";
@@ -310,35 +309,33 @@ async function saveGpuCache(info: GpuCache): Promise<void> {
 }
 
 async function getCachedGpu(): Promise<string | undefined> {
+	debugStartup("system-prompt:getEnvironmentInfo:getCachedGpu:start");
 	const cached = await loadGpuCache();
 	if (cached) return cached.gpu;
+	debugStartup("system-prompt:getEnvironmentInfo:getGpuModel");
 	const gpu = await getGpuModel();
+	debugStartup("system-prompt:getEnvironmentInfo:saveGpuCache");
 	if (gpu) await saveGpuCache({ gpu });
 	return gpu ?? undefined;
 }
 async function getEnvironmentInfo(): Promise<Array<{ label: string; value: string }>> {
-	let nativeInfo: SystemInfo | null = null;
-	try {
-		nativeInfo = getNativeSystemInfo();
-	} catch {
-		nativeInfo = null;
-	}
-
+	debugStartup("system-prompt:getEnvironmentInfo:getCachedGpu");
 	const gpu = await getCachedGpu();
+	debugStartup("system-prompt:getEnvironmentInfo:getCpuInfo");
 	const cpus = os.cpus();
+	debugStartup("system-prompt:getEnvironmentInfo:buildEntries");
 	const entries: Array<{ label: string; value: string | undefined }> = [
 		{ label: "OS", value: `${os.platform()} ${os.release()}` },
-		{ label: "Distro", value: nativeInfo?.distro ?? os.type() },
-		{ label: "Kernel", value: nativeInfo?.kernel ?? os.version() },
+		{ label: "Distro", value: os.type() },
+		{ label: "Kernel", value: os.version() },
 		{ label: "Arch", value: os.arch() },
-		{ label: "CPU", value: `${cpus.length}x ${nativeInfo?.cpu ?? cpus[0]?.model}` },
+		{ label: "CPU", value: `${cpus.length}x ${cpus[0]?.model}` },
 		{ label: "GPU", value: gpu },
-		{ label: "Disk", value: nativeInfo?.disk ?? undefined },
 		{ label: "Terminal", value: getTerminalName() },
 		{ label: "DE", value: getDesktopEnvironment() },
 		{ label: "WM", value: getWindowManager() },
 	];
-
+	debugStartup("system-prompt:getEnvironmentInfo:done");
 	return entries.filter((e): e is { label: string; value: string } => e.value != null && e.value !== "unknown");
 }
 

package/src/tools/fetch.ts

@@ -24,12 +24,13 @@ import { allocateOutputArtifact } from "./output-utils";
 import { formatExpandHint } from "./render-utils";
 import { ToolAbortError } from "./tool-errors";
 import { toolResult } from "./tool-result";
-import { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, truncateHead } from "./truncate";
+import { DEFAULT_MAX_BYTES, truncateHead } from "./truncate";
 
 // =============================================================================
 // Types and Constants
 // =============================================================================
 
+const FETCH_DEFAULT_MAX_LINES = 300;
 // Convertible document types (markitdown supported)
 const CONVERTIBLE_MIMES = new Set([
 	"application/pdf",
@@ -878,7 +879,10 @@ export class FetchTool implements AgentTool<typeof fetchSchema, FetchToolDetails
 		}
 
 		const result = await renderUrl(url, effectiveTimeout, raw, signal);
-		const truncation = truncateHead(result.content, { maxBytes: DEFAULT_MAX_BYTES, maxLines: DEFAULT_MAX_LINES });
+		const truncation = truncateHead(result.content, {
+			maxBytes: DEFAULT_MAX_BYTES,
+			maxLines: FETCH_DEFAULT_MAX_LINES,
+		});
 		const needsArtifact = truncation.truncated;
 		let artifactId: string | undefined;
 

package/src/tools/index.ts

@@ -24,7 +24,7 @@ import { FetchTool } from "./fetch";
 import { FindTool } from "./find";
 import { GrepTool } from "./grep";
 import { NotebookTool } from "./notebook";
-import { wrapToolsWithMetaNotice } from "./output-meta";
+import { wrapToolWithMetaNotice } from "./output-meta";
 import { PythonTool } from "./python";
 import { ReadTool } from "./read";
 import { reportFindingTool } from "./review";
@@ -328,7 +328,7 @@ export async function createTools(session: ToolSession, toolNames?: string[]): P
 		logger.debug("Tool factory timings", { slowTools });
 	}
 	const tools = results.filter(r => r.tool !== null).map(r => r.tool as Tool);
-	const wrappedTools = wrapToolsWithMetaNotice(tools);
+	const wrappedTools = tools.map(wrapToolWithMetaNotice);
 
 	if (filteredRequestedTools !== undefined) {
 		const allowed = new Set(filteredRequestedTools);

package/src/tools/output-meta.ts

@@ -4,7 +4,13 @@
  * Tools populate details.meta using the fluent OutputMetaBuilder.
  * The tool wrapper automatically formats and appends notices at message boundary.
  */
-import type { AgentTool, AgentToolResult } from "@oh-my-pi/pi-agent-core";
+import type {
+	AgentTool,
+	AgentToolContext,
+	AgentToolExecFn,
+	AgentToolResult,
+	AgentToolUpdateCallback,
+} from "@oh-my-pi/pi-agent-core";
 import type { ImageContent, TextContent } from "@oh-my-pi/pi-ai";
 import type { OutputSummary } from "../session/streaming-output";
 import { renderError } from "./tool-errors";
@@ -335,7 +341,8 @@ export function formatOutputNotice(meta: OutputMeta | undefined): string {
 
 		if (t.nextOffset != null) {
 			notice += `. Use offset=${t.nextOffset} to continue`;
-		} else if (t.artifactId != null) {
+		}
+		if (t.artifactId != null) {
 			notice += `. Full: artifact://${t.artifactId}`;
 		}
 
@@ -396,31 +403,21 @@ function appendOutputNotice(
 	return result;
 }
 
-/**
- * Wrap a tool to:
- * 1. Automatically append output notices based on details.meta
- * 2. Handle ToolError rendering
- */
-export function wrapToolWithMetaNotice<T extends AgentTool<any, any, any>>(tool: T): T {
-	const originalExecute = tool.execute.bind(tool);
-
-	const wrappedExecute: typeof tool.execute = async (
-		toolCallId,
-		params,
-		signal,
-		onUpdate,
-		context,
-	): Promise<AgentToolResult<any, any>> => {
-		let result: AgentToolResult<any, any>;
-
-		try {
-			result = await originalExecute(toolCallId, params, signal, onUpdate, context);
-		} catch (e) {
-			// Re-throw with formatted message so agent-loop sets isError flag
-			throw new Error(renderError(e));
-		}
+const kUnwrappedExecute = Symbol("OutputMeta.UnwrappedExecute");
+
+async function wrappedExecute(
+	this: AgentTool & { [kUnwrappedExecute]: AgentToolExecFn },
+	toolCallId: string,
+	params: any,
+	signal?: AbortSignal,
+	onUpdate?: AgentToolUpdateCallback,
+	context?: AgentToolContext,
+): Promise<AgentToolResult> {
+	const originalExecute = this[kUnwrappedExecute];
 
+	try {
 		// Append notices from meta
+		const result = await originalExecute.call(this, toolCallId, params, signal, onUpdate, context);
 		const meta = (result.details as { meta?: OutputMeta } | undefined)?.meta;
 		if (meta) {
 			return {
@@ -428,26 +425,36 @@ export function wrapToolWithMetaNotice<T extends AgentTool<any, any, any>>(tool:
 				content: appendOutputNotice(result.content, meta) as (TextContent | ImageContent)[],
 			};
 		}
-
 		return result;
-	};
-
-	// Use Proxy so property access (description, parameters, mode) stays on the original
-	// tool. Object.create(tool) would make getters run with this=wrapper, breaking
-	// private fields on tools like EditTool.
-	return new Proxy(tool, {
-		get(target, prop) {
-			if (prop === "execute") return wrappedExecute;
-			const value = (target as Record<string | symbol, unknown>)[prop];
-			if (typeof value === "function") return value.bind(target);
-			return value;
-		},
-	}) as T;
+	} catch (e) {
+		// Re-throw with formatted message so agent-loop sets isError flag
+		throw new Error(renderError(e));
+	}
 }
 
 /**
- * Wrap all tools with meta notice formatting and error handling.
+ * Wrap a tool to:
+ * 1. Automatically append output notices based on details.meta
+ * 2. Handle ToolError rendering
  */
-export function wrapToolsWithMetaNotice<T extends AgentTool<any, any, any>>(tools: T[]): T[] {
-	return tools.map(wrapToolWithMetaNotice);
+export function wrapToolWithMetaNotice<T extends AgentTool<any, any, any>>(tool: T): T {
+	if (kUnwrappedExecute in tool) {
+		return tool;
+	}
+
+	const originalExecute = tool.execute;
+
+	return Object.defineProperties(tool, {
+		[kUnwrappedExecute]: {
+			value: originalExecute,
+			enumerable: false,
+			configurable: true,
+		},
+		execute: {
+			value: wrappedExecute,
+			enumerable: false,
+			configurable: true,
+			writable: true,
+		},
+	});
 }