@oh-my-pi/pi-coding-agent 13.12.0 → 13.12.4

package/CHANGELOG.md

@@ -2,6 +2,53 @@
 
 ## [Unreleased]
 
+## [13.12.4] - 2026-03-15
+### Added
+
+- Exposed `settings` instance in `CustomToolContext` for session-specific configuration access
+
+### Changed
+
+- Improved artifact spill configuration to use session settings with schema defaults as fallback
+- Refactored type annotations for better type safety in tool result handling
+
+## [13.12.2] - 2026-03-15
+
+### Added
+
+- Added `compaction.thresholdTokens` setting as a fixed token limit alternative to percentage-based compaction threshold
+- Added more artifact spill threshold options (1 KB to 1 MB) with size descriptions
+- Added more artifact tail bytes and tail lines options with descriptions
+- Added `toExtensionId` capability method to enable granular disabling of individual capabilities by ID
+- Added support for disabling specific capabilities (skills, tools, hooks, rules, prompts, instructions, slash commands, MCP servers, extension modules, and context files) via `disabledExtensions` setting
+- Added `includeDisabled` and `disabledExtensions` options to `LoadOptions` for capability loading
+- Added plugin manifest support for `extensions` entry points to allow plugins to contribute extension modules
+- Added `extensions` field to plugin features for feature-specific extension entry points
+- Added automatic discovery of extension modules from installed plugins during extension loading
+- Added `disabledExtensions` setting to allow disabling specific extensions and skills by ID
+- Added support for filtering skills by disabled extension IDs with `skill:` prefix
+
+### Changed
+
+- Changed capability loading to filter out disabled items based on extension IDs before returning results
+- Changed plugin loader to support `extensions` as a manifest entry type alongside tools, hooks, and commands
+- Changed extension discovery to include extension entry points from all enabled plugins
+- Changed context file path handling to use `path.basename()` for consistent cross-platform filename extraction
+
+### Fixed
+
+- Fixed skill loading to properly respect disabled skill names when loading from custom directories
+
+## [13.12.1] - 2026-03-15
+### Added
+
+- Support for move-only operations that preserve exact bytes including binary files
+
+### Fixed
+
+- Fixed handling of file moves when no edits are specified, now correctly preserves binary content
+- Fixed validation to reject move operations where source and destination paths are identical
+
 ## [13.12.0] - 2026-03-14
 
 ### Added

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "13.12.0",
+	"version": "13.12.4",
 	"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.12.0",
-		"@oh-my-pi/pi-agent-core": "13.12.0",
-		"@oh-my-pi/pi-ai": "13.12.0",
-		"@oh-my-pi/pi-natives": "13.12.0",
-		"@oh-my-pi/pi-tui": "13.12.0",
-		"@oh-my-pi/pi-utils": "13.12.0",
+		"@oh-my-pi/omp-stats": "13.12.4",
+		"@oh-my-pi/pi-agent-core": "13.12.4",
+		"@oh-my-pi/pi-ai": "13.12.4",
+		"@oh-my-pi/pi-natives": "13.12.4",
+		"@oh-my-pi/pi-tui": "13.12.4",
+		"@oh-my-pi/pi-utils": "13.12.4",
 		"@sinclair/typebox": "^0.34",
 		"@xterm/headless": "^6.0",
 		"ajv": "^8.18",

package/src/capability/context-file.ts

@@ -4,6 +4,7 @@
  * System instruction files (CLAUDE.md, AGENTS.md, GEMINI.md, etc.) that provide
  * persistent guidance to the agent.
  */
+import * as path from "node:path";
 import { defineCapability } from ".";
 import type { SourceMeta } from "./types";
 
@@ -33,6 +34,7 @@ export const contextFileCapability = defineCapability<ContextFile>({
 	// 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)}`),
+	toExtensionId: file => `context-file:${file.level}:${path.basename(file.path)}`,
 	validate: file => {
 		if (!file.path) return "Missing path";
 		if (file.content === undefined) return "Missing content";

package/src/capability/extension-module.ts

@@ -25,6 +25,7 @@ export const extensionModuleCapability = defineCapability<ExtensionModule>({
 	displayName: "Extension Modules",
 	description: "TypeScript/JavaScript extension modules loaded by the extension system",
 	key: ext => ext.name,
+	toExtensionId: ext => `extension-module:${ext.name}`,
 	validate: ext => {
 		if (!ext.name) return "Missing name";
 		if (!ext.path) return "Missing path";

package/src/capability/hook.ts

@@ -29,6 +29,7 @@ export const hookCapability = defineCapability<Hook>({
 	displayName: "Hooks",
 	description: "Pre/post tool execution hooks",
 	key: hook => `${hook.type}:${hook.tool}:${hook.name}`,
+	toExtensionId: hook => `hook:${hook.type}:${hook.tool}:${hook.name}`,
 	validate: hook => {
 		if (!hook.name) return "Missing name";
 		if (!hook.path) return "Missing path";

package/src/capability/index.ts

@@ -107,6 +107,9 @@ async function loadImpl<T>(
 	const allItems: Array<T & { _source: SourceMeta; _shadowed?: boolean }> = [];
 	const allWarnings: string[] = [];
 	const contributingProviders: string[] = [];
+	const disabledExtensionIds = options.includeDisabled
+		? new Set<string>()
+		: new Set<string>(options.disabledExtensions ?? settings?.get("disabledExtensions") ?? []);
 
 	const results = await Promise.all(
 		providers.map(async provider => {
@@ -136,18 +139,26 @@ async function loadImpl<T>(
 			allWarnings.push(...result.warnings.map(w => `[${provider.displayName}] ${w}`));
 		}
 
-		if (result.items.length > 0) {
-			contributingProviders.push(provider.id);
+		let contributedItemCount = 0;
+		for (const item of result.items) {
+			const itemWithSource = item as T & { _source: SourceMeta };
+			if (!itemWithSource._source) {
+				allWarnings.push(`[${provider.displayName}] Item missing _source metadata, skipping`);
+				continue;
+			}
 
-			for (const item of result.items) {
-				const itemWithSource = item as T & { _source: SourceMeta };
-				if (itemWithSource._source) {
-					itemWithSource._source.providerName = provider.displayName;
-					allItems.push(itemWithSource as T & { _source: SourceMeta; _shadowed?: boolean });
-				} else {
-					allWarnings.push(`[${provider.displayName}] Item missing _source metadata, skipping`);
-				}
+			const extensionId = capability.toExtensionId?.(itemWithSource);
+			if (extensionId && disabledExtensionIds.has(extensionId)) {
+				continue;
 			}
+
+			itemWithSource._source.providerName = provider.displayName;
+			allItems.push(itemWithSource as T & { _source: SourceMeta; _shadowed?: boolean });
+			contributedItemCount += 1;
+		}
+
+		if (contributedItemCount > 0) {
+			contributingProviders.push(provider.id);
 		}
 	}
 

package/src/capability/instruction.ts

@@ -27,6 +27,7 @@ export const instructionCapability = defineCapability<Instruction>({
 	displayName: "Instructions",
 	description: "File-specific instructions with glob pattern matching (GitHub Copilot format)",
 	key: inst => inst.name,
+	toExtensionId: inst => `instruction:${inst.name}`,
 	validate: inst => {
 		if (!inst.name) return "Missing name";
 		if (!inst.path) return "Missing path";

package/src/capability/mcp.ts

@@ -48,6 +48,7 @@ export const mcpCapability = defineCapability<MCPServer>({
 	displayName: "MCP Servers",
 	description: "Model Context Protocol server configurations for external tool integrations",
 	key: server => server.name,
+	toExtensionId: server => `mcp:${server.name}`,
 	validate: server => {
 		if (!server.name) return "Missing server name";
 		if (!server.command && !server.url) return "Must have command or url";

package/src/capability/prompt.ts

@@ -25,6 +25,7 @@ export const promptCapability = defineCapability<Prompt>({
 	displayName: "Prompts",
 	description: "Reusable prompt templates available via /prompts: menu",
 	key: prompt => prompt.name,
+	toExtensionId: prompt => `prompt:${prompt.name}`,
 	validate: prompt => {
 		if (!prompt.name) return "Missing name";
 		if (!prompt.path) return "Missing path";

package/src/capability/rule.ts

@@ -214,6 +214,7 @@ export const ruleCapability = defineCapability<Rule>({
 	displayName: "Rules",
 	description: "Project-specific rules and constraints (Cursor MDC, Windsurf, Cline formats)",
 	key: rule => rule.name,
+	toExtensionId: rule => `rule:${rule.name}`,
 	validate: rule => {
 		if (!rule.name) return "Missing rule name";
 		if (!rule.path) return "Missing rule path";

package/src/capability/skill.ts

@@ -40,6 +40,7 @@ export const skillCapability = defineCapability<Skill>({
 	displayName: "Skills",
 	description: "Specialized knowledge and workflow files that extend agent capabilities",
 	key: skill => skill.name,
+	toExtensionId: skill => `skill:${skill.name}`,
 	validate: skill => {
 		if (!skill.name) return "Missing skill name";
 		if (!skill.path) return "Missing skill path";

package/src/capability/slash-command.ts

@@ -27,6 +27,7 @@ export const slashCommandCapability = defineCapability<SlashCommand>({
 	displayName: "Slash Commands",
 	description: "Custom slash commands defined as markdown files",
 	key: cmd => cmd.name,
+	toExtensionId: cmd => `slash-command:${cmd.name}`,
 	validate: cmd => {
 		if (!cmd.name) return "Missing name";
 		if (!cmd.path) return "Missing path";

package/src/capability/tool.ts

@@ -29,6 +29,7 @@ export const toolCapability = defineCapability<CustomTool>({
 	displayName: "Custom Tools",
 	description: "User-defined tools that extend agent capabilities",
 	key: tool => tool.name,
+	toExtensionId: tool => `tool:${tool.name}`,
 	validate: tool => {
 		if (!tool.name) return "Missing name";
 		if (!tool.path) return "Missing path";

package/src/capability/types.ts

@@ -68,6 +68,10 @@ export interface LoadOptions {
 	cwd?: string;
 	/** Include items even if they fail validation. Default: false */
 	includeInvalid?: boolean;
+	/** Include items disabled via settings. Default: false */
+	includeDisabled?: boolean;
+	/** Explicit disabled extension IDs to apply instead of settings. */
+	disabledExtensions?: string[];
 }
 
 /**
@@ -123,6 +127,12 @@ export interface Capability<T> {
 	 */
 	validate?(item: T): string | undefined;
 
+	/**
+	 * Optional disabledExtensions ID for this item.
+	 * When present, loadCapability() can hide items disabled via settings.
+	 */
+	toExtensionId?(item: T): string | undefined;
+
 	/** Registered providers, sorted by priority (highest first) */
 	providers: Provider<T>[];
 }

package/src/cli/commands/init-xdg.ts

@@ -5,8 +5,8 @@ import * as path from "node:path";
 const APP_NAME = "omp";
 
 export async function initXdg(): Promise<void> {
-	if (process.platform !== "linux") {
-		console.error("XDG directory setup is only supported on Linux.");
+	if (process.platform !== "linux" && process.platform !== "darwin") {
+		console.error("XDG directory setup is only supported on Linux and macOS.");
 		process.exit(1);
 	}
 

package/src/cli/config-cli.ts

@@ -397,7 +397,7 @@ ${chalk.bold("Commands:")}
   set <key> <value>  Set a setting value
   reset <key>        Reset a setting to its default value
   path               Print the config directory path
-  init-xdg           Initialize XDG Base Directory structure (Linux only)
+  init-xdg           Initialize XDG Base Directory structure
 
 ${chalk.bold("Options:")}
   --json             Output as JSON

package/src/config/settings-schema.ts

@@ -226,6 +226,36 @@ export const SETTINGS_SCHEMA = {
 			submenu: true,
 		},
 	},
+	"tools.artifactSpillThreshold": {
+		type: "number",
+		default: 50,
+		ui: {
+			tab: "tools",
+			label: "Artifact spill threshold (KB)",
+			description: "Tool output above this size is saved as an artifact; tail is kept inline",
+			submenu: true,
+		},
+	},
+	"tools.artifactTailBytes": {
+		type: "number",
+		default: 20,
+		ui: {
+			tab: "tools",
+			label: "Artifact tail size (KB)",
+			description: "Amount of tail content kept inline when output spills to artifact",
+			submenu: true,
+		},
+	},
+	"tools.artifactTailLines": {
+		type: "number",
+		default: 500,
+		ui: {
+			tab: "tools",
+			label: "Artifact tail lines",
+			description: "Maximum lines of tail content kept inline when output spills to artifact",
+			submenu: true,
+		},
+	},
 
 	"statusLine.showHookStatus": {
 		type: "boolean",
@@ -629,6 +659,16 @@ export const SETTINGS_SCHEMA = {
 			submenu: true,
 		},
 	},
+	"compaction.thresholdTokens": {
+		type: "number",
+		default: -1,
+		ui: {
+			tab: "context",
+			label: "Compaction Token Limit",
+			description: "Fixed token limit for context maintenance; overrides percentage if set",
+			submenu: true,
+		},
+	},
 
 	"compaction.handoffSaveToDisk": {
 		type: "boolean",
@@ -1518,6 +1558,7 @@ export interface CompactionSettings {
 	enabled: boolean;
 	strategy: "context-full" | "handoff" | "off";
 	thresholdPercent: number;
+	thresholdTokens: number;
 	reserveTokens: number;
 	keepRecentTokens: number;
 	handoffSaveToDisk: boolean;
@@ -1574,6 +1615,7 @@ export interface SkillsSettings {
 	customDirectories?: string[];
 	ignoredSkills?: string[];
 	includeSkills?: string[];
+	disabledExtensions?: string[];
 }
 
 export interface CommitSettings {

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

@@ -10,6 +10,7 @@ import type { Component } from "@oh-my-pi/pi-tui";
 import type { Static, TSchema } from "@sinclair/typebox";
 import type { Rule } from "../../capability/rule";
 import type { ModelRegistry } from "../../config/model-registry";
+import type { Settings } from "../../config/settings";
 import type { ExecOptions, ExecResult } from "../../exec/exec";
 import type { HookUIContext } from "../../extensibility/hooks/types";
 import type { Theme } from "../../modes/theme/theme";
@@ -76,6 +77,8 @@ export interface CustomToolContext {
 	hasQueuedMessages(): boolean;
 	/** Abort the current agent operation (fire-and-forget, does not wait) */
 	abort(): void;
+	/** Settings instance for the current session. Prefer over the global singleton. */
+	settings?: Settings;
 }
 
 /** Session event passed to onSession callback */

package/src/extensibility/extensions/loader.ts

@@ -18,6 +18,7 @@ import type { ExecOptions } from "../../exec/exec";
 import { execCommand } from "../../exec/exec";
 import type { CustomMessage } from "../../session/messages";
 import { EventBus } from "../../utils/event-bus";
+import { getAllPluginExtensionPaths } from "../plugins/loader";
 import { resolvePath } from "../utils";
 import type {
 	Extension,
@@ -481,7 +482,10 @@ export async function discoverAndLoadExtensions(
 		addPath(ext.path);
 	}
 
-	// 2. Explicitly configured paths
+	// 2. Discover extension entry points from installed plugins
+	addPaths(await getAllPluginExtensionPaths(cwd));
+
+	// 3. Explicitly configured paths
 	for (const configuredPath of configuredPaths) {
 		const resolved = resolvePath(configuredPath, cwd);
 

package/src/extensibility/plugins/loader.ts

@@ -1,8 +1,8 @@
 /**
- * Plugin loader - discovers and loads tools/hooks from installed plugins.
+ * Plugin loader - discovers and loads manifest entry points from installed plugins.
  *
- * Reads enabled plugins from the runtime config and loads their tools/hooks
- * based on manifest entries and enabled features.
+ * Reads enabled plugins from the runtime config and loads their
+ * tools/hooks/extensions/commands based on manifest entries and enabled features.
  */
 import * as fs from "node:fs";
 import * as path from "node:path";
@@ -122,10 +122,10 @@ export async function getEnabledPlugins(cwd: string): Promise<InstalledPlugin[]>
 // =============================================================================
 
 /**
- * Generic path resolver for plugin manifest entries (tools, hooks, commands).
+ * Generic path resolver for plugin manifest entries (tools, hooks, commands, extensions).
  * Handles both single-string and string[] base entries, plus feature-specific entries.
  */
-function resolvePluginPaths(plugin: InstalledPlugin, key: "tools" | "hooks" | "commands"): string[] {
+function resolvePluginPaths(plugin: InstalledPlugin, key: "tools" | "hooks" | "commands" | "extensions"): string[] {
 	const paths: string[] = [];
 	const manifest = plugin.manifest;
 
@@ -188,6 +188,10 @@ export function resolvePluginCommandPaths(plugin: InstalledPlugin): string[] {
 	return resolvePluginPaths(plugin, "commands");
 }
 
+export function resolvePluginExtensionPaths(plugin: InstalledPlugin): string[] {
+	return resolvePluginPaths(plugin, "extensions");
+}
+
 // =============================================================================
 // Aggregated Discovery
 // =============================================================================
@@ -234,6 +238,20 @@ export async function getAllPluginCommandPaths(cwd: string): Promise<string[]> {
 	return paths;
 }
 
+/**
+ * Get all extension module paths from all enabled plugins.
+ */
+export async function getAllPluginExtensionPaths(cwd: string): Promise<string[]> {
+	const plugins = await getEnabledPlugins(cwd);
+	const paths: string[] = [];
+
+	for (const plugin of plugins) {
+		paths.push(...resolvePluginExtensionPaths(plugin));
+	}
+
+	return paths;
+}
+
 /**
  * Get plugin settings for use in tool/hook contexts.
  * Merges global settings with project overrides.

package/src/extensibility/plugins/manager.ts

@@ -585,6 +585,20 @@ export class PluginManager {
 				}
 			}
 
+			// Check extension entry paths exist if specified
+			if (manifest?.extensions) {
+				for (const extensionPath of manifest.extensions) {
+					const resolvedExtensionPath = path.join(pluginPath, extensionPath);
+					if (!fs.existsSync(resolvedExtensionPath)) {
+						checks.push({
+							name: `plugin:${name}:extension:${extensionPath}`,
+							status: "error",
+							message: `Extension entry "${extensionPath}" not found`,
+						});
+					}
+				}
+			}
+
 			// Check enabled features exist in manifest
 			const runtimeState = config.plugins[name];
 			if (runtimeState?.enabledFeatures && manifest?.features) {

package/src/extensibility/plugins/types.ts

@@ -11,6 +11,8 @@ export interface PluginFeature {
 	description?: string;
 	/** Whether this feature is enabled by default */
 	default?: boolean;
+	/** Additional extension entry points provided by this feature */
+	extensions?: string[];
 	/** Additional tool entry points provided by this feature */
 	tools?: string[];
 	/** Additional hook entry points provided by this feature */
@@ -34,6 +36,8 @@ export interface PluginManifest {
 	tools?: string;
 	/** Entry point for base hooks (relative path from package root) */
 	hooks?: string;
+	/** Extension entry points (relative paths from package root) */
+	extensions?: string[];
 	/** Command files (relative paths from package root) */
 	commands?: string[];
 

package/src/extensibility/skills.ts

@@ -83,6 +83,7 @@ export async function loadSkills(options: LoadSkillsOptions = {}): Promise<LoadS
 		customDirectories = [],
 		ignoredSkills = [],
 		includeSkills = [],
+		disabledExtensions = [],
 	} = options;
 
 	// Early return if skills are disabled
@@ -105,7 +106,7 @@ export async function loadSkills(options: LoadSkillsOptions = {}): Promise<LoadS
 	}
 
 	// Use capability API to load all skills
-	const result = await loadCapability<CapabilitySkill>(skillCapability.id, { cwd });
+	const result = await loadCapability<CapabilitySkill>(skillCapability.id, { cwd, disabledExtensions });
 
 	const skillMap = new Map<string, Skill>();
 	const realPathSet = new Set<string>();
@@ -123,8 +124,12 @@ export async function loadSkills(options: LoadSkillsOptions = {}): Promise<LoadS
 		return ignoredSkills.some(pattern => new Bun.Glob(pattern).match(name));
 	}
 
+	const disabledSkillNames = new Set(
+		(disabledExtensions ?? []).filter(id => id.startsWith("skill:")).map(id => id.slice(6)),
+	);
 	// Filter skills by source and patterns first
 	const filteredSkills = result.items.filter(capSkill => {
+		if (disabledSkillNames.has(capSkill.name)) return false;
 		if (!isSourceEnabled(capSkill._source)) return false;
 		if (matchesIgnorePatterns(capSkill.name)) return false;
 		if (!matchesIncludePatterns(capSkill.name)) return false;
@@ -190,6 +195,7 @@ export async function loadSkills(options: LoadSkillsOptions = {}): Promise<LoadS
 	const allCustomSkills: Array<{ skill: Skill; path: string }> = [];
 	for (const { expandedDir, scanResult } of customDirectoryResults) {
 		for (const capSkill of scanResult.items) {
+			if (disabledSkillNames.has(capSkill.name)) continue;
 			if (matchesIgnorePatterns(capSkill.name)) continue;
 			if (!matchesIncludePatterns(capSkill.name)) continue;
 			allCustomSkills.push({

package/src/ipy/kernel.ts

@@ -274,13 +274,12 @@ export function serializeWebSocketMessage(msg: JupyterMessage): ArrayBuffer {
 		metadata: msg.metadata,
 		content: msg.content,
 	});
-	const msgBytes = TEXT_ENCODER.encode(msgText);
 
 	const buffers = msg.buffers ?? [];
 	const offsetCount = 1 + buffers.length;
 	const headerSize = 4 + offsetCount * 4;
-
-	let totalSize = headerSize + msgBytes.length;
+	const msgBytes = Buffer.byteLength(msgText);
+	let totalSize = headerSize + msgBytes;
 	for (const buf of buffers) {
 		totalSize += buf.length;
 	}
@@ -293,8 +292,8 @@ export function serializeWebSocketMessage(msg: JupyterMessage): ArrayBuffer {
 
 	let offset = headerSize;
 	view.setUint32(4, offset, true);
-	bytes.set(msgBytes, offset);
-	offset += msgBytes.length;
+	TEXT_ENCODER.encodeInto(msgText, bytes.subarray(offset));
+	offset += msgBytes;
 
 	for (let i = 0; i < buffers.length; i++) {
 		view.setUint32(4 + (i + 1) * 4, offset, true);

package/src/modes/components/diff.ts

@@ -23,17 +23,12 @@ function visualizeIndent(text: string, filePath?: string): string {
 	const leftPadding = Math.floor(tabWidth / 2);
 	const rightPadding = Math.max(0, tabWidth - leftPadding - 1);
 	const tabMarker = `${DIM}${" ".repeat(leftPadding)}→${" ".repeat(rightPadding)}${DIM_OFF}`;
-	// Normalize: collapse configured tab-width groups into tab markers, then handle remaining spaces.
-	const normalized = indent.replaceAll("\t", indentation);
 	let visible = "";
-	let pos = 0;
-	while (pos < normalized.length) {
-		if (pos + tabWidth <= normalized.length && normalized.slice(pos, pos + tabWidth) === indentation) {
+	for (const ch of indent) {
+		if (ch === "\t") {
 			visible += tabMarker;
-			pos += tabWidth;
 		} else {
 			visible += `${DIM}·${DIM_OFF}`;
-			pos++;
 		}
 	}
 	return `${visible}${replaceTabs(rest, filePath)}`;

package/src/modes/components/extensions/state-manager.ts

@@ -2,6 +2,7 @@
  * State manager for the Extension Control Center.
  * Handles data loading, tree building, filtering, and toggle persistence.
  */
+import * as path from "node:path";
 import { logger } from "@oh-my-pi/pi-utils";
 import type { ContextFile } from "../../../capability/context-file";
 import type { ExtensionModule } from "../../../capability/extension-module";
@@ -96,7 +97,7 @@ export async function loadAllExtensions(cwd?: string, disabledIds?: string[]): P
 		}
 	}
 
-	const loadOpts = cwd ? { cwd } : {};
+	const loadOpts = cwd ? { cwd, includeDisabled: true } : { includeDisabled: true };
 
 	// Load skills
 	try {
@@ -252,7 +253,7 @@ export async function loadAllExtensions(cwd?: string, disabledIds?: string[]): P
 		const contextFiles = await loadCapability<ContextFile>("context-files", loadOpts);
 		for (const file of contextFiles.all) {
 			// Extract filename from path for display
-			const name = file.path.split("/").pop() || file.path;
+			const name = path.basename(file.path);
 			const id = makeExtensionId("context-file", `${file.level}:${name}`);
 			const isDisabled = disabledExtensions.has(id);
 			const isShadowed = (file as { _shadowed?: boolean })._shadowed;