@bastani/atomic 0.8.1-1 → 0.8.2-0

package/CHANGELOG.md

@@ -2,6 +2,19 @@
 
 ## [Unreleased]
 
+## [0.8.2-0] - 2026-05-16
+
+### Changed
+
+- Reduced the Atomic startup banner to a compact three-line mark.
+
+## [0.8.1] - 2026-05-15
+
+### Fixed
+
+- Fixed the Atomic changelog viewer to show only the current release notes instead of including older sections.
+- Fixed the published `@bastani/atomic` package manifest so Bun can install it outside the monorepo without resolving private workspace-only bundled packages.
+
 ## [0.8.1-1] - 2026-05-15
 
 ### Fixed

package/dist/builtin/intercom/config.ts

@@ -1,7 +1,5 @@
 import { existsSync, readFileSync } from "fs";
-import { join } from "path";
-import { homedir } from "os";
-import { CONFIG_DIR_NAME } from "@bastani/atomic";
+import { getAgentConfigPaths } from "@bastani/atomic";
 
 export interface IntercomConfig {
   /** Broker command used to spawn the broker process (e.g. "npx" or "bun") */
@@ -23,7 +21,8 @@ export interface IntercomConfig {
   replyHint: boolean;
 }
 
-const CONFIG_PATH = join(homedir(), CONFIG_DIR_NAME, "agent", "intercom", "config.json");
+const CONFIG_PATHS = getAgentConfigPaths("intercom", "config.json");
+const CONFIG_PATH = CONFIG_PATHS.find((path) => existsSync(path)) ?? CONFIG_PATHS[0]!;
 
 const defaults: IntercomConfig = {
   brokerCommand: "npx",

package/dist/builtin/intercom/index.ts

@@ -2,7 +2,7 @@ import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-age
 import { randomUUID } from "crypto";
 import { Type } from "typebox";
 import { Text } from "@mariozechner/pi-tui";
-import { APP_NAME } from "@bastani/atomic";
+import { APP_NAME, getEnvValue } from "@bastani/atomic";
 import { IntercomClient } from "./broker/client.ts";
 import { spawnBrokerIfNeeded } from "./broker/spawn.ts";
 import { SessionListOverlay } from "./ui/session-list.ts";
@@ -79,14 +79,14 @@ function formatAttachments(attachments: Attachment[]): string {
   return text;
 }
 function readChildOrchestratorMetadata(): ChildOrchestratorMetadata | null {
-  const orchestratorTarget = process.env[SUBAGENT_ORCHESTRATOR_TARGET_ENV]?.trim();
-  const runId = process.env[SUBAGENT_RUN_ID_ENV]?.trim();
-  const agent = process.env[SUBAGENT_CHILD_AGENT_ENV]?.trim();
-  const index = process.env[SUBAGENT_CHILD_INDEX_ENV]?.trim();
+  const orchestratorTarget = getEnvValue(SUBAGENT_ORCHESTRATOR_TARGET_ENV)?.trim();
+  const runId = getEnvValue(SUBAGENT_RUN_ID_ENV)?.trim();
+  const agent = getEnvValue(SUBAGENT_CHILD_AGENT_ENV)?.trim();
+  const index = getEnvValue(SUBAGENT_CHILD_INDEX_ENV)?.trim();
   if (!orchestratorTarget || !runId || !agent || !index) {
     return null;
   }
-  const sessionName = process.env[SUBAGENT_INTERCOM_SESSION_NAME_ENV]?.trim();
+  const sessionName = getEnvValue(SUBAGENT_INTERCOM_SESSION_NAME_ENV)?.trim();
   return {
     orchestratorTarget,
     runId,

package/dist/builtin/intercom/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/intercom",
-  "version": "0.8.1-1",
+  "version": "0.8.2-0",
   "private": true,
   "description": "Atomic extension providing a private coordination channel between parent and child agent sessions.",
   "contributors": [

package/dist/builtin/mcp/agent-dir.ts

@@ -1,9 +1,9 @@
 import { homedir } from "node:os";
 import { join, resolve } from "node:path";
-import { APP_NAME, CONFIG_DIR_NAME } from "@bastani/atomic";
+import { APP_NAME, CONFIG_DIR_NAME, getAgentDirs as getAtomicAgentDirs, getEnvValue } from "@bastani/atomic";
 
 export function getAgentDir(): string {
-  const configured = process.env[`${APP_NAME.toUpperCase()}_CODING_AGENT_DIR`]?.trim();
+  const configured = getEnvValue(`${APP_NAME.toUpperCase()}_CODING_AGENT_DIR`)?.trim();
   if (!configured) {
     return join(homedir(), CONFIG_DIR_NAME, "agent");
   }
@@ -16,6 +16,15 @@ export function getAgentDir(): string {
   return resolve(configured);
 }
 
+export function getAgentDirs(): string[] {
+  const configured = getEnvValue(`${APP_NAME.toUpperCase()}_CODING_AGENT_DIR`)?.trim();
+  return configured ? [getAgentDir()] : getAtomicAgentDirs();
+}
+
 export function getAgentPath(...segments: string[]): string {
   return join(getAgentDir(), ...segments);
 }
+
+export function getAgentPaths(...segments: string[]): string[] {
+  return getAgentDirs().map((dir) => join(dir, ...segments));
+}

package/dist/builtin/mcp/cli.js

@@ -4,7 +4,7 @@ import fs from "node:fs";
 import path from "node:path";
 import os from "node:os";
 import { pathToFileURL } from "node:url";
-import { APP_NAME, CONFIG_DIR_NAME } from "@bastani/atomic";
+import { APP_NAME, CONFIG_DIR_NAME, getAgentDirs, getEnvValue, getProjectConfigPaths } from "@bastani/atomic";
 
 const HOME = os.homedir();
 const AGENT_DIR_ENV = `${APP_NAME.toUpperCase()}_CODING_AGENT_DIR`;
@@ -15,13 +15,18 @@ function expandHome(input) {
   return path.resolve(input);
 }
 
-const AGENT_DIR = process.env[AGENT_DIR_ENV]?.trim()
-  ? expandHome(process.env[AGENT_DIR_ENV].trim())
+const AGENT_DIR_ENV_VALUE = getEnvValue(AGENT_DIR_ENV)?.trim();
+const AGENT_DIR = AGENT_DIR_ENV_VALUE
+  ? expandHome(AGENT_DIR_ENV_VALUE)
   : path.join(HOME, CONFIG_DIR_NAME, "agent");
 const PI_CONFIG_PATH = path.join(AGENT_DIR, "mcp.json");
+const PI_CONFIG_READ_PATHS = AGENT_DIR_ENV_VALUE
+  ? [PI_CONFIG_PATH]
+  : getAgentDirs().map((dir) => path.join(dir, "mcp.json"));
 const GENERIC_GLOBAL_CONFIG_PATH = path.join(HOME, ".config", "mcp", "mcp.json");
 const PROJECT_CONFIG_PATH = path.resolve(process.cwd(), ".mcp.json");
 const PROJECT_PI_CONFIG_PATH = path.resolve(process.cwd(), CONFIG_DIR_NAME, "mcp.json");
+const PROJECT_PI_CONFIG_READ_PATHS = getProjectConfigPaths(process.cwd(), "mcp.json");
 
 const IMPORT_PATHS = {
   cursor: [path.join(HOME, ".cursor", "mcp.json")],
@@ -50,14 +55,15 @@ function readJsonFile(filePath) {
 }
 
 function loadPiConfig() {
-  if (!fs.existsSync(PI_CONFIG_PATH)) {
+  const configPath = PI_CONFIG_READ_PATHS.find((candidate) => fs.existsSync(candidate));
+  if (!configPath) {
     return { mcpServers: {} };
   }
 
-  const raw = readJsonFile(PI_CONFIG_PATH);
+  const raw = readJsonFile(configPath);
   const mcpServers = raw.mcpServers ?? raw["mcp-servers"] ?? {};
   if (!mcpServers || typeof mcpServers !== "object" || Array.isArray(mcpServers)) {
-    throw new Error(`Invalid MCP config at ${PI_CONFIG_PATH}: expected \"mcpServers\" to be an object`);
+    throw new Error(`Invalid MCP config at ${configPath}: expected \"mcpServers\" to be an object`);
   }
 
   const normalized = { ...raw };

package/dist/builtin/mcp/config.ts

@@ -2,8 +2,8 @@
 import { existsSync, readFileSync, writeFileSync, mkdirSync, renameSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join, resolve } from "node:path";
-import { CONFIG_DIR_NAME } from "@bastani/atomic";
-import { getAgentPath } from "./agent-dir.ts";
+import { CONFIG_DIR_NAME, getProjectConfigPaths } from "@bastani/atomic";
+import { getAgentPath, getAgentPaths } from "./agent-dir.ts";
 import type { McpConfig, ServerEntry, McpSettings, ImportKind, ServerProvenance } from "./types.ts";
 
 const GENERIC_GLOBAL_CONFIG_PATH = join(homedir(), ".config", "mcp", "mcp.json");
@@ -106,6 +106,10 @@ export function getProjectPiConfigPath(cwd = process.cwd()): string {
   return resolve(cwd, PROJECT_PI_CONFIG_NAME);
 }
 
+function getProjectPiConfigPaths(cwd = process.cwd()): string[] {
+  return getProjectConfigPaths(cwd, "mcp.json").map((p) => resolve(p));
+}
+
 export function getConfigDiscoveryPaths(overridePath?: string, cwd = process.cwd()): ConfigDiscoveryPath[] {
   return getConfigSources(overridePath, cwd).map((source) => ({
     label: source.label,
@@ -195,8 +199,9 @@ export function loadMcpConfig(overridePath?: string, cwd = process.cwd()): McpCo
 
 function getConfigSources(overridePath?: string, cwd = process.cwd()): ConfigSourceSpec[] {
   const userPath = getPiGlobalConfigPath(overridePath);
+  const userPaths = overridePath ? [userPath] : getAgentPaths("mcp.json");
   const projectPath = getProjectConfigPath(cwd);
-  const projectPiPath = getProjectPiConfigPath(cwd);
+  const projectPiPaths = getProjectPiConfigPaths(cwd);
   const sources: ConfigSourceSpec[] = [];
 
   if (GENERIC_GLOBAL_CONFIG_PATH !== userPath) {
@@ -212,15 +217,17 @@ function getConfigSources(overridePath?: string, cwd = process.cwd()): ConfigSou
     });
   }
 
-  sources.push({
-    id: "pi-global",
-    label: "Pi global override",
-    readPath: userPath,
-    writePath: userPath,
-    kind: "user",
-    shared: false,
-    scope: "global",
-  });
+  for (const readPath of userPaths.reverse()) {
+    sources.push({
+      id: "pi-global",
+      label: readPath === userPath ? "Pi global override" : "Pi legacy global override",
+      readPath,
+      writePath: userPath,
+      kind: "user",
+      shared: false,
+      scope: "global",
+    });
+  }
 
   if (projectPath !== userPath) {
     sources.push({
@@ -234,16 +241,18 @@ function getConfigSources(overridePath?: string, cwd = process.cwd()): ConfigSou
     });
   }
 
-  if (projectPiPath !== userPath && projectPiPath !== projectPath) {
-    sources.push({
-      id: "pi-project",
-      label: "project Pi override",
-      readPath: projectPiPath,
-      writePath: projectPiPath,
-      kind: "project",
-      shared: false,
-      scope: "project",
-    });
+  for (const projectPiPath of projectPiPaths.reverse()) {
+    if (projectPiPath !== userPath && projectPiPath !== projectPath) {
+      sources.push({
+        id: "pi-project",
+        label: projectPiPath === getProjectPiConfigPath(cwd) ? "project Pi override" : "project Pi legacy override",
+        readPath: projectPiPath,
+        writePath: getProjectPiConfigPath(cwd),
+        kind: "project",
+        shared: false,
+        scope: "project",
+      });
+    }
   }
 
   return sources;

package/dist/builtin/mcp/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/mcp",
-  "version": "0.8.1-1",
+  "version": "0.8.2-0",
   "private": true,
   "description": "Atomic extension that adapts MCP (Model Context Protocol) servers into the coding agent.",
   "contributors": [

package/dist/builtin/subagents/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/subagents",
-  "version": "0.8.1-1",
+  "version": "0.8.2-0",
   "private": true,
   "description": "Atomic extension for delegating tasks to subagents with chains, parallel execution, and TUI clarification.",
   "contributors": [

package/dist/builtin/subagents/src/agents/agents.ts

@@ -6,7 +6,7 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import { fileURLToPath } from "node:url";
-import { CONFIG_DIR_NAME } from "@bastani/atomic";
+import { CONFIG_DIR_NAME, getAgentConfigPaths, getProjectConfigDirs } from "@bastani/atomic";
 import type { OutputMode } from "../shared/types.ts";
 import { KNOWN_FIELDS } from "./agent-serializer.ts";
 import { parseChain } from "./chain-serializer.ts";
@@ -132,7 +132,15 @@ interface AgentDiscoveryResult {
 }
 
 function getUserChainDir(): string {
-	return path.join(os.homedir(), CONFIG_DIR_NAME, "agent", "chains");
+	return getAgentConfigPaths("chains")[0] ?? path.join(os.homedir(), CONFIG_DIR_NAME, "agent", "chains");
+}
+
+function getUserChainDirs(): string[] {
+	return getAgentConfigPaths("chains");
+}
+
+function getUserAgentDirs(): string[] {
+	return getAgentConfigPaths("agents");
 }
 
 function splitToolList(rawTools: string[] | undefined): { tools?: string[]; mcpDirectTools?: string[] } {
@@ -207,7 +215,7 @@ function cloneOverrideValue(override: BuiltinAgentOverrideConfig): BuiltinAgentO
 function findNearestProjectRoot(cwd: string): string | null {
 	let currentDir = cwd;
 	while (true) {
-		if (isDirectory(path.join(currentDir, CONFIG_DIR_NAME)) || isDirectory(path.join(currentDir, ".agents"))) {
+		if (getProjectConfigDirs(currentDir).some(isDirectory) || isDirectory(path.join(currentDir, ".agents"))) {
 			return currentDir;
 		}
 
@@ -218,12 +226,21 @@ function findNearestProjectRoot(cwd: string): string | null {
 }
 
 function getUserAgentSettingsPath(): string {
-	return path.join(os.homedir(), CONFIG_DIR_NAME, "agent", "settings.json");
+	return getAgentConfigPaths("settings.json")[0] ?? path.join(os.homedir(), CONFIG_DIR_NAME, "agent", "settings.json");
+}
+
+function getUserAgentSettingsPaths(): string[] {
+	return getAgentConfigPaths("settings.json");
 }
 
 function getProjectAgentSettingsPath(cwd: string): string | null {
 	const projectRoot = findNearestProjectRoot(cwd);
-	return projectRoot ? path.join(projectRoot, CONFIG_DIR_NAME, "settings.json") : null;
+	return projectRoot ? path.join(getProjectConfigDirs(projectRoot)[0]!, "settings.json") : null;
+}
+
+function getProjectAgentSettingsPaths(cwd: string): string[] {
+	const projectRoot = findNearestProjectRoot(cwd);
+	return projectRoot ? getProjectConfigDirs(projectRoot).map((dir) => path.join(dir, "settings.json")) : [];
 }
 
 function readSettingsFileStrict(filePath: string): Record<string, unknown> {
@@ -413,6 +430,22 @@ function applyBuiltinOverride(
 	return next;
 }
 
+function readMergedSubagentSettings(filePaths: string[]): { settings: SubagentSettings; path: string | null } {
+	let settings = EMPTY_SUBAGENT_SETTINGS;
+	let path: string | null = null;
+	for (let i = filePaths.length - 1; i >= 0; i--) {
+		const filePath = filePaths[i]!;
+		if (!fs.existsSync(filePath)) continue;
+		const next = readSubagentSettings(filePath);
+		settings = {
+			disableBuiltins: next.disableBuiltins ?? settings.disableBuiltins,
+			overrides: { ...settings.overrides, ...next.overrides },
+		};
+		path = filePath;
+	}
+	return { settings, path };
+}
+
 function applyBuiltinOverrides(
 	builtinAgents: AgentConfig[],
 	userSettings: SubagentSettings,
@@ -700,10 +733,13 @@ function resolveNearestProjectAgentDirs(cwd: string): { readDirs: string[]; pref
 	if (!projectRoot) return { readDirs: [], preferredDir: null };
 
 	const legacyDir = path.join(projectRoot, ".agents");
-	const preferredDir = path.join(projectRoot, CONFIG_DIR_NAME, "agents");
+	const preferredDir = path.join(getProjectConfigDirs(projectRoot)[0]!, "agents");
 	const readDirs: string[] = [];
 	if (isDirectory(legacyDir)) readDirs.push(legacyDir);
-	if (isDirectory(preferredDir)) readDirs.push(preferredDir);
+	for (const configDir of getProjectConfigDirs(projectRoot).reverse()) {
+		const agentsDir = path.join(configDir, "agents");
+		if (isDirectory(agentsDir)) readDirs.push(agentsDir);
+	}
 
 	return {
 		readDirs,
@@ -715,22 +751,24 @@ function resolveNearestProjectChainDirs(cwd: string): { readDirs: string[]; pref
 	const projectRoot = findNearestProjectRoot(cwd);
 	if (!projectRoot) return { readDirs: [], preferredDir: null };
 
-	const preferredDir = path.join(projectRoot, CONFIG_DIR_NAME, "chains");
+	const preferredDir = path.join(getProjectConfigDirs(projectRoot)[0]!, "chains");
 	return {
-		readDirs: isDirectory(preferredDir) ? [preferredDir] : [],
+		readDirs: getProjectConfigDirs(projectRoot).reverse().map((configDir) => path.join(configDir, "chains")).filter(isDirectory),
 		preferredDir,
 	};
 }
 const BUILTIN_AGENTS_DIR = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..", "agents");
 
 export function discoverAgents(cwd: string, scope: AgentScope): AgentDiscoveryResult {
-	const userDirOld = path.join(os.homedir(), CONFIG_DIR_NAME, "agent", "agents");
+	const userDirOld = getUserAgentDirs();
 	const userDirNew = path.join(os.homedir(), ".agents");
 	const { readDirs: projectAgentDirs, preferredDir: projectAgentsDir } = resolveNearestProjectAgentDirs(cwd);
-	const userSettingsPath = getUserAgentSettingsPath();
-	const projectSettingsPath = getProjectAgentSettingsPath(cwd);
-	const userSettings = scope === "project" ? EMPTY_SUBAGENT_SETTINGS : readSubagentSettings(userSettingsPath);
-	const projectSettings = scope === "user" ? EMPTY_SUBAGENT_SETTINGS : readSubagentSettings(projectSettingsPath);
+	const userSettingsLoad = readMergedSubagentSettings(getUserAgentSettingsPaths());
+	const projectSettingsLoad = readMergedSubagentSettings(getProjectAgentSettingsPaths(cwd));
+	const userSettingsPath = userSettingsLoad.path ?? getUserAgentSettingsPath();
+	const projectSettingsPath = projectSettingsLoad.path ?? getProjectAgentSettingsPath(cwd);
+	const userSettings = scope === "project" ? EMPTY_SUBAGENT_SETTINGS : userSettingsLoad.settings;
+	const projectSettings = scope === "user" ? EMPTY_SUBAGENT_SETTINGS : projectSettingsLoad.settings;
 
 	const builtinAgents = applyBuiltinOverrides(
 		loadAgentsFromDir(BUILTIN_AGENTS_DIR, "builtin"),
@@ -740,7 +778,7 @@ export function discoverAgents(cwd: string, scope: AgentScope): AgentDiscoveryRe
 		projectSettingsPath,
 	);
 
-	const userAgentsOld = scope === "project" ? [] : loadAgentsFromDir(userDirOld, "user");
+	const userAgentsOld = scope === "project" ? [] : userDirOld.flatMap((dir) => loadAgentsFromDir(dir, "user"));
 	const userAgentsNew = scope === "project" ? [] : loadAgentsFromDir(userDirNew, "user");
 	const userAgents = [...userAgentsOld, ...userAgentsNew];
 
@@ -763,15 +801,17 @@ export function discoverAgentsAll(cwd: string): {
 	userSettingsPath: string;
 	projectSettingsPath: string | null;
 } {
-	const userDirOld = path.join(os.homedir(), CONFIG_DIR_NAME, "agent", "agents");
+	const userDirOld = getUserAgentDirs();
 	const userDirNew = path.join(os.homedir(), ".agents");
 	const userChainDir = getUserChainDir();
 	const { readDirs: projectDirs, preferredDir: projectDir } = resolveNearestProjectAgentDirs(cwd);
 	const { readDirs: projectChainDirs, preferredDir: projectChainDir } = resolveNearestProjectChainDirs(cwd);
-	const userSettingsPath = getUserAgentSettingsPath();
-	const projectSettingsPath = getProjectAgentSettingsPath(cwd);
-	const userSettings = readSubagentSettings(userSettingsPath);
-	const projectSettings = readSubagentSettings(projectSettingsPath);
+	const userSettingsLoad = readMergedSubagentSettings(getUserAgentSettingsPaths());
+	const projectSettingsLoad = readMergedSubagentSettings(getProjectAgentSettingsPaths(cwd));
+	const userSettingsPath = userSettingsLoad.path ?? getUserAgentSettingsPath();
+	const projectSettingsPath = projectSettingsLoad.path ?? getProjectAgentSettingsPath(cwd);
+	const userSettings = userSettingsLoad.settings;
+	const projectSettings = projectSettingsLoad.settings;
 
 	const builtin = applyBuiltinOverrides(
 		loadAgentsFromDir(BUILTIN_AGENTS_DIR, "builtin"),
@@ -781,7 +821,7 @@ export function discoverAgentsAll(cwd: string): {
 		projectSettingsPath,
 	);
 	const user = [
-		...loadAgentsFromDir(userDirOld, "user"),
+		...userDirOld.flatMap((dir) => loadAgentsFromDir(dir, "user")),
 		...loadAgentsFromDir(userDirNew, "user"),
 	];
 	const projectMap = new Map<string, AgentConfig>();
@@ -799,11 +839,11 @@ export function discoverAgentsAll(cwd: string): {
 		}
 	}
 	const chains = [
-		...loadChainsFromDir(userChainDir, "user"),
+		...getUserChainDirs().flatMap((dir) => loadChainsFromDir(dir, "user")),
 		...Array.from(chainMap.values()),
 	];
 
-	const userDir = fs.existsSync(userDirNew) ? userDirNew : userDirOld;
+	const userDir = fs.existsSync(userDirNew) ? userDirNew : userDirOld[0]!;
 
 	return { builtin, user, project, chains, userDir, projectDir, userChainDir, projectChainDir, userSettingsPath, projectSettingsPath };
 }

package/dist/builtin/subagents/src/agents/skills.ts

@@ -6,7 +6,7 @@ import { execSync } from "node:child_process";
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
-import { CONFIG_DIR_NAME as CONFIG_DIR } from "@bastani/atomic";
+import { getAgentConfigPaths, getAgentDirs, getProjectConfigDirs } from "@bastani/atomic";
 
 export type SkillSource =
 	| "project"
@@ -50,7 +50,6 @@ const MAX_CACHE_SIZE = 50;
 let loadSkillsCache: { cwd: string; skills: CachedSkillEntry[]; timestamp: number } | null = null;
 const LOAD_SKILLS_CACHE_TTL_MS = 5000;
 
-const AGENT_DIR = path.join(os.homedir(), CONFIG_DIR, "agent");
 const SUBAGENT_ORCHESTRATION_SKILL = "subagent";
 
 const SOURCE_PRIORITY: Record<SkillSource, number> = {
@@ -135,8 +134,8 @@ function getGlobalNpmRoot(): string | null {
 
 function collectInstalledPackageSkillPaths(cwd: string): SkillSearchPath[] {
 	const dirs: SkillSearchPath[] = [
-		{ path: path.join(cwd, CONFIG_DIR, "npm", "node_modules"), source: "project-package" },
-		{ path: path.join(AGENT_DIR, "npm", "node_modules"), source: "user-package" },
+		...getProjectConfigDirs(cwd).map((configDir) => ({ path: path.join(configDir, "npm", "node_modules"), source: "project-package" as const })),
+		...getAgentConfigPaths("npm", "node_modules").map((dir) => ({ path: dir, source: "user-package" as const })),
 	];
 
 	const globalRoot = getGlobalNpmRoot();
@@ -187,8 +186,8 @@ function collectInstalledPackageSkillPaths(cwd: string): SkillSearchPath[] {
 function collectSettingsSkillPaths(cwd: string): SkillSearchPath[] {
 	const results: SkillSearchPath[] = [];
 	const settingsFiles = [
-		{ file: path.join(cwd, CONFIG_DIR, "settings.json"), base: path.join(cwd, CONFIG_DIR), source: "project-settings" as const },
-		{ file: path.join(AGENT_DIR, "settings.json"), base: AGENT_DIR, source: "user-settings" as const },
+		...getProjectConfigDirs(cwd).map((configDir) => ({ file: path.join(configDir, "settings.json"), base: configDir, source: "project-settings" as const })),
+		...getAgentConfigPaths("settings.json").map((file) => ({ file, base: path.dirname(file), source: "user-settings" as const })),
 	];
 
 	for (const { file, base, source } of settingsFiles) {
@@ -287,8 +286,8 @@ function resolveSettingsPackageRoot(source: string, baseDir: string): string | u
 
 function collectSettingsPackageSkillPaths(cwd: string): SkillSearchPath[] {
 	const settingsFiles = [
-		{ file: path.join(cwd, CONFIG_DIR, "settings.json"), base: path.join(cwd, CONFIG_DIR), source: "project-package" as const },
-		{ file: path.join(AGENT_DIR, "settings.json"), base: AGENT_DIR, source: "user-package" as const },
+		...getProjectConfigDirs(cwd).map((configDir) => ({ file: path.join(configDir, "settings.json"), base: configDir, source: "project-package" as const })),
+		...getAgentConfigPaths("settings.json").map((file) => ({ file, base: path.dirname(file), source: "user-package" as const })),
 	];
 	const results: SkillSearchPath[] = [];
 
@@ -317,9 +316,9 @@ function collectSettingsPackageSkillPaths(cwd: string): SkillSearchPath[] {
 
 function buildSkillPaths(cwd: string): SkillSearchPath[] {
 	const skillPaths: SkillSearchPath[] = [
-		{ path: path.join(cwd, CONFIG_DIR, "skills"), source: "project" },
+		...getProjectConfigDirs(cwd).map((configDir) => ({ path: path.join(configDir, "skills"), source: "project" as const })),
 		{ path: path.join(cwd, ".agents", "skills"), source: "project" },
-		{ path: path.join(AGENT_DIR, "skills"), source: "user" },
+		...getAgentConfigPaths("skills").map((dir) => ({ path: dir, source: "user" as const })),
 		{ path: path.join(os.homedir(), ".agents", "skills"), source: "user" },
 		...collectInstalledPackageSkillPaths(cwd),
 		...collectSettingsPackageSkillPaths(cwd),
@@ -340,21 +339,22 @@ function buildSkillPaths(cwd: string): SkillSearchPath[] {
 function inferSkillSource(filePath: string, cwd: string, sourceHint?: SkillSource): SkillSource {
 	if (sourceHint) return sourceHint;
 
-	const projectConfigRoot = path.resolve(cwd, CONFIG_DIR);
-	const projectSkillsRoot = path.resolve(cwd, CONFIG_DIR, "skills");
-	const projectPackagesRoot = path.resolve(cwd, CONFIG_DIR, "npm", "node_modules");
+	const projectConfigRoots = getProjectConfigDirs(cwd).map((dir) => path.resolve(dir));
+	const projectSkillsRoots = projectConfigRoots.map((dir) => path.join(dir, "skills"));
+	const projectPackagesRoots = projectConfigRoots.map((dir) => path.join(dir, "npm", "node_modules"));
 	const projectAgentsRoot = path.resolve(cwd, ".agents");
-	const userSkillsRoot = path.resolve(AGENT_DIR, "skills");
-	const userPackagesRoot = path.resolve(AGENT_DIR, "npm", "node_modules");
+	const userAgentRoots = getAgentDirs().map((dir) => path.resolve(dir));
+	const userSkillsRoots = userAgentRoots.map((dir) => path.join(dir, "skills"));
+	const userPackagesRoots = userAgentRoots.map((dir) => path.join(dir, "npm", "node_modules"));
 	const userAgentsRoot = path.resolve(os.homedir(), ".agents");
 
-	if (isWithinPath(filePath, projectPackagesRoot)) return "project-package";
-	if (isWithinPath(filePath, projectSkillsRoot) || isWithinPath(filePath, projectAgentsRoot)) return "project";
-	if (isWithinPath(filePath, projectConfigRoot)) return "project-settings";
+	if (projectPackagesRoots.some((root) => isWithinPath(filePath, root))) return "project-package";
+	if (projectSkillsRoots.some((root) => isWithinPath(filePath, root)) || isWithinPath(filePath, projectAgentsRoot)) return "project";
+	if (projectConfigRoots.some((root) => isWithinPath(filePath, root))) return "project-settings";
 
-	if (isWithinPath(filePath, userPackagesRoot)) return "user-package";
-	if (isWithinPath(filePath, userSkillsRoot) || isWithinPath(filePath, userAgentsRoot)) return "user";
-	if (isWithinPath(filePath, AGENT_DIR)) return "user-settings";
+	if (userPackagesRoots.some((root) => isWithinPath(filePath, root))) return "user-package";
+	if (userSkillsRoots.some((root) => isWithinPath(filePath, root)) || isWithinPath(filePath, userAgentsRoot)) return "user";
+	if (userAgentRoots.some((root) => isWithinPath(filePath, root))) return "user-settings";
 
 	const globalRoot = getGlobalNpmRoot();
 	if (globalRoot && isWithinPath(filePath, globalRoot)) return "user-package";

package/dist/builtin/subagents/src/extension/index.ts

@@ -15,7 +15,7 @@
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
-import { CONFIG_DIR_NAME } from "@bastani/atomic";
+import { getAgentConfigPaths, getEnvValue } from "@bastani/atomic";
 import type { AgentToolResult } from "@earendil-works/pi-agent-core";
 import { type ExtensionAPI, type ExtensionContext, type ToolDefinition } from "@earendil-works/pi-coding-agent";
 import { Box, Container, Spacer, Text, truncateToWidth, visibleWidth, wrapTextWithAnsi, type Component } from "@earendil-works/pi-tui";
@@ -74,13 +74,14 @@ function getSubagentSessionRoot(parentSessionFile: string | null): string {
 }
 
 function loadConfig(): ExtensionConfig {
-	const configPath = path.join(os.homedir(), CONFIG_DIR_NAME, "agent", "extensions", "subagent", "config.json");
-	try {
-		if (fs.existsSync(configPath)) {
-			return JSON.parse(fs.readFileSync(configPath, "utf-8")) as ExtensionConfig;
+	for (const configPath of getAgentConfigPaths("extensions", "subagent", "config.json")) {
+		try {
+			if (fs.existsSync(configPath)) {
+				return JSON.parse(fs.readFileSync(configPath, "utf-8")) as ExtensionConfig;
+			}
+		} catch (error) {
+			console.error(`Failed to load subagent config from '${configPath}':`, error);
 		}
-	} catch (error) {
-		console.error(`Failed to load subagent config from '${configPath}':`, error);
 	}
 	return {};
 }
@@ -221,7 +222,7 @@ class SubagentControlNoticeComponent implements Component {
 }
 
 export default function registerSubagentExtension(pi: ExtensionAPI): void {
-	if (process.env[SUBAGENT_CHILD_ENV] === "1") return;
+	if (getEnvValue(SUBAGENT_CHILD_ENV) === "1") return;
 	const globalStore = globalThis as Record<string, unknown>;
 	const runtimeCleanupStoreKey = "__piSubagentRuntimeCleanup";
 	const previousRuntimeCleanup = globalStore[runtimeCleanupStoreKey];

package/dist/builtin/subagents/src/runs/shared/run-history.ts

@@ -1,7 +1,7 @@
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
-import { CONFIG_DIR_NAME } from "@bastani/atomic";
+import { getAgentConfigPaths } from "@bastani/atomic";
 
 export interface RunEntry {
 	agent: string;
@@ -12,7 +12,8 @@ export interface RunEntry {
 	exit?: number;
 }
 
-const HISTORY_PATH = path.join(os.homedir(), CONFIG_DIR_NAME, "agent", "run-history.jsonl");
+const HISTORY_PATH = getAgentConfigPaths("run-history.jsonl")[0] ?? path.join(os.homedir(), ".atomic", "agent", "run-history.jsonl");
+const HISTORY_READ_PATHS = getAgentConfigPaths("run-history.jsonl");
 const ROTATE_READ_THRESHOLD = 1200;
 const ROTATE_KEEP = 1000;
 
@@ -34,15 +35,17 @@ export function recordRun(agent: string, task: string, exitCode: number, duratio
 }
 
 export function loadRunsForAgent(agent: string): RunEntry[] {
-	if (!fs.existsSync(HISTORY_PATH)) return [];
-	let raw: string;
-	try {
-		raw = fs.readFileSync(HISTORY_PATH, "utf-8");
-	} catch {
-		return [];
+	let lines: string[] = [];
+	for (const historyPath of HISTORY_READ_PATHS) {
+		if (!fs.existsSync(historyPath)) continue;
+		try {
+			lines.push(...fs.readFileSync(historyPath, "utf-8").split("\n"));
+		} catch {
+			continue;
+		}
 	}
-
-	let lines = raw.split("\n").map((line) => line.trim()).filter((line) => line.length > 0);
+	lines = lines.map((line) => line.trim()).filter((line) => line.length > 0);
+	if (lines.length === 0) return [];
 
 	if (lines.length > ROTATE_READ_THRESHOLD) {
 		lines = lines.slice(-ROTATE_KEEP);