@oh-my-pi/pi-coding-agent 13.7.6 → 13.8.0

package/CHANGELOG.md

@@ -2,6 +2,21 @@
 
 ## [Unreleased]
 
+## [13.8.0] - 2026-03-04
+### Added
+
+- Added `buildCompactHashlineDiffPreview()` function to generate compact diff previews for model-visible tool responses, collapsing long unchanged runs and consecutive additions/removals to show edit shape without full file content
+- Added project-level discovery for `.agent/` and `.agents/` directories, walking up from cwd to repo root (matching behavior of other providers like `.omp`, `.claude`, `.codex`). Applies to skills, rules, prompts, commands, context files (AGENTS.md), and system prompts (SYSTEM.md)
+
+### Changed
+
+- Changed edit tool response to include diff summary with line counts (+added -removed) and a compact diff preview instead of warnings-only output
+- Limited auto context promotion to models with explicit `contextPromotionTarget`; models without a configured target now compact on overflow instead of switching to arbitrary larger models ([#282](https://github.com/can1357/oh-my-pi/issues/282))
+
+### Fixed
+
+- Fixed `:thinking` suffix in `modelRoles` config values silently breaking model resolution (e.g., `slow: anthropic/claude-opus-4-6:high`) and being stripped on Ctrl+P role cycling
+
 ## [13.7.6] - 2026-03-04
 ### Added
 

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "13.7.6",
+	"version": "13.8.0",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://github.com/can1357/oh-my-pi",
 	"author": "Can Boluk",
@@ -41,12 +41,12 @@
 	},
 	"dependencies": {
 		"@mozilla/readability": "^0.6",
-		"@oh-my-pi/omp-stats": "13.7.6",
-		"@oh-my-pi/pi-agent-core": "13.7.6",
-		"@oh-my-pi/pi-ai": "13.7.6",
-		"@oh-my-pi/pi-natives": "13.7.6",
-		"@oh-my-pi/pi-tui": "13.7.6",
-		"@oh-my-pi/pi-utils": "13.7.6",
+		"@oh-my-pi/omp-stats": "13.8.0",
+		"@oh-my-pi/pi-agent-core": "13.8.0",
+		"@oh-my-pi/pi-ai": "13.8.0",
+		"@oh-my-pi/pi-natives": "13.8.0",
+		"@oh-my-pi/pi-tui": "13.8.0",
+		"@oh-my-pi/pi-utils": "13.8.0",
 		"@sinclair/typebox": "^0.34",
 		"@xterm/headless": "^6.0",
 		"ajv": "^8.18",

package/scripts/generate-docs-index.ts

@@ -1,7 +1,7 @@
 #!/usr/bin/env bun
 
-import { Glob } from "bun";
 import * as path from "node:path";
+import { Glob } from "bun";
 
 const docsDir = path.resolve(import.meta.dir, "../../../docs");
 const outputPath = path.resolve(import.meta.dir, "../src/internal-urls/docs-index.generated.ts");
@@ -14,10 +14,10 @@ for await (const relativePath of glob.scan(docsDir)) {
 entries.sort();
 
 const docsWithContent = await Promise.all(
-	entries.map(async (relativePath) => ({
+	entries.map(async relativePath => ({
 		relativePath,
 		content: await Bun.file(path.join(docsDir, relativePath)).text(),
-	}))
+	})),
 );
 
 const filenamesLiteral = JSON.stringify(entries);

package/src/capability/context-file.ts

@@ -27,9 +27,12 @@ export const contextFileCapability = defineCapability<ContextFile>({
 	id: "context-files",
 	displayName: "Context Files",
 	description: "Persistent instruction files (CLAUDE.md, AGENTS.md, etc.) that guide agent behavior",
-	// Deduplicate by level: one user-level file, one project-level file
-	// Higher-priority providers shadow lower-priority ones at the same scope
-	key: file => file.level,
+	// Deduplicate by scope: one user-level file, and one project-level file per directory depth.
+	// Within each depth level, higher-priority providers shadow lower-priority ones.
+	// This supports monorepo hierarchies where AGENTS.md exists at multiple ancestor levels.
+	// Clamp depth >= 0: files inside config subdirectories of an ancestor (e.g. .claude/, .github/)
+	// are same-scope as the ancestor itself.
+	key: file => (file.level === "user" ? "user" : `project:${Math.max(0, file.depth ?? 0)}`),
 	validate: file => {
 		if (!file.path) return "Missing path";
 		if (file.content === undefined) return "Missing content";

package/src/capability/fs.ts

@@ -66,6 +66,24 @@ export async function walkUp(
 	}
 }
 
+/**
+ * Walk up from startDir looking for a `.git` entry (file or directory).
+ * Returns the directory containing `.git` (the repo root), or null if not in a git repo.
+ * Results are based on the cached readDirEntries, so repeated calls are cheap.
+ */
+export async function findRepoRoot(startDir: string): Promise<string | null> {
+	let current = resolvePath(startDir);
+	while (true) {
+		const entries = await readDirEntries(current);
+		if (entries.some(e => e.name === ".git")) {
+			return current;
+		}
+		const parent = path.dirname(current);
+		if (parent === current) return null;
+		current = parent;
+	}
+}
+
 export function cacheStats(): { content: number; dir: number } {
 	return {
 		content: contentCache.size,

package/src/capability/index.ts

@@ -11,7 +11,7 @@ import * as path from "node:path";
 import { getProjectDir, logger } from "@oh-my-pi/pi-utils";
 
 import type { Settings } from "../config/settings";
-import { clearCache as clearFsCache, cacheStats as fsCacheStats, invalidate as invalidateFs } from "./fs";
+import { clearCache as clearFsCache, findRepoRoot, cacheStats as fsCacheStats, invalidate as invalidateFs } from "./fs";
 import type {
 	Capability,
 	CapabilityInfo,
@@ -220,7 +220,8 @@ export async function loadCapability<T>(capabilityId: string, options: LoadOptio
 
 	const cwd = options.cwd ?? getProjectDir();
 	const home = os.homedir();
-	const ctx: LoadContext = { cwd, home };
+	const repoRoot = await findRepoRoot(cwd);
+	const ctx: LoadContext = { cwd, home, repoRoot };
 	const providers = filterProviders(capability, options);
 
 	return await loadImpl(capability, providers, ctx, options);

package/src/capability/types.ts

@@ -14,6 +14,8 @@ export interface LoadContext {
 	cwd: string;
 	/** User home directory */
 	home: string;
+	/** Git repository root (directory containing .git), or null if not in a repo */
+	repoRoot: string | null;
 }
 
 /**

package/src/config/model-resolver.ts

@@ -23,10 +23,22 @@ export interface ScopedModel {
  * Parse a model string in "provider/modelId" format.
  * Returns undefined if the format is invalid.
  */
-export function parseModelString(modelStr: string): { provider: string; id: string } | undefined {
+export function parseModelString(
+	modelStr: string,
+): { provider: string; id: string; thinkingLevel?: ThinkingLevel } | undefined {
 	const slashIdx = modelStr.indexOf("/");
 	if (slashIdx <= 0) return undefined;
-	return { provider: modelStr.slice(0, slashIdx), id: modelStr.slice(slashIdx + 1) };
+	const id = modelStr.slice(slashIdx + 1);
+	const provider = modelStr.slice(0, slashIdx);
+	// Strip valid thinking level suffix (e.g., "claude-sonnet-4-6:high" -> id "claude-sonnet-4-6", thinkingLevel "high")
+	const colonIdx = id.lastIndexOf(":");
+	if (colonIdx !== -1) {
+		const suffix = id.slice(colonIdx + 1);
+		if (isValidThinkingLevel(suffix)) {
+			return { provider, id: id.slice(0, colonIdx), thinkingLevel: suffix };
+		}
+	}
+	return { provider, id };
 }
 
 /**

package/src/discovery/agents-md.ts

@@ -14,7 +14,6 @@ import { calculateDepth, createSourceMeta } from "./helpers";
 
 const PROVIDER_ID = "agents-md";
 const DISPLAY_NAME = "AGENTS.md";
-const MAX_DEPTH = 20; // Prevent walking up excessively far from cwd
 
 /**
  * Load standalone AGENTS.md files.
@@ -25,9 +24,8 @@ async function loadAgentsMd(ctx: LoadContext): Promise<LoadResult<ContextFile>>
 
 	// Walk up from cwd looking for AGENTS.md files
 	let current = ctx.cwd;
-	let depth = 0;
 
-	while (depth < MAX_DEPTH) {
+	while (true) {
 		const candidate = path.join(current, "AGENTS.md");
 		const content = await readFile(candidate);
 
@@ -49,11 +47,12 @@ async function loadAgentsMd(ctx: LoadContext): Promise<LoadResult<ContextFile>>
 			}
 		}
 
+		if (current === (ctx.repoRoot ?? ctx.home)) break; // scanned repo root or home, stop
+
 		// Move to parent directory
 		const parent = path.dirname(current);
 		if (parent === current) break; // Reached filesystem root
 		current = parent;
-		depth++;
 	}
 
 	return { items, warnings };

package/src/discovery/agents.ts

@@ -1,7 +1,9 @@
 /**
  * Agents (standard) Provider
  *
- * Loads user-level skills, rules, prompts, commands, context files, and system prompts from ~/.agent/.
+ * Loads skills, rules, prompts, commands, context files, and system prompts
+ * from .agent/ and .agents/ directories at both user (~/) and project levels.
+ * Project-level discovery walks up from cwd to repoRoot.
  */
 import * as path from "node:path";
 import { registerProvider } from "../capability";
@@ -13,76 +15,97 @@ import { type Skill, skillCapability } from "../capability/skill";
 import { type SlashCommand, slashCommandCapability } from "../capability/slash-command";
 import { type SystemPrompt, systemPromptCapability } from "../capability/system-prompt";
 import type { LoadContext, LoadResult } from "../capability/types";
-import { buildRuleFromMarkdown, createSourceMeta, loadFilesFromDir, scanSkillsFromDir } from "./helpers";
+import {
+	buildRuleFromMarkdown,
+	calculateDepth,
+	createSourceMeta,
+	loadFilesFromDir,
+	scanSkillsFromDir,
+} from "./helpers";
 
 const PROVIDER_ID = "agents";
 const DISPLAY_NAME = "Agents (standard)";
 const PRIORITY = 70;
-const USER_AGENT_DIR_CANDIDATES = [".agent", ".agents"] as const;
+const AGENT_DIR_CANDIDATES = [".agent", ".agents"] as const;
 
-function getUserAgentPathCandidates(ctx: LoadContext, ...segments: string[]): string[] {
-	return USER_AGENT_DIR_CANDIDATES.map(baseDir => path.join(ctx.home, baseDir, ...segments));
+/** User-level paths: ~/.agent/<segments> and ~/.agents/<segments>. */
+function getUserPathCandidates(ctx: LoadContext, ...segments: string[]): string[] {
+	return AGENT_DIR_CANDIDATES.map(baseDir => path.join(ctx.home, baseDir, ...segments));
 }
 
-async function loadSkills(ctx: LoadContext): Promise<LoadResult<Skill>> {
-	const items: Skill[] = [];
-	const warnings: string[] = [];
-	for (const userSkillsDir of getUserAgentPathCandidates(ctx, "skills")) {
-		const result = await scanSkillsFromDir(ctx, {
-			dir: userSkillsDir,
-			providerId: PROVIDER_ID,
-			level: "user",
-		});
-		items.push(...result.items);
-		warnings.push(...(result.warnings ?? []));
+/** Project-level paths: walk up from cwd to repoRoot, returning .agent/<segments> and .agents/<segments> at each level. */
+function getProjectPathCandidates(ctx: LoadContext, ...segments: string[]): string[] {
+	const paths: string[] = [];
+	let current = ctx.cwd;
+	while (true) {
+		for (const baseDir of AGENT_DIR_CANDIDATES) {
+			paths.push(path.join(current, baseDir, ...segments));
+		}
+		if (current === (ctx.repoRoot ?? ctx.home)) break;
+		const parent = path.dirname(current);
+		if (parent === current) break;
+		current = parent;
 	}
+	return paths;
+}
+
+// Skills
+async function loadSkills(ctx: LoadContext): Promise<LoadResult<Skill>> {
+	const projectScans = getProjectPathCandidates(ctx, "skills").map(dir =>
+		scanSkillsFromDir(ctx, { dir, providerId: PROVIDER_ID, level: "project" }),
+	);
+	const userScans = getUserPathCandidates(ctx, "skills").map(dir =>
+		scanSkillsFromDir(ctx, { dir, providerId: PROVIDER_ID, level: "user" }),
+	);
+
+	const results = await Promise.all([...projectScans, ...userScans]);
+
 	return {
-		items,
-		warnings,
+		items: results.flatMap(r => r.items),
+		warnings: results.flatMap(r => r.warnings ?? []),
 	};
 }
 
 registerProvider<Skill>(skillCapability.id, {
 	id: PROVIDER_ID,
 	displayName: DISPLAY_NAME,
-	description: "Load skills from ~/.agent/skills (fallback ~/.agents/skills)",
+	description: "Load skills from .agent/skills and .agents/skills (project walk-up + user home)",
 	priority: PRIORITY,
 	load: loadSkills,
 });
 
 // Rules
 async function loadRules(ctx: LoadContext): Promise<LoadResult<Rule>> {
-	const items: Rule[] = [];
-	const warnings: string[] = [];
-	for (const userRulesDir of getUserAgentPathCandidates(ctx, "rules")) {
-		const result = await loadFilesFromDir<Rule>(ctx, userRulesDir, PROVIDER_ID, "user", {
+	const load = (dir: string, level: "user" | "project") =>
+		loadFilesFromDir<Rule>(ctx, dir, PROVIDER_ID, level, {
 			extensions: ["md", "mdc"],
 			transform: (name, content, filePath, source) =>
 				buildRuleFromMarkdown(name, content, filePath, source, { stripNamePattern: /\.(md|mdc)$/ }),
 		});
-		items.push(...result.items);
-		warnings.push(...(result.warnings ?? []));
-	}
+
+	const results = await Promise.all([
+		...getProjectPathCandidates(ctx, "rules").map(dir => load(dir, "project")),
+		...getUserPathCandidates(ctx, "rules").map(dir => load(dir, "user")),
+	]);
+
 	return {
-		items,
-		warnings,
+		items: results.flatMap(r => r.items),
+		warnings: results.flatMap(r => r.warnings ?? []),
 	};
 }
 
 registerProvider<Rule>(ruleCapability.id, {
 	id: PROVIDER_ID,
 	displayName: DISPLAY_NAME,
-	description: "Load rules from ~/.agent/rules (fallback ~/.agents/rules)",
+	description: "Load rules from .agent/rules and .agents/rules (project walk-up + user home)",
 	priority: PRIORITY,
 	load: loadRules,
 });
 
 // Prompts
 async function loadPrompts(ctx: LoadContext): Promise<LoadResult<Prompt>> {
-	const items: Prompt[] = [];
-	const warnings: string[] = [];
-	for (const userPromptsDir of getUserAgentPathCandidates(ctx, "prompts")) {
-		const result = await loadFilesFromDir<Prompt>(ctx, userPromptsDir, PROVIDER_ID, "user", {
+	const load = (dir: string, level: "user" | "project") =>
+		loadFilesFromDir<Prompt>(ctx, dir, PROVIDER_ID, level, {
 			extensions: ["md"],
 			transform: (name, content, filePath, source) => ({
 				name: name.replace(/\.md$/, ""),
@@ -91,109 +114,106 @@ async function loadPrompts(ctx: LoadContext): Promise<LoadResult<Prompt>> {
 				_source: source,
 			}),
 		});
-		items.push(...result.items);
-		warnings.push(...(result.warnings ?? []));
-	}
+
+	const results = await Promise.all([
+		...getProjectPathCandidates(ctx, "prompts").map(dir => load(dir, "project")),
+		...getUserPathCandidates(ctx, "prompts").map(dir => load(dir, "user")),
+	]);
+
 	return {
-		items,
-		warnings,
+		items: results.flatMap(r => r.items),
+		warnings: results.flatMap(r => r.warnings ?? []),
 	};
 }
 
 registerProvider<Prompt>(promptCapability.id, {
 	id: PROVIDER_ID,
 	displayName: DISPLAY_NAME,
-	description: "Load prompts from ~/.agent/prompts (fallback ~/.agents/prompts)",
+	description: "Load prompts from .agent/prompts and .agents/prompts (project walk-up + user home)",
 	priority: PRIORITY,
 	load: loadPrompts,
 });
 
 // Slash Commands
 async function loadSlashCommands(ctx: LoadContext): Promise<LoadResult<SlashCommand>> {
-	const items: SlashCommand[] = [];
-	const warnings: string[] = [];
-	for (const userCommandsDir of getUserAgentPathCandidates(ctx, "commands")) {
-		const result = await loadFilesFromDir<SlashCommand>(ctx, userCommandsDir, PROVIDER_ID, "user", {
+	const load = (dir: string, level: "user" | "project") =>
+		loadFilesFromDir<SlashCommand>(ctx, dir, PROVIDER_ID, level, {
 			extensions: ["md"],
 			transform: (name, content, filePath, source) => ({
 				name: name.replace(/\.md$/, ""),
 				path: filePath,
 				content,
-				level: "user",
+				level,
 				_source: source,
 			}),
 		});
-		items.push(...result.items);
-		warnings.push(...(result.warnings ?? []));
-	}
+
+	const results = await Promise.all([
+		...getProjectPathCandidates(ctx, "commands").map(dir => load(dir, "project")),
+		...getUserPathCandidates(ctx, "commands").map(dir => load(dir, "user")),
+	]);
+
 	return {
-		items,
-		warnings,
+		items: results.flatMap(r => r.items),
+		warnings: results.flatMap(r => r.warnings ?? []),
 	};
 }
 
 registerProvider<SlashCommand>(slashCommandCapability.id, {
 	id: PROVIDER_ID,
 	displayName: DISPLAY_NAME,
-	description: "Load commands from ~/.agent/commands (fallback ~/.agents/commands)",
+	description: "Load commands from .agent/commands and .agents/commands (project walk-up + user home)",
 	priority: PRIORITY,
 	load: loadSlashCommands,
 });
 
 // Context Files (AGENTS.md)
 async function loadContextFiles(ctx: LoadContext): Promise<LoadResult<ContextFile>> {
-	const items: ContextFile[] = [];
-	for (const agentsPath of getUserAgentPathCandidates(ctx, "AGENTS.md")) {
-		const content = await readFile(agentsPath);
-		if (!content) {
-			continue;
-		}
-		items.push({
-			path: agentsPath,
-			content,
-			level: "user",
-			_source: createSourceMeta(PROVIDER_ID, agentsPath, "user"),
-		});
-	}
-	return {
-		items,
-		warnings: [],
+	const load = async (filePath: string, level: "user" | "project"): Promise<ContextFile | null> => {
+		const content = await readFile(filePath);
+		if (!content) return null;
+		// filePath is <ancestor>/.agent(s)/AGENTS.md — go up past the config dir to the ancestor
+		const ancestorDir = path.dirname(path.dirname(filePath));
+		const depth = level === "project" ? calculateDepth(ctx.cwd, ancestorDir, path.sep) : undefined;
+		return { path: filePath, content, level, depth, _source: createSourceMeta(PROVIDER_ID, filePath, level) };
 	};
+
+	const results = await Promise.all([
+		...getProjectPathCandidates(ctx, "AGENTS.md").map(p => load(p, "project")),
+		...getUserPathCandidates(ctx, "AGENTS.md").map(p => load(p, "user")),
+	]);
+
+	return { items: results.filter((r): r is ContextFile => r !== null), warnings: [] };
 }
 
 registerProvider<ContextFile>(contextFileCapability.id, {
 	id: PROVIDER_ID,
 	displayName: DISPLAY_NAME,
-	description: "Load AGENTS.md from ~/.agent (fallback ~/.agents)",
+	description: "Load AGENTS.md from .agent and .agents (project walk-up + user home)",
 	priority: PRIORITY,
 	load: loadContextFiles,
 });
 
 // System Prompt (SYSTEM.md)
 async function loadSystemPrompt(ctx: LoadContext): Promise<LoadResult<SystemPrompt>> {
-	const items: SystemPrompt[] = [];
-	for (const systemPath of getUserAgentPathCandidates(ctx, "SYSTEM.md")) {
-		const content = await readFile(systemPath);
-		if (!content) {
-			continue;
-		}
-		items.push({
-			path: systemPath,
-			content,
-			level: "user",
-			_source: createSourceMeta(PROVIDER_ID, systemPath, "user"),
-		});
-	}
-	return {
-		items,
-		warnings: [],
+	const load = async (filePath: string, level: "user" | "project"): Promise<SystemPrompt | null> => {
+		const content = await readFile(filePath);
+		if (!content) return null;
+		return { path: filePath, content, level, _source: createSourceMeta(PROVIDER_ID, filePath, level) };
 	};
+
+	const results = await Promise.all([
+		...getProjectPathCandidates(ctx, "SYSTEM.md").map(p => load(p, "project")),
+		...getUserPathCandidates(ctx, "SYSTEM.md").map(p => load(p, "user")),
+	]);
+
+	return { items: results.filter((r): r is SystemPrompt => r !== null), warnings: [] };
 }
 
 registerProvider<SystemPrompt>(systemPromptCapability.id, {
 	id: PROVIDER_ID,
 	displayName: DISPLAY_NAME,
-	description: "Load SYSTEM.md from ~/.agent (fallback ~/.agents)",
+	description: "Load SYSTEM.md from .agent and .agents (project walk-up + user home)",
 	priority: PRIORITY,
 	load: loadSystemPrompt,
 });

package/src/discovery/builtin.ts

@@ -68,12 +68,13 @@ async function getConfigDirs(ctx: LoadContext): Promise<Array<{ dir: string; lev
 	return result;
 }
 
-function getAncestorDirs(cwd: string): Array<{ dir: string; depth: number }> {
+function getAncestorDirs(cwd: string, stopAt?: string | null): Array<{ dir: string; depth: number }> {
 	const ancestors: Array<{ dir: string; depth: number }> = [];
 	let current = cwd;
 	let depth = 0;
 	while (true) {
 		ancestors.push({ dir: current, depth });
+		if (stopAt && current === stopAt) break;
 		const parent = path.dirname(current);
 		if (parent === current) break;
 		current = parent;
@@ -82,8 +83,11 @@ function getAncestorDirs(cwd: string): Array<{ dir: string; depth: number }> {
 	return ancestors;
 }
 
-async function findNearestProjectConfigDir(cwd: string): Promise<{ dir: string; depth: number } | null> {
-	for (const ancestor of getAncestorDirs(cwd)) {
+async function findNearestProjectConfigDir(
+	cwd: string,
+	repoRoot?: string | null,
+): Promise<{ dir: string; depth: number } | null> {
+	for (const ancestor of getAncestorDirs(cwd, repoRoot)) {
 		const configDir = await ifNonEmptyDir(ancestor.dir, PATHS.projectDir);
 		if (configDir) return { dir: configDir, depth: ancestor.depth };
 	}
@@ -215,7 +219,7 @@ async function loadSystemPrompt(ctx: LoadContext): Promise<LoadResult<SystemProm
 		});
 	}
 
-	const nearestProjectConfigDir = await findNearestProjectConfigDir(ctx.cwd);
+	const nearestProjectConfigDir = await findNearestProjectConfigDir(ctx.cwd, ctx.repoRoot);
 	if (nearestProjectConfigDir) {
 		const projectPath = path.join(nearestProjectConfigDir.dir, "SYSTEM.md");
 		const projectContent = await readFile(projectPath);
@@ -242,18 +246,27 @@ registerProvider<SystemPrompt>(systemPromptCapability.id, {
 
 // Skills
 async function loadSkills(ctx: LoadContext): Promise<LoadResult<Skill>> {
-	const configDirs = await getConfigDirs(ctx);
-	const results = await Promise.all(
-		configDirs.map(({ dir, level }) =>
-			scanSkillsFromDir(ctx, {
-				dir: path.join(dir, "skills"),
-				providerId: PROVIDER_ID,
-				level,
-				requireDescription: true,
-			}),
-		),
+	// Walk up from cwd finding .omp/skills/ in ancestors (closest first)
+	const ancestors = getAncestorDirs(ctx.cwd, ctx.repoRoot ?? ctx.home);
+	const projectScans = ancestors.map(({ dir }) =>
+		scanSkillsFromDir(ctx, {
+			dir: path.join(dir, PATHS.projectDir, "skills"),
+			providerId: PROVIDER_ID,
+			level: "project",
+			requireDescription: true,
+		}),
 	);
 
+	// User-level scan from ~/.omp/agent/skills/
+	const userScan = scanSkillsFromDir(ctx, {
+		dir: path.join(ctx.home, PATHS.userAgent, "skills"),
+		providerId: PROVIDER_ID,
+		level: "user",
+		requireDescription: true,
+	});
+
+	const results = await Promise.all([...projectScans, userScan]);
+
 	return {
 		items: results.flatMap(r => r.items),
 		warnings: results.flatMap(r => r.warnings ?? []),
@@ -795,7 +808,7 @@ async function loadContextFiles(ctx: LoadContext): Promise<LoadResult<ContextFil
 		});
 	}
 
-	const nearestProjectConfigDir = await findNearestProjectConfigDir(ctx.cwd);
+	const nearestProjectConfigDir = await findNearestProjectConfigDir(ctx.cwd, ctx.repoRoot);
 	if (nearestProjectConfigDir) {
 		const projectPath = path.join(nearestProjectConfigDir.dir, "AGENTS.md");
 		const projectContent = await readFile(projectPath);

package/src/discovery/claude.ts

@@ -145,7 +145,7 @@ async function loadContextFiles(ctx: LoadContext): Promise<LoadResult<ContextFil
 	const projectClaudeMd = path.join(projectBase, "CLAUDE.md");
 	const projectContent = await readFile(projectClaudeMd);
 	if (projectContent !== null) {
-		const depth = calculateDepth(ctx.cwd, projectBase, path.sep);
+		const depth = calculateDepth(ctx.cwd, path.dirname(projectBase), path.sep);
 		items.push({
 			path: projectClaudeMd,
 			content: projectContent,
@@ -164,11 +164,27 @@ async function loadContextFiles(ctx: LoadContext): Promise<LoadResult<ContextFil
 
 async function loadSkills(ctx: LoadContext): Promise<LoadResult<Skill>> {
 	const userSkillsDir = path.join(getUserClaude(ctx), "skills");
-	const projectSkillsDir = path.join(getProjectClaude(ctx), "skills");
 
-	const [userResult, projectResult] = await Promise.allSettled([
+	// Walk up from cwd finding .claude/skills/ in ancestors
+	const projectScans: Promise<LoadResult<Skill>>[] = [];
+	let current = ctx.cwd;
+	while (true) {
+		projectScans.push(
+			scanSkillsFromDir(ctx, {
+				dir: path.join(current, CONFIG_DIR, "skills"),
+				providerId: PROVIDER_ID,
+				level: "project",
+			}),
+		);
+		if (current === (ctx.repoRoot ?? ctx.home)) break;
+		const parent = path.dirname(current);
+		if (parent === current) break; // filesystem root
+		current = parent;
+	}
+
+	const [userResult, ...projectResults] = await Promise.allSettled([
 		scanSkillsFromDir(ctx, { dir: userSkillsDir, providerId: PROVIDER_ID, level: "user" }),
-		scanSkillsFromDir(ctx, { dir: projectSkillsDir, providerId: PROVIDER_ID, level: "project" }),
+		...projectScans,
 	]);
 
 	const items: Skill[] = [];
@@ -181,11 +197,13 @@ async function loadSkills(ctx: LoadContext): Promise<LoadResult<Skill>> {
 		warnings.push(`Failed to scan Claude user skills in ${userSkillsDir}: ${String(userResult.reason)}`);
 	}
 
-	if (projectResult.status === "fulfilled") {
-		items.push(...projectResult.value.items);
-		warnings.push(...(projectResult.value.warnings ?? []));
-	} else if (!isMissingDirectoryError(projectResult.reason)) {
-		warnings.push(`Failed to scan Claude project skills in ${projectSkillsDir}: ${String(projectResult.reason)}`);
+	for (const projectResult of projectResults) {
+		if (projectResult.status === "fulfilled") {
+			items.push(...projectResult.value.items);
+			warnings.push(...(projectResult.value.warnings ?? []));
+		} else if (!isMissingDirectoryError(projectResult.reason)) {
+			warnings.push(`Failed to scan Claude project skills: ${String(projectResult.reason)}`);
+		}
 	}
 
 	return { items, warnings };