@oh-my-pi/pi-coding-agent 8.0.20 → 8.2.0

package/src/session/storage-migration.ts

@@ -1,12 +1,13 @@
 /**
- * Migrates legacy JSON storage (settings.json, auth.json) to SQLite-based agent.db.
- * Settings migrate only when the DB has no settings; auth merges per-provider when missing.
+ * Migrates legacy auth.json to SQLite-based agent.db.
+ * Auth credentials merge per-provider when missing.
  * Original JSON files are backed up to .bak and removed after successful migration.
+ *
+ * NOTE: Settings migration is now handled by SettingsManager.migrateToYaml(),
+ * which migrates from both settings.json and agent.db to config.yaml.
  */
-
-import { getAgentDbPath } from "@oh-my-pi/pi-coding-agent/config";
-import type { Settings } from "@oh-my-pi/pi-coding-agent/config/settings-manager";
 import { logger } from "@oh-my-pi/pi-utils";
+import { getAgentDbPath } from "../config";
 import { AgentStorage } from "./agent-storage";
 import type { AuthCredential, AuthCredentialEntry, AuthStorageData } from "./auth-storage";
 
@@ -14,7 +15,7 @@ import type { AuthCredential, AuthCredentialEntry, AuthStorageData } from "./aut
 type MigrationPaths = {
 	/** Directory containing agent.db */
 	agentDir: string;
-	/** Path to legacy settings.json file */
+	/** Path to legacy settings.json file (kept for API compatibility, no longer used) */
 	settingsPath: string;
 	/** Candidate paths to search for auth.json (checked in order) */
 	authPaths: string[];
@@ -22,7 +23,7 @@ type MigrationPaths = {
 
 /** Result of the JSON-to-SQLite storage migration. */
 export interface StorageMigrationResult {
-	/** Whether settings.json was migrated to agent.db */
+	/** Whether settings.json was migrated (always false - settings migration is handled elsewhere) */
 	migratedSettings: boolean;
 	/** Whether auth.json was migrated to agent.db */
 	migratedAuth: boolean;
@@ -39,20 +40,6 @@ function isRecord(value: unknown): value is Record<string, unknown> {
 	return !!value && typeof value === "object" && !Array.isArray(value);
 }
 
-/**
- * Transforms legacy settings to current schema (e.g., queueMode -> steeringMode).
- * @param settings - Settings object potentially containing deprecated keys
- * @returns Settings with deprecated keys renamed to current equivalents
- */
-function migrateLegacySettings(settings: Settings): Settings {
-	const migrated = { ...settings } as Record<string, unknown>;
-	if ("queueMode" in migrated && !("steeringMode" in migrated)) {
-		migrated.steeringMode = migrated.queueMode;
-		delete migrated.queueMode;
-	}
-	return migrated as Settings;
-}
-
 /**
  * Normalizes credential entries to array format (legacy stored single credentials).
  * @param entry - Single credential or array of credentials
@@ -99,32 +86,6 @@ async function backupJson(path: string): Promise<void> {
 	}
 }
 
-/**
- * Migrates settings.json to SQLite storage if DB is empty.
- * @param storage - AgentStorage instance to migrate into
- * @param settingsPath - Path to legacy settings.json
- * @param warnings - Array to collect non-fatal warnings
- * @returns True if migration was performed
- */
-async function migrateSettings(storage: AgentStorage, settingsPath: string, warnings: string[]): Promise<boolean> {
-	const settingsFile = Bun.file(settingsPath);
-	const settingsExists = await settingsFile.exists();
-	const hasDbSettings = storage.getSettings() !== null;
-
-	if (!settingsExists) return false;
-	if (hasDbSettings) {
-		warnings.push(`settings.json exists but agent.db is authoritative: ${settingsPath}`);
-		return false;
-	}
-
-	const settingsJson = await readJsonFile<Settings>(settingsPath);
-	if (!settingsJson) return false;
-
-	storage.saveSettings(migrateLegacySettings(settingsJson));
-	await backupJson(settingsPath);
-	return true;
-}
-
 /**
  * Finds the first valid auth.json from candidate paths (checked in priority order).
  * @param authPaths - Candidate paths to search (e.g., project-local before global)
@@ -166,7 +127,7 @@ async function migrateAuth(storage: AgentStorage, authPaths: string[], warnings:
 	for (const [provider, entry] of Object.entries(authJson.data)) {
 		const credentials = normalizeCredentialEntry(entry)
 			.filter(isValidCredential)
-			.map((credential) => credential);
+			.map(credential => credential);
 
 		if (credentials.length === 0) continue;
 		sawValid = true;
@@ -191,19 +152,16 @@ async function migrateAuth(storage: AgentStorage, authPaths: string[], warnings:
 }
 
 /**
- * Migrates legacy JSON files (settings.json, auth.json) to SQLite-based agent.db.
- * Settings migrate only when the DB has no settings; auth merges per-provider when missing.
+ * Migrates legacy auth.json to SQLite-based agent.db.
+ * Settings migration is handled separately by SettingsManager.migrateToYaml().
  * @param paths - Configuration specifying locations of legacy files and target DB
  * @returns Result indicating what was migrated and any warnings encountered
  */
 export async function migrateJsonStorage(paths: MigrationPaths): Promise<StorageMigrationResult> {
-	const storage = AgentStorage.open(getAgentDbPath(paths.agentDir));
+	const storage = await AgentStorage.open(getAgentDbPath(paths.agentDir));
 	const warnings: string[] = [];
 
-	const [migratedSettings, migratedAuth] = await Promise.all([
-		migrateSettings(storage, paths.settingsPath, warnings),
-		migrateAuth(storage, paths.authPaths, warnings),
-	]);
+	const migratedAuth = await migrateAuth(storage, paths.authPaths, warnings);
 
 	if (warnings.length > 0) {
 		for (const warning of warnings) {
@@ -211,5 +169,5 @@ export async function migrateJsonStorage(paths: MigrationPaths): Promise<Storage
 		}
 	}
 
-	return { migratedSettings, migratedAuth, warnings };
+	return { migratedSettings: false, migratedAuth, warnings };
 }

package/src/session/streaming-output.ts

@@ -1,5 +1,5 @@
-import { DEFAULT_MAX_BYTES } from "@oh-my-pi/pi-coding-agent/tools/truncate";
 import { sanitizeText } from "@oh-my-pi/pi-utils";
+import { DEFAULT_MAX_BYTES } from "../tools/truncate";
 
 export interface OutputSummary {
 	output: string;
@@ -141,7 +141,7 @@ export class OutputSink {
 		};
 
 		return new WritableStream<Uint8Array | string>({
-			write: async (chunk) => {
+			write: async chunk => {
 				if (typeof chunk === "string") {
 					await this.push(chunk);
 				} else {

package/src/ssh/connection-manager.ts

@@ -1,9 +1,9 @@
-import { chmodSync, existsSync, mkdirSync, readFileSync, statSync } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
-import { CONFIG_DIR_NAME } from "@oh-my-pi/pi-coding-agent/config";
-import { logger } from "@oh-my-pi/pi-utils";
+import * as fs from "node:fs/promises";
+import * as os from "node:os";
+import * as path from "node:path";
+import { isEnoent, logger } from "@oh-my-pi/pi-utils";
 import { $ } from "bun";
+import { CONFIG_DIR_NAME } from "../config";
 
 export interface SSHConnectionTarget {
 	name: string;
@@ -25,52 +25,44 @@ export interface SSHHostInfo {
 	compatEnabled: boolean;
 }
 
-const CONTROL_DIR = join(homedir(), CONFIG_DIR_NAME, "ssh-control");
-const CONTROL_PATH = join(CONTROL_DIR, "%h.sock");
-const HOST_INFO_DIR = join(homedir(), CONFIG_DIR_NAME, "remote-host");
+const CONTROL_DIR = path.join(os.homedir(), CONFIG_DIR_NAME, "ssh-control");
+const CONTROL_PATH = path.join(CONTROL_DIR, "%h.sock");
+const HOST_INFO_DIR = path.join(os.homedir(), CONFIG_DIR_NAME, "remote-host");
 const HOST_INFO_VERSION = 2;
 
 const activeHosts = new Map<string, SSHConnectionTarget>();
 const pendingConnections = new Map<string, Promise<void>>();
 const hostInfoCache = new Map<string, SSHHostInfo>();
 
-function ensureControlDir(): void {
-	if (!existsSync(CONTROL_DIR)) {
-		mkdirSync(CONTROL_DIR, { recursive: true, mode: 0o700 });
-	}
+async function ensureControlDir(): Promise<void> {
+	await fs.mkdir(CONTROL_DIR, { recursive: true, mode: 0o700 });
 	try {
-		chmodSync(CONTROL_DIR, 0o700);
+		await fs.chmod(CONTROL_DIR, 0o700);
 	} catch (err) {
 		logger.debug("SSH control dir chmod failed", { path: CONTROL_DIR, error: String(err) });
 	}
 }
 
-function ensureHostInfoDir(): void {
-	if (!existsSync(HOST_INFO_DIR)) {
-		mkdirSync(HOST_INFO_DIR, { recursive: true, mode: 0o700 });
-	}
-	try {
-		chmodSync(HOST_INFO_DIR, 0o700);
-	} catch (err) {
-		logger.debug("SSH host info dir chmod failed", { path: HOST_INFO_DIR, error: String(err) });
-	}
-}
-
 function sanitizeHostName(name: string): string {
 	const sanitized = name.replace(/[^a-zA-Z0-9._-]+/g, "_");
 	return sanitized.length > 0 ? sanitized : "host";
 }
 
 function getHostInfoPath(name: string): string {
-	return join(HOST_INFO_DIR, `${sanitizeHostName(name)}.json`);
+	return path.join(HOST_INFO_DIR, `${sanitizeHostName(name)}.json`);
 }
 
-function validateKeyPermissions(keyPath?: string): void {
+async function validateKeyPermissions(keyPath?: string): Promise<void> {
 	if (!keyPath) return;
-	if (!existsSync(keyPath)) {
-		throw new Error(`SSH key not found: ${keyPath}`);
+	let stats: Awaited<ReturnType<typeof fs.stat>>;
+	try {
+		stats = await fs.stat(keyPath);
+	} catch (err) {
+		if (isEnoent(err)) {
+			throw new Error(`SSH key not found: ${keyPath}`);
+		}
+		throw err;
 	}
-	const stats = statSync(keyPath);
 	if (!stats.isFile()) {
 		throw new Error(`SSH key is not a file: ${keyPath}`);
 	}
@@ -208,31 +200,31 @@ function shouldRefreshHostInfo(host: SSHConnectionTarget, info: SSHHostInfo): bo
 	return false;
 }
 
-function loadHostInfoFromDisk(host: SSHConnectionTarget): SSHHostInfo | undefined {
+async function loadHostInfoFromDisk(host: SSHConnectionTarget): Promise<SSHHostInfo | undefined> {
 	const path = getHostInfoPath(host.name);
-	if (!existsSync(path)) return undefined;
 	try {
-		const raw = readFileSync(path, "utf-8");
+		const raw = await fs.readFile(path, "utf-8");
 		const parsed = parseHostInfo(JSON.parse(raw));
 		if (!parsed) return undefined;
 		const resolved = applyCompatOverride(host, parsed);
 		hostInfoCache.set(host.name, resolved);
 		return resolved;
 	} catch (err) {
+		if (isEnoent(err)) return undefined;
 		logger.warn("Failed to load SSH host info", { host: host.name, error: String(err) });
 		return undefined;
 	}
 }
 
-function loadHostInfoFromDiskByName(hostName: string): SSHHostInfo | undefined {
+async function loadHostInfoFromDiskByName(hostName: string): Promise<SSHHostInfo | undefined> {
 	const path = getHostInfoPath(hostName);
-	if (!existsSync(path)) return undefined;
 	try {
-		const raw = readFileSync(path, "utf-8");
+		const raw = await fs.readFile(path, "utf-8");
 		const parsed = parseHostInfo(JSON.parse(raw));
 		if (!parsed) return undefined;
 		return parsed;
 	} catch (err) {
+		if (isEnoent(err)) return undefined;
 		logger.warn("Failed to load SSH host info", { host: hostName, error: String(err) });
 		return undefined;
 	}
@@ -240,7 +232,6 @@ function loadHostInfoFromDiskByName(hostName: string): SSHHostInfo | undefined {
 
 async function persistHostInfo(host: SSHConnectionTarget, info: SSHHostInfo): Promise<void> {
 	try {
-		ensureHostInfoDir();
 		const path = getHostInfoPath(host.name);
 		const payload = { ...info, version: HOST_INFO_VERSION };
 		hostInfoCache.set(host.name, payload);
@@ -252,7 +243,7 @@ async function persistHostInfo(host: SSHConnectionTarget, info: SSHHostInfo): Pr
 
 async function probeHostInfo(host: SSHConnectionTarget): Promise<SSHHostInfo> {
 	const command = 'echo "$OSTYPE|$SHELL|$BASH_VERSION" 2>/dev/null || echo "%OS%|%COMSPEC%|"';
-	const result = await runSshCaptureSync(buildRemoteCommand(host, command));
+	const result = await runSshCaptureSync(await buildRemoteCommand(host, command));
 	if (result.exitCode !== 0 && !result.stdout) {
 		logger.debug("SSH host probe failed", { host: host.name, error: result.stderr });
 		const fallback: SSHHostInfo = {
@@ -315,11 +306,11 @@ async function probeHostInfo(host: SSHConnectionTarget): Promise<SSHHostInfo> {
 	const hasBash = !unexpandedPosixVars && (Boolean(bashVersion) || shell === "bash");
 	let compatShell: SSHHostInfo["compatShell"];
 	if (os === "windows" && host.compat !== false) {
-		const bashProbe = await runSshCaptureSync(buildRemoteCommand(host, 'bash -lc "echo OMP_BASH_OK"'));
+		const bashProbe = await runSshCaptureSync(await buildRemoteCommand(host, 'bash -lc "echo OMP_BASH_OK"'));
 		if (bashProbe.exitCode === 0 && bashProbe.stdout.includes("OMP_BASH_OK")) {
 			compatShell = "bash";
 		} else {
-			const shProbe = await runSshCaptureSync(buildRemoteCommand(host, 'sh -lc "echo OMP_SH_OK"'));
+			const shProbe = await runSshCaptureSync(await buildRemoteCommand(host, 'sh -lc "echo OMP_SH_OK"'));
 			if (shProbe.exitCode === 0 && shProbe.stdout.includes("OMP_SH_OK")) {
 				compatShell = "sh";
 			}
@@ -344,18 +335,20 @@ async function probeHostInfo(host: SSHConnectionTarget): Promise<SSHHostInfo> {
 	return info;
 }
 
-export function getHostInfo(hostName: string): SSHHostInfo | undefined {
-	return hostInfoCache.get(hostName) ?? loadHostInfoFromDiskByName(hostName);
+export async function getHostInfo(hostName: string): Promise<SSHHostInfo | undefined> {
+	const cached = hostInfoCache.get(hostName);
+	if (cached) return cached;
+	return loadHostInfoFromDiskByName(hostName);
 }
 
-export function getHostInfoForHost(host: SSHConnectionTarget): SSHHostInfo | undefined {
+export async function getHostInfoForHost(host: SSHConnectionTarget): Promise<SSHHostInfo | undefined> {
 	const cached = hostInfoCache.get(host.name);
 	if (cached) {
 		const resolved = applyCompatOverride(host, cached);
 		if (resolved !== cached) hostInfoCache.set(host.name, resolved);
 		return resolved;
 	}
-	return loadHostInfoFromDisk(host);
+	return await loadHostInfoFromDisk(host);
 }
 
 export async function ensureHostInfo(host: SSHConnectionTarget): Promise<SSHHostInfo> {
@@ -365,7 +358,7 @@ export async function ensureHostInfo(host: SSHConnectionTarget): Promise<SSHHost
 		hostInfoCache.set(host.name, resolved);
 		if (!shouldRefreshHostInfo(host, resolved)) return resolved;
 	}
-	const fromDisk = loadHostInfoFromDisk(host);
+	const fromDisk = await loadHostInfoFromDisk(host);
 	if (fromDisk && !shouldRefreshHostInfo(host, fromDisk)) return fromDisk;
 	await ensureConnection(host);
 	const current = hostInfoCache.get(host.name);
@@ -373,8 +366,8 @@ export async function ensureHostInfo(host: SSHConnectionTarget): Promise<SSHHost
 	return probeHostInfo(host);
 }
 
-export function buildRemoteCommand(host: SSHConnectionTarget, command: string): string[] {
-	validateKeyPermissions(host.keyPath);
+export async function buildRemoteCommand(host: SSHConnectionTarget, command: string): Promise<string[]> {
+	await validateKeyPermissions(host.keyPath);
 	return [...buildCommonArgs(host), buildSshTarget(host), command];
 }
 
@@ -388,14 +381,14 @@ export async function ensureConnection(host: SSHConnectionTarget): Promise<void>
 
 	const promise = (async () => {
 		ensureSshBinary();
-		ensureControlDir();
-		validateKeyPermissions(host.keyPath);
+		await ensureControlDir();
+		await validateKeyPermissions(host.keyPath);
 
 		const target = buildSshTarget(host);
 		const check = await runSshSync(["-O", "check", ...buildCommonArgs(host), target]);
 		if (check.exitCode === 0) {
 			activeHosts.set(key, host);
-			if (!hostInfoCache.has(key) && !loadHostInfoFromDisk(host)) {
+			if (!hostInfoCache.has(key) && !(await loadHostInfoFromDisk(host))) {
 				await probeHostInfo(host);
 			}
 			return;
@@ -408,7 +401,7 @@ export async function ensureConnection(host: SSHConnectionTarget): Promise<void>
 		}
 
 		activeHosts.set(key, host);
-		if (!hostInfoCache.has(key) && !loadHostInfoFromDisk(host)) {
+		if (!hostInfoCache.has(key) && !(await loadHostInfoFromDisk(host))) {
 			await probeHostInfo(host);
 		}
 	})();

package/src/ssh/ssh-executor.ts

@@ -1,5 +1,5 @@
-import { OutputSink } from "@oh-my-pi/pi-coding-agent/session/streaming-output";
 import { cspawn, logger, ptree } from "@oh-my-pi/pi-utils";
+import { OutputSink } from "../session/streaming-output";
 import { buildRemoteCommand, ensureConnection, ensureHostInfo, type SSHConnectionTarget } from "./connection-manager";
 import { hasSshfs, mountRemote } from "./sshfs-mount";
 
@@ -76,7 +76,7 @@ export async function executeSSH(
 		}
 	}
 
-	const child = cspawn(["ssh", ...buildRemoteCommand(host, resolvedCommand)], {
+	const child = cspawn(["ssh", ...(await buildRemoteCommand(host, resolvedCommand))], {
 		signal: options?.signal,
 		timeout: options?.timeout,
 	});

package/src/ssh/sshfs-mount.ts

@@ -1,25 +1,21 @@
-import { chmodSync, existsSync, mkdirSync } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
-import { CONFIG_DIR_NAME } from "@oh-my-pi/pi-coding-agent/config";
-import { logger } from "@oh-my-pi/pi-utils";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
 import { $ } from "bun";
+import { CONFIG_DIR_NAME } from "../config";
 import { getControlDir, getControlPathTemplate, type SSHConnectionTarget } from "./connection-manager";
 
-const REMOTE_DIR = join(homedir(), CONFIG_DIR_NAME, "remote");
+const REMOTE_DIR = path.join(os.homedir(), CONFIG_DIR_NAME, "remote");
 const CONTROL_DIR = getControlDir();
 const CONTROL_PATH = getControlPathTemplate();
 
 const mountedPaths = new Set<string>();
 
-function ensureDir(path: string, mode = 0o700): void {
-	if (!existsSync(path)) {
-		mkdirSync(path, { recursive: true, mode });
-	}
+async function ensureDir(path: string, mode = 0o700): Promise<void> {
 	try {
-		chmodSync(path, mode);
-	} catch (err) {
-		logger.debug("SSHFS dir chmod failed", { path, error: String(err) });
+		await fs.promises.mkdir(path, { recursive: true, mode });
+	} catch {
+		await fs.promises.chmod(path, mode).catch(e => void e);
 	}
 }
 
@@ -30,7 +26,7 @@ function getMountName(host: SSHConnectionTarget): string {
 }
 
 function getMountPath(host: SSHConnectionTarget): string {
-	return join(REMOTE_DIR, getMountName(host));
+	return path.join(REMOTE_DIR, getMountName(host));
 }
 
 function buildSshTarget(host: SSHConnectionTarget): string {
@@ -95,11 +91,8 @@ export async function isMounted(path: string): Promise<boolean> {
 export async function mountRemote(host: SSHConnectionTarget, remotePath = "/"): Promise<string | undefined> {
 	if (!hasSshfs()) return undefined;
 
-	ensureDir(REMOTE_DIR);
-	ensureDir(CONTROL_DIR);
-
 	const mountPath = getMountPath(host);
-	ensureDir(mountPath);
+	await Promise.all([ensureDir(REMOTE_DIR), ensureDir(CONTROL_DIR), ensureDir(mountPath)]);
 
 	if (await isMounted(mountPath)) {
 		mountedPaths.add(mountPath);

package/src/system-prompt.ts

@@ -1,27 +1,19 @@
 /**
  * System prompt construction and project context loading
  */
-
-import { existsSync } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
-import { contextFileCapability } from "@oh-my-pi/pi-coding-agent/capability/context-file";
-import { systemPromptCapability } from "@oh-my-pi/pi-coding-agent/capability/system-prompt";
-import { renderPromptTemplate } from "@oh-my-pi/pi-coding-agent/config/prompt-templates";
-import type { SkillsSettings } from "@oh-my-pi/pi-coding-agent/config/settings-manager";
-import {
-	type ContextFile,
-	loadCapability,
-	type SystemPrompt as SystemPromptFile,
-} from "@oh-my-pi/pi-coding-agent/discovery/index";
-import { loadSkills, type Skill } from "@oh-my-pi/pi-coding-agent/extensibility/skills";
-import customSystemPromptTemplate from "@oh-my-pi/pi-coding-agent/prompts/system/custom-system-prompt.md" with {
-	type: "text",
-};
-import systemPromptTemplate from "@oh-my-pi/pi-coding-agent/prompts/system/system-prompt.md" with { type: "text" };
+import * as os from "node:os";
+import * as path from "node:path";
 import { $ } from "bun";
 import chalk from "chalk";
-import type { ToolName } from "./tools/index";
+import { contextFileCapability } from "./capability/context-file";
+import { systemPromptCapability } from "./capability/system-prompt";
+import { renderPromptTemplate } from "./config/prompt-templates";
+import type { SkillsSettings } from "./config/settings-manager";
+import { type ContextFile, loadCapability, type SystemPrompt as SystemPromptFile } from "./discovery";
+import { loadSkills, type Skill } from "./extensibility/skills";
+import customSystemPromptTemplate from "./prompts/system/custom-system-prompt.md" with { type: "text" };
+import systemPromptTemplate from "./prompts/system/system-prompt.md" with { type: "text" };
+import type { ToolName } from "./tools";
 
 interface GitContext {
 	isRepo: boolean;
@@ -42,7 +34,7 @@ export async function loadGitContext(cwd: string): Promise<GitContext | null> {
 			.quiet()
 			.text()
 			.catch(() => null)
-			.then((text) => text?.trim() ?? null);
+			.then(text => text?.trim() ?? null);
 
 	// Check if inside a git repo
 	const isGitRepo = await git("rev-parse", "--is-inside-work-tree");
@@ -86,7 +78,7 @@ function firstNonEmptyLine(value: string | null): string | null {
 	if (!value) return null;
 	const line = value
 		.split("\n")
-		.map((entry) => entry.trim())
+		.map(entry => entry.trim())
 		.filter(Boolean)[0];
 	return line ?? null;
 }
@@ -94,9 +86,9 @@ function firstNonEmptyLine(value: string | null): string | null {
 function parseWmicTable(output: string, header: string): string | null {
 	const lines = output
 		.split("\n")
-		.map((line) => line.trim())
+		.map(line => line.trim())
 		.filter(Boolean);
-	const filtered = lines.filter((line) => line.toLowerCase() !== header.toLowerCase());
+	const filtered = lines.filter(line => line.toLowerCase() !== header.toLowerCase());
 	return filtered[0] ?? null;
 }
 
@@ -137,8 +129,8 @@ function listAgentsMdFiles(root: string, limit: number): string[] {
 			new Bun.Glob(AGENTS_MD_PATTERN).scanSync({ cwd: root, onlyFiles: true, dot: false, absolute: false }),
 		);
 		const normalized = entries
-			.map((entry) => normalizePath(entry))
-			.filter((entry) => entry.length > 0 && !entry.includes("node_modules"))
+			.map(entry => normalizePath(entry))
+			.filter(entry => entry.length > 0 && !entry.includes("node_modules"))
 			.sort();
 		return normalized.length > limit ? normalized.slice(0, limit) : normalized;
 	} catch {
@@ -274,8 +266,8 @@ async function getCpuModel(): Promise<string | null> {
 			if (lscpu) {
 				const match = lscpu
 					.split("\n")
-					.map((line) => line.trim())
-					.find((line) => line.toLowerCase().startsWith("model name:"));
+					.map(line => line.trim())
+					.find(line => line.toLowerCase().startsWith("model name:"));
 				if (match) return match.split(":").slice(1).join(":").trim();
 			}
 			const cpuInfo = await Bun.file("/proc/cpuinfo")
@@ -370,7 +362,7 @@ function normalizeDesktopValue(value: string): string {
 	if (!trimmed) return "unknown";
 	const parts = trimmed
 		.split(":")
-		.map((part) => part.trim())
+		.map(part => part.trim())
 		.filter(Boolean);
 	return parts[0] ?? trimmed;
 }
@@ -436,14 +428,15 @@ interface SystemInfoCache {
 }
 
 function getSystemInfoCachePath(): string {
-	return join(homedir(), ".omp", "system_info.json");
+	return path.join(os.homedir(), ".omp", "system_info.json");
 }
 
 async function loadSystemInfoCache(): Promise<SystemInfoCache | null> {
 	try {
 		const cachePath = getSystemInfoCachePath();
-		if (!existsSync(cachePath)) return null;
-		const content = await Bun.file(cachePath).json();
+		const file = Bun.file(cachePath);
+		if (!(await file.exists())) return null;
+		const content = await file.json();
 		return content as SystemInfoCache;
 	} catch {
 		return null;
@@ -494,7 +487,7 @@ async function getDiskInfo(): Promise<string | null> {
 				.text()
 				.catch(() => null);
 			if (!output) return null;
-			const lines = output.split("\n").filter((l) => l.trim() && !l.startsWith("Node"));
+			const lines = output.split("\n").filter(l => l.trim() && !l.startsWith("Node"));
 			const disks: string[] = [];
 			for (const line of lines) {
 				const parts = line.split(",");
@@ -590,7 +583,7 @@ export async function loadProjectContextFiles(
 	const result = await loadCapability(contextFileCapability.id, { cwd: resolvedCwd });
 
 	// Convert ContextFile items and preserve depth info
-	const files = result.items.map((item) => {
+	const files = result.items.map(item => {
 		const contextFile = item as ContextFile;
 		return {
 			path: contextFile.path,
@@ -622,8 +615,8 @@ export async function loadSystemPromptFiles(options: LoadContextFilesOptions = {
 	if (result.items.length === 0) return null;
 
 	// Combine all SYSTEM.md contents (user-level first, then project-level)
-	const userLevel = result.items.filter((item) => item.level === "user");
-	const projectLevel = result.items.filter((item) => item.level === "project");
+	const userLevel = result.items.filter(item => item.level === "user");
+	const projectLevel = result.items.filter(item => item.level === "project");
 
 	const parts: string[] = [];
 	for (const item of [...userLevel, ...projectLevel]) {