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

package/CHANGELOG.md

@@ -2,6 +2,43 @@
 
 ## [Unreleased]
 
+## [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.3",
 	"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.3",
+		"@oh-my-pi/pi-agent-core": "13.12.3",
+		"@oh-my-pi/pi-ai": "13.12.3",
+		"@oh-my-pi/pi-natives": "13.12.3",
+		"@oh-my-pi/pi-tui": "13.12.3",
+		"@oh-my-pi/pi-utils": "13.12.3",
 		"@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/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;

package/src/modes/components/settings-defs.ts

@@ -82,13 +82,29 @@ const OPTION_PROVIDERS: Partial<Record<SettingPath, OptionProvider>> = {
 	// Context maintenance threshold
 	"compaction.thresholdPercent": [
 		{ value: "default", label: "Default", description: "Legacy reserve-based threshold" },
-		{ value: "70", label: "70%", description: "Very early maintenance" },
-		{ value: "75", label: "75%", description: "Early maintenance" },
-		{ value: "80", label: "80%", description: "Balanced" },
-		{ value: "85", label: "85%", description: "Typical threshold" },
-		{ value: "90", label: "90%", description: "Aggressive context usage" },
+		{ value: "10", label: "10%", description: "Extremely early maintenance" },
+		{ value: "20", label: "20%", description: "Very early maintenance" },
+		{ value: "30", label: "30%", description: "Early maintenance" },
+		{ value: "40", label: "40%", description: "Moderately early maintenance" },
+		{ value: "50", label: "50%", description: "Halfway point" },
+		{ value: "60", label: "60%", description: "Moderate context usage" },
+		{ value: "70", label: "70%", description: "Balanced" },
+		{ value: "75", label: "75%", description: "Slightly aggressive" },
+		{ value: "80", label: "80%", description: "Typical threshold" },
+		{ value: "85", label: "85%", description: "Aggressive context usage" },
+		{ value: "90", label: "90%", description: "Very aggressive" },
 		{ value: "95", label: "95%", description: "Near context limit" },
 	],
+	"compaction.thresholdTokens": [
+		{ value: "default", label: "Default", description: "Use percentage-based threshold" },
+		{ value: "25000", label: "25K tokens", description: "Quarter of a 200K window" },
+		{ value: "50000", label: "50K tokens", description: "Half of a 200K window" },
+		{ value: "100000", label: "100K tokens", description: "Half of a 200K window" },
+		{ value: "150000", label: "150K tokens", description: "Three-quarters of a 200K window" },
+		{ value: "200000", label: "200K tokens", description: "Full standard context window" },
+		{ value: "300000", label: "300K tokens", description: "Large context window" },
+		{ value: "500000", label: "500K tokens", description: "Very large context window" },
+	],
 	// Retry max retries
 	"retry.maxRetries": [
 		{ value: "1", label: "1 retry" },
@@ -190,6 +206,40 @@ const OPTION_PROVIDERS: Partial<Record<SettingPath, OptionProvider>> = {
 		{ value: "300", label: "5 minutes" },
 		{ value: "600", label: "10 minutes" },
 	],
+	// Artifact spill settings
+	"tools.artifactSpillThreshold": [
+		{ value: "1", label: "1 KB", description: "~250 tokens" },
+		{ value: "2.5", label: "2.5 KB", description: "~625 tokens" },
+		{ value: "5", label: "5 KB", description: "~1.25K tokens" },
+		{ value: "10", label: "10 KB", description: "~2.5K tokens" },
+		{ value: "20", label: "20 KB", description: "~5K tokens" },
+		{ value: "30", label: "30 KB", description: "~7.5K tokens" },
+		{ value: "50", label: "50 KB", description: "Default; ~12.5K tokens" },
+		{ value: "75", label: "75 KB", description: "~19K tokens" },
+		{ value: "100", label: "100 KB", description: "~25K tokens" },
+		{ value: "200", label: "200 KB", description: "~50K tokens" },
+		{ value: "500", label: "500 KB", description: "~125K tokens" },
+		{ value: "1000", label: "1 MB", description: "~250K tokens" },
+	],
+	"tools.artifactTailBytes": [
+		{ value: "1", label: "1 KB", description: "~250 tokens" },
+		{ value: "2.5", label: "2.5 KB", description: "~625 tokens" },
+		{ value: "5", label: "5 KB", description: "~1.25K tokens" },
+		{ value: "10", label: "10 KB", description: "~2.5K tokens" },
+		{ value: "20", label: "20 KB", description: "Default; ~5K tokens" },
+		{ value: "50", label: "50 KB", description: "~12.5K tokens" },
+		{ value: "100", label: "100 KB", description: "~25K tokens" },
+		{ value: "200", label: "200 KB", description: "~50K tokens" },
+	],
+	"tools.artifactTailLines": [
+		{ value: "50", label: "50 lines", description: "~250 tokens" },
+		{ value: "100", label: "100 lines", description: "~500 tokens" },
+		{ value: "250", label: "250 lines", description: "~1.25K tokens" },
+		{ value: "500", label: "500 lines", description: "Default; ~2.5K tokens" },
+		{ value: "1000", label: "1000 lines", description: "~5K tokens" },
+		{ value: "2000", label: "2000 lines", description: "~10K tokens" },
+		{ value: "5000", label: "5000 lines", description: "~25K tokens" },
+	],
 	// Read line limit
 	"read.defaultLimit": [
 		{ value: "200", label: "200 lines" },

package/src/modes/components/settings-selector.ts

@@ -291,6 +291,9 @@ export class SettingsSelectorComponent extends Container {
 		if (path === "compaction.thresholdPercent" && (rawValue === "-1" || rawValue === "")) {
 			return "default";
 		}
+		if (path === "compaction.thresholdTokens" && (rawValue === "-1" || rawValue === "")) {
+			return "default";
+		}
 		return rawValue;
 	}
 
@@ -393,6 +396,8 @@ export class SettingsSelectorComponent extends Container {
 		const currentValue = settings.get(path);
 		if (path === "compaction.thresholdPercent" && value === "default") {
 			settings.set(path, -1 as never);
+		} else if (path === "compaction.thresholdTokens" && value === "default") {
+			settings.set(path, -1 as never);
 		} else if (typeof currentValue === "number") {
 			settings.set(path, Number(value) as never);
 		} else if (typeof currentValue === "boolean") {

package/src/modes/controllers/command-controller.ts

@@ -27,7 +27,7 @@ import type { InteractiveModeContext } from "../../modes/types";
 import type { AsyncJobSnapshotItem } from "../../session/agent-session";
 import type { AuthStorage } from "../../session/auth-storage";
 import { outputMeta } from "../../tools/output-meta";
-import { resolveToCwd } from "../../tools/path-utils";
+import { resolveToCwd, stripOuterDoubleQuotes } from "../../tools/path-utils";
 import { replaceTabs } from "../../tools/render-utils";
 import { getChangelogPath, parseChangelog } from "../../utils/changelog";
 import { openPath } from "../../utils/open";
@@ -679,8 +679,14 @@ export class CommandController {
 			return;
 		}
 
+		const unquoted = stripOuterDoubleQuotes(targetPath);
+		if (!unquoted) {
+			this.ctx.showError("Usage: /move <path>");
+			return;
+		}
+
 		const cwd = this.ctx.sessionManager.getCwd();
-		const resolvedPath = resolveToCwd(targetPath, cwd);
+		const resolvedPath = resolveToCwd(unquoted, cwd);
 
 		try {
 			const stat = await fs.stat(resolvedPath);

package/src/patch/diff.ts

@@ -391,6 +391,8 @@ export async function computeHashlineDiff(
 ): Promise<DiffResult | DiffError> {
 	const { path, edits, move } = input;
 	const absolutePath = resolveToCwd(path, cwd);
+	const movePath = move ? resolveToCwd(move, cwd) : undefined;
+	const isMoveOnly = Boolean(movePath) && movePath !== absolutePath && edits.length === 0;
 
 	try {
 		const file = Bun.file(absolutePath);
@@ -402,6 +404,13 @@ export async function computeHashlineDiff(
 			return { error: `File not found: ${path}` };
 		}
 
+		if (movePath === absolutePath) {
+			return { error: "move path is the same as source path" };
+		}
+		if (isMoveOnly) {
+			return { diff: "", firstChangedLine: undefined };
+		}
+
 		let rawContent: string;
 		try {
 			rawContent = await file.text();
@@ -412,7 +421,6 @@ export async function computeHashlineDiff(
 
 		const { text: content } = stripBom(rawContent);
 		const normalizedContent = normalizeToLF(content);
-
 		const result = applyHashlineEdits(normalizedContent, edits);
 		if (normalizedContent === result.lines && !move) {
 			return { error: `No changes would be made to ${path}. The edits produce identical content.` };

package/src/patch/index.ts

@@ -9,6 +9,7 @@
  * The mode is determined by the `edit.mode` setting.
  */
 import * as fs from "node:fs/promises";
+import * as nodePath from "node:path";
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import { StringEnum } from "@oh-my-pi/pi-ai";
 import { type Static, Type } from "@sinclair/typebox";
@@ -322,11 +323,18 @@ export type EditMode = "replace" | "patch" | "hashline";
 
 export const DEFAULT_EDIT_MODE: EditMode = "hashline";
 
-const EDIT_ID: Record<string, EditMode> = Object.fromEntries(
-	["replace", "patch", "hashline"].map(mode => [mode, mode as EditMode]),
-);
+const EDIT_MODES = ["replace", "patch", "hashline"] as const satisfies readonly EditMode[];
+const EDIT_ID = Object.fromEntries(EDIT_MODES.map(mode => [mode, mode])) satisfies Record<string, EditMode>;
 export const normalizeEditMode = (mode?: string | null): EditMode | undefined => EDIT_ID[mode ?? ""];
 
+function isHashlineParams(params: ReplaceParams | PatchParams | HashlineParams): params is HashlineParams {
+	return "edits" in params;
+}
+
+function isReplaceParams(params: ReplaceParams | PatchParams | HashlineParams): params is ReplaceParams {
+	return "old_text" in params && "new_text" in params;
+}
+
 /**
  * Edit tool implementation.
  *
@@ -454,7 +462,10 @@ export class EditTool implements AgentTool<TInput> {
 		// Hashline mode execution
 		// ─────────────────────────────────────────────────────────────────
 		if (this.mode === "hashline") {
-			const { path, edits, delete: deleteFile, move } = params as HashlineParams;
+			if (!isHashlineParams(params)) {
+				throw new Error("Invalid edit parameters for hashline mode.");
+			}
+			const { path, edits, delete: deleteFile, move } = params;
 
 			enforcePlanModeWrite(this.session, path, { op: deleteFile ? "delete" : "update", move });
 
@@ -464,9 +475,14 @@ export class EditTool implements AgentTool<TInput> {
 
 			const absolutePath = resolvePlanPath(this.session, path);
 			const resolvedMove = move ? resolvePlanPath(this.session, move) : undefined;
+			if (resolvedMove === absolutePath) {
+				throw new Error("move path is the same as source path");
+			}
+			const sourceExists = await fs.exists(absolutePath);
+			const isMoveOnly = Boolean(resolvedMove) && edits.length === 0;
 
 			if (deleteFile) {
-				if (await fs.exists(absolutePath)) {
+				if (sourceExists) {
 					await fs.unlink(absolutePath);
 				}
 				invalidateFsScanAfterDelete(absolutePath);
@@ -480,7 +496,29 @@ export class EditTool implements AgentTool<TInput> {
 				};
 			}
 
-			if (!(await fs.exists(absolutePath))) {
+			if (isMoveOnly && resolvedMove) {
+				if (!sourceExists) {
+					throw new Error(`File not found: ${path}`);
+				}
+				const parentDir = nodePath.dirname(resolvedMove);
+				if (parentDir && parentDir !== ".") {
+					await fs.mkdir(parentDir, { recursive: true });
+				}
+				// Preserve exact bytes for move-only operations, including binary files.
+				await fs.rename(absolutePath, resolvedMove);
+				invalidateFsScanAfterRename(absolutePath, resolvedMove);
+				return {
+					content: [{ type: "text", text: `Moved ${path} to ${move}` }],
+					details: {
+						diff: "",
+						op: "update",
+						move,
+						meta: outputMeta().get(),
+					},
+				};
+			}
+
+			if (!sourceExists) {
 				const lines: string[] = [];
 				for (const edit of edits) {
 					// For file creation, only anchorless appends/prepends are valid
@@ -628,7 +666,10 @@ export class EditTool implements AgentTool<TInput> {
 		// Patch mode execution
 		// ─────────────────────────────────────────────────────────────────
 		if (this.mode === "patch") {
-			const { path, op: rawOp, rename, diff } = params as PatchParams;
+			if (isHashlineParams(params) || isReplaceParams(params)) {
+				throw new Error("Invalid edit parameters for patch mode.");
+			}
+			const { path, op: rawOp, rename, diff } = params;
 
 			// Normalize unrecognized operations to "update"
 			const op: Operation = rawOp === "create" || rawOp === "delete" ? rawOp : "update";
@@ -662,7 +703,10 @@ export class EditTool implements AgentTool<TInput> {
 			const effRename = result.change.newPath ? rename : undefined;
 
 			// Generate diff for display
-			let diffResult = { diff: "", firstChangedLine: undefined as number | undefined };
+			let diffResult: { diff: string; firstChangedLine: number | undefined } = {
+				diff: "",
+				firstChangedLine: undefined,
+			};
 			if (result.change.type === "update" && result.change.oldContent && result.change.newContent) {
 				const normalizedOld = normalizeToLF(stripBom(result.change.oldContent).text);
 				const normalizedNew = normalizeToLF(stripBom(result.change.newContent).text);
@@ -710,7 +754,10 @@ export class EditTool implements AgentTool<TInput> {
 		// ─────────────────────────────────────────────────────────────────
 		// Replace mode execution
 		// ─────────────────────────────────────────────────────────────────
-		const { path, old_text, new_text, all } = params as ReplaceParams;
+		if (!isReplaceParams(params)) {
+			throw new Error("Invalid edit parameters for replace mode.");
+		}
+		const { path, old_text, new_text, all } = params;
 
 		enforcePlanModeWrite(this.session, path);
 

package/src/sdk.ts

@@ -627,8 +627,11 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		modelRegistry.refreshInBackground();
 	}
 	const skillsSettings = settings.getGroup("skills") as SkillsSettings;
+	const disabledExtensionIds = settings.get("disabledExtensions") ?? [];
 	const discoveredSkillsPromise =
-		options.skills === undefined ? discoverSkills(cwd, agentDir, skillsSettings) : undefined;
+		options.skills === undefined
+			? discoverSkills(cwd, agentDir, { ...skillsSettings, disabledExtensions: disabledExtensionIds })
+			: undefined;
 
 	// Initialize provider preferences from settings
 	const webSearchProvider = settings.get("providers.webSearch");
@@ -1006,12 +1009,14 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			...(options.additionalExtensionPaths ?? []),
 			...((settings.get("extensions") as string[]) ?? []),
 		];
+		const disabledExtensionIds = settings.get("disabledExtensions") ?? [];
 		extensionsResult = await logger.timeAsync(
 			"discoverAndLoadExtensions",
 			discoverAndLoadExtensions,
 			configuredPaths,
 			cwd,
 			eventBus,
+			disabledExtensionIds,
 		);
 		for (const { path, error } of extensionsResult.errors) {
 			logger.error("Failed to load extension", { path, error });

package/src/session/compaction/compaction.ts

@@ -136,6 +136,7 @@ export interface CompactionSettings {
 	enabled: boolean;
 	strategy?: "context-full" | "handoff" | "off";
 	thresholdPercent?: number;
+	thresholdTokens?: number;
 	reserveTokens: number;
 	keepRecentTokens: number;
 	autoContinue?: boolean;
@@ -147,6 +148,7 @@ export const DEFAULT_COMPACTION_SETTINGS: CompactionSettings = {
 	enabled: true,
 	strategy: "context-full",
 	thresholdPercent: -1,
+	thresholdTokens: -1,
 	reserveTokens: 16384,
 	keepRecentTokens: 20000,
 	autoContinue: true,
@@ -218,6 +220,14 @@ export function shouldCompact(contextTokens: number, contextWindow: number, sett
 }
 
 function resolveThresholdTokens(contextWindow: number, settings: CompactionSettings): number {
+	// Fixed token limit takes priority over percentage
+	const thresholdTokens = settings.thresholdTokens;
+	if (typeof thresholdTokens === "number" && Number.isFinite(thresholdTokens) && thresholdTokens > 0) {
+		// Clamp to [1, contextWindow - 1] so there's always room
+		return Math.min(contextWindow - 1, Math.max(1, thresholdTokens));
+	}
+
+	// Percentage-based threshold
 	const thresholdPercent = settings.thresholdPercent;
 	if (typeof thresholdPercent !== "number" || !Number.isFinite(thresholdPercent) || thresholdPercent <= 0) {
 		return contextWindow - effectiveReserveTokens(contextWindow, settings);

package/src/session/session-manager.ts

@@ -1449,6 +1449,7 @@ export class SessionManager {
 		if (resolvedCwd === this.cwd) return;
 
 		const newSessionDir = getDefaultSessionDir(resolvedCwd, this.storage);
+		let hadSessionFile = false;
 
 		if (this.persist && this.#sessionFile) {
 			// Close the persist writer before moving files
@@ -1461,12 +1462,16 @@ export class SessionManager {
 			const newSessionFile = path.join(newSessionDir, path.basename(oldSessionFile));
 			const oldArtifactDir = oldSessionFile.slice(0, -6); // strip .jsonl
 			const newArtifactDir = newSessionFile.slice(0, -6);
+			hadSessionFile = this.storage.existsSync(oldSessionFile);
 			let movedSessionFile = false;
 			let movedArtifactDir = false;
 
 			try {
-				await fs.promises.rename(oldSessionFile, newSessionFile);
-				movedSessionFile = true;
+				// Guard: session file may not exist yet (no assistant messages persisted)
+				if (hadSessionFile) {
+					await fs.promises.rename(oldSessionFile, newSessionFile);
+					movedSessionFile = true;
+				}
 
 				try {
 					const stat = await fs.promises.stat(oldArtifactDir);
@@ -1511,8 +1516,12 @@ export class SessionManager {
 			header.cwd = resolvedCwd;
 		}
 
-		// Rewrite the session file at its new location with updated header
-		if (this.persist && this.#sessionFile) {
+		// Rewrite the session file at its new location with updated header.
+		// hadSessionFile: file existed before move → must rewrite to update cwd
+		// hasAssistant: assistant messages in memory but file missing → recreate from memory
+		// Neither true → fresh session, never written → preserve lazy-persist
+		const hasAssistant = this.#fileEntries.some(e => e.type === "message" && e.message.role === "assistant");
+		if (this.persist && this.#sessionFile && (hadSessionFile || hasAssistant)) {
 			await this.#rewriteFile();
 		}
 
@@ -1695,7 +1704,6 @@ export class SessionManager {
 
 	/** Flush pending writes to disk. Call before switching sessions or on shutdown. */
 	async flush(): Promise<void> {
-		if (!this.#persistWriter) return;
 		await this.#queuePersistTask(async () => {
 			if (this.#persistWriter) {
 				await this.#persistWriter.flush();

package/src/tools/output-meta.ts

@@ -12,6 +12,7 @@ import type {
 	AgentToolUpdateCallback,
 } from "@oh-my-pi/pi-agent-core";
 import type { ImageContent, TextContent } from "@oh-my-pi/pi-ai";
+import { settings } from "../config/settings";
 import { formatGroupedDiagnosticMessages } from "../lsp/utils";
 import type { Theme } from "../modes/theme/theme";
 import { type OutputSummary, type TruncationResult, truncateTail } from "../session/streaming-output";
@@ -438,14 +439,20 @@ const kUnwrappedExecute = Symbol("OutputMeta.UnwrappedExecute");
 // Centralized artifact spill for large tool results
 // =============================================================================
 
-/** Text content above this byte threshold gets saved to an artifact. */
-const RESULT_ARTIFACT_THRESHOLD = 50 * 1024; // 50KB
+/** Artifact spill threshold — tool output above this size is saved as an artifact. */
+function getArtifactSpillThreshold(): number {
+	return settings.get("tools.artifactSpillThreshold") * 1024;
+}
 
 /** When spilling, keep this many bytes of tail in the result sent to the LLM. */
-const RESULT_ARTIFACT_TAIL_BYTES = 20 * 1024; // 20KB
+function getArtifactTailBytes(): number {
+	return settings.get("tools.artifactTailBytes") * 1024;
+}
 
 /** When spilling, keep at most this many lines of tail. */
-const RESULT_ARTIFACT_TAIL_LINES = 500;
+function getArtifactTailLines(): number {
+	return settings.get("tools.artifactTailLines");
+}
 
 /**
  * If the tool result text exceeds RESULT_ARTIFACT_THRESHOLD, save the full
@@ -476,7 +483,7 @@ async function spillLargeResultToArtifact(
 
 	const fullText = textParts.length === 1 ? textParts[0] : textParts.join("\n");
 	const totalBytes = Buffer.byteLength(fullText, "utf-8");
-	if (totalBytes <= RESULT_ARTIFACT_THRESHOLD) return result;
+	if (totalBytes <= getArtifactSpillThreshold()) return result;
 
 	// Save full output as artifact
 	const artifactId = await sessionManager.saveArtifact(fullText, toolName);
@@ -484,8 +491,8 @@ async function spillLargeResultToArtifact(
 
 	// Truncate to tail
 	const truncated = truncateTail(fullText, {
-		maxBytes: RESULT_ARTIFACT_TAIL_BYTES,
-		maxLines: RESULT_ARTIFACT_TAIL_LINES,
+		maxBytes: getArtifactTailBytes(),
+		maxLines: getArtifactTailLines(),
 	});
 
 	// Replace text blocks with single tail-truncated block, keep images
@@ -508,7 +515,7 @@ async function spillLargeResultToArtifact(
 		totalBytes: truncated.totalBytes,
 		outputLines,
 		outputBytes,
-		maxBytes: RESULT_ARTIFACT_TAIL_BYTES,
+		maxBytes: getArtifactTailBytes(),
 		shownRange: { start: shownStart, end: truncated.totalLines },
 		artifactId,
 	};

package/src/tools/path-utils.ts

@@ -111,6 +111,17 @@ export function resolveToCwd(filePath: string, cwd: string): string {
 	return path.resolve(cwd, expanded);
 }
 
+/**
+ * Strip matching surrounding double quotes from a path string.
+ * Common when users paste quoted paths from Windows Explorer or shell copy-paste.
+ * Only double quotes — single quotes are valid POSIX filename characters.
+ * Tradeoff: a POSIX path literally starting AND ending with " would also be unquoted.
+ * Accepted because such names are virtually nonexistent in practice.
+ */
+export function stripOuterDoubleQuotes(input: string): string {
+	return input.startsWith('"') && input.endsWith('"') && input.length > 1 ? input.slice(1, -1) : input;
+}
+
 const GLOB_PATH_CHARS = ["*", "?", "[", "{"] as const;
 
 export function hasGlobPathChars(filePath: string): boolean {