@oh-my-pi/pi-coding-agent 4.1.0 → 4.2.0

package/src/core/custom-share.ts

@@ -0,0 +1,66 @@
+/**
+ * Custom share script loader.
+ *
+ * Allows users to define a custom share handler at ~/.omp/agent/share.ts
+ * that will be used instead of the default GitHub Gist sharing.
+ */
+
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { getAgentDir } from "../config";
+
+export interface CustomShareResult {
+	/** URL to display/open (optional - script may handle everything itself) */
+	url?: string;
+	/** Additional message to show the user */
+	message?: string;
+}
+
+export type CustomShareFn = (htmlPath: string) => Promise<CustomShareResult | string | undefined>;
+
+interface LoadedCustomShare {
+	path: string;
+	fn: CustomShareFn;
+}
+
+const SHARE_SCRIPT_CANDIDATES = ["share.ts", "share.js", "share.mjs"];
+
+/**
+ * Get the path to the custom share script if it exists.
+ */
+export function getCustomSharePath(): string | null {
+	const agentDir = getAgentDir();
+
+	for (const candidate of SHARE_SCRIPT_CANDIDATES) {
+		const scriptPath = join(agentDir, candidate);
+		if (existsSync(scriptPath)) {
+			return scriptPath;
+		}
+	}
+
+	return null;
+}
+
+/**
+ * Load the custom share script if it exists.
+ */
+export async function loadCustomShare(): Promise<LoadedCustomShare | null> {
+	const scriptPath = getCustomSharePath();
+	if (!scriptPath) {
+		return null;
+	}
+
+	try {
+		const module = await import(scriptPath);
+		const fn = module.default;
+
+		if (typeof fn !== "function") {
+			throw new Error("share script must export a default function");
+		}
+
+		return { path: scriptPath, fn };
+	} catch (err) {
+		const message = err instanceof Error ? err.message : String(err);
+		throw new Error(`Failed to load share script: ${message}`);
+	}
+}

package/src/core/history-storage.ts

@@ -29,6 +29,9 @@ export class HistoryStorage {
 	private searchStmt: Statement;
 	private lastPromptStmt: Statement;
 
+	// In-memory cache of last prompt to avoid sync DB reads on add
+	private lastPromptCache: string | null = null;
+
 	private constructor(dbPath: string) {
 		this.ensureDir(dbPath);
 
@@ -71,6 +74,9 @@ END;
 			"SELECT h.id, h.prompt, h.created_at, h.cwd FROM history_fts f JOIN history h ON h.id = f.rowid WHERE history_fts MATCH ? ORDER BY h.created_at DESC, h.id DESC LIMIT ?",
 		);
 		this.lastPromptStmt = this.db.prepare("SELECT prompt FROM history ORDER BY id DESC LIMIT 1");
+
+		const last = this.lastPromptStmt.get() as { prompt?: string } | undefined;
+		this.lastPromptCache = last?.prompt ?? null;
 	}
 
 	static open(dbPath: string = join(getAgentDir(), "history.db")): HistoryStorage {
@@ -83,15 +89,17 @@ END;
 	add(prompt: string, cwd?: string): void {
 		const trimmed = prompt.trim();
 		if (!trimmed) return;
+		if (this.lastPromptCache === trimmed) return;
 
-		try {
-			const last = this.lastPromptStmt.get() as { prompt?: string } | undefined;
-			if (last?.prompt === trimmed) return;
+		this.lastPromptCache = trimmed;
 
-			this.insertStmt.run(trimmed, cwd ?? null);
-		} catch (error) {
-			logger.error("HistoryStorage add failed", { error: String(error) });
-		}
+		setImmediate(() => {
+			try {
+				this.insertStmt.run(trimmed, cwd ?? null);
+			} catch (error) {
+				logger.error("HistoryStorage add failed", { error: String(error) });
+			}
+		});
 	}
 
 	getRecent(limit: number): HistoryEntry[] {

package/src/core/prompt-templates.ts

@@ -1,4 +1,5 @@
 import { join, resolve } from "node:path";
+import Handlebars from "handlebars";
 import { CONFIG_DIR_NAME, getPromptsDir } from "../config";
 
 /**
@@ -11,6 +12,273 @@ export interface PromptTemplate {
 	source: string; // e.g., "(user)", "(project)", "(project:frontend)"
 }
 
+export interface TemplateContext extends Record<string, unknown> {
+	args?: string[];
+	ARGUMENTS?: string;
+	arguments?: string;
+}
+
+const handlebars = Handlebars.create();
+
+handlebars.registerHelper("arg", function (this: TemplateContext, index: number | string): string {
+	const args = this.args ?? [];
+	const parsedIndex = typeof index === "number" ? index : Number.parseInt(index, 10);
+	if (!Number.isFinite(parsedIndex)) return "";
+	const zeroBased = parsedIndex - 1;
+	if (zeroBased < 0) return "";
+	return args[zeroBased] ?? "";
+});
+
+/**
+ * {{#list items prefix="- " suffix="" join="\n"}}{{this}}{{/list}}
+ * Renders an array with customizable prefix, suffix, and join separator.
+ * Note: Use \n in join for newlines (will be unescaped automatically).
+ */
+handlebars.registerHelper(
+	"list",
+	function (this: unknown, context: unknown[], options: Handlebars.HelperOptions): string {
+		if (!Array.isArray(context) || context.length === 0) return "";
+		const prefix = (options.hash.prefix as string) ?? "";
+		const suffix = (options.hash.suffix as string) ?? "";
+		const rawSeparator = (options.hash.join as string) ?? "\n";
+		const separator = rawSeparator.replace(/\\n/g, "\n").replace(/\\t/g, "\t");
+		return context.map((item) => `${prefix}${options.fn(item)}${suffix}`).join(separator);
+	},
+);
+
+/**
+ * {{join array ", "}}
+ * Joins an array with a separator (default: ", ").
+ */
+handlebars.registerHelper("join", (context: unknown[], separator?: unknown): string => {
+	if (!Array.isArray(context)) return "";
+	const sep = typeof separator === "string" ? separator : ", ";
+	return context.join(sep);
+});
+
+/**
+ * {{default value "fallback"}}
+ * Returns the value if truthy, otherwise returns the fallback.
+ */
+handlebars.registerHelper("default", (value: unknown, defaultValue: unknown): unknown => value || defaultValue);
+
+/**
+ * {{pluralize count "item" "items"}}
+ * Returns "1 item" or "5 items" based on count.
+ */
+handlebars.registerHelper(
+	"pluralize",
+	(count: number, singular: string, plural: string): string => `${count} ${count === 1 ? singular : plural}`,
+);
+
+/**
+ * {{#when value "==" compare}}...{{else}}...{{/when}}
+ * Conditional block with comparison operators: ==, ===, !=, !==, >, <, >=, <=
+ */
+handlebars.registerHelper(
+	"when",
+	function (this: unknown, lhs: unknown, operator: string, rhs: unknown, options: Handlebars.HelperOptions): string {
+		const ops: Record<string, (a: unknown, b: unknown) => boolean> = {
+			"==": (a, b) => a === b,
+			"===": (a, b) => a === b,
+			"!=": (a, b) => a !== b,
+			"!==": (a, b) => a !== b,
+			">": (a, b) => (a as number) > (b as number),
+			"<": (a, b) => (a as number) < (b as number),
+			">=": (a, b) => (a as number) >= (b as number),
+			"<=": (a, b) => (a as number) <= (b as number),
+		};
+		const fn = ops[operator];
+		if (!fn) return options.inverse(this);
+		return fn(lhs, rhs) ? options.fn(this) : options.inverse(this);
+	},
+);
+
+/**
+ * {{#ifAny a b c}}...{{else}}...{{/ifAny}}
+ * True if any argument is truthy.
+ */
+handlebars.registerHelper("ifAny", function (this: unknown, ...args: unknown[]): string {
+	const options = args.pop() as Handlebars.HelperOptions;
+	return args.some(Boolean) ? options.fn(this) : options.inverse(this);
+});
+
+/**
+ * {{#ifAll a b c}}...{{else}}...{{/ifAll}}
+ * True if all arguments are truthy.
+ */
+handlebars.registerHelper("ifAll", function (this: unknown, ...args: unknown[]): string {
+	const options = args.pop() as Handlebars.HelperOptions;
+	return args.every(Boolean) ? options.fn(this) : options.inverse(this);
+});
+
+/**
+ * {{#table rows headers="Col1|Col2"}}{{col1}}|{{col2}}{{/table}}
+ * Generates a markdown table from an array of objects.
+ */
+handlebars.registerHelper(
+	"table",
+	function (this: unknown, context: unknown[], options: Handlebars.HelperOptions): string {
+		if (!Array.isArray(context) || context.length === 0) return "";
+		const headersStr = options.hash.headers as string | undefined;
+		const headers = headersStr?.split("|") ?? [];
+		const separator = headers.map(() => "---").join(" | ");
+		const headerRow = headers.length > 0 ? `| ${headers.join(" | ")} |\n| ${separator} |\n` : "";
+		const rows = context.map((item) => `| ${options.fn(item).trim()} |`).join("\n");
+		return headerRow + rows;
+	},
+);
+
+/**
+ * {{#codeblock lang="diff"}}...{{/codeblock}}
+ * Wraps content in a fenced code block.
+ */
+handlebars.registerHelper("codeblock", function (this: unknown, options: Handlebars.HelperOptions): string {
+	const lang = (options.hash.lang as string) ?? "";
+	const content = options.fn(this).trim();
+	return `\`\`\`${lang}\n${content}\n\`\`\``;
+});
+
+/**
+ * {{#xml "tag"}}content{{/xml}}
+ * Wraps content in XML-style tags. Returns empty string if content is empty.
+ */
+handlebars.registerHelper("xml", function (this: unknown, tag: string, options: Handlebars.HelperOptions): string {
+	const content = options.fn(this).trim();
+	if (!content) return "";
+	return `<${tag}>\n${content}\n</${tag}>`;
+});
+
+/**
+ * {{escapeXml value}}
+ * Escapes XML special characters: & < > "
+ */
+handlebars.registerHelper("escapeXml", (value: unknown): string => {
+	if (value == null) return "";
+	return String(value).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+});
+
+/**
+ * {{len array}}
+ * Returns the length of an array or string.
+ */
+handlebars.registerHelper("len", (value: unknown): number => {
+	if (Array.isArray(value)) return value.length;
+	if (typeof value === "string") return value.length;
+	return 0;
+});
+
+/**
+ * {{add a b}}
+ * Adds two numbers.
+ */
+handlebars.registerHelper("add", (a: number, b: number): number => (a ?? 0) + (b ?? 0));
+
+/**
+ * {{sub a b}}
+ * Subtracts b from a.
+ */
+handlebars.registerHelper("sub", (a: number, b: number): number => (a ?? 0) - (b ?? 0));
+
+/**
+ * {{#has collection item}}...{{else}}...{{/has}}
+ * Checks if an array includes an item or if a Set/Map has a key.
+ */
+handlebars.registerHelper(
+	"has",
+	function (this: unknown, collection: unknown, item: unknown, options: Handlebars.HelperOptions): string {
+		let found = false;
+		if (Array.isArray(collection)) {
+			found = collection.includes(item);
+		} else if (collection instanceof Set) {
+			found = collection.has(item);
+		} else if (collection instanceof Map) {
+			found = collection.has(item);
+		} else if (collection && typeof collection === "object") {
+			if (typeof item === "string" || typeof item === "number" || typeof item === "symbol") {
+				found = item in collection;
+			}
+		}
+		return found ? options.fn(this) : options.inverse(this);
+	},
+);
+
+/**
+ * {{includes array item}}
+ * Returns true if array includes item. For use in other helpers.
+ */
+handlebars.registerHelper("includes", (collection: unknown, item: unknown): boolean => {
+	if (Array.isArray(collection)) return collection.includes(item);
+	if (collection instanceof Set) return collection.has(item);
+	if (collection instanceof Map) return collection.has(item);
+	return false;
+});
+
+/**
+ * {{not value}}
+ * Returns logical NOT of value. For use in subexpressions.
+ */
+handlebars.registerHelper("not", (value: unknown): boolean => !value);
+
+export function renderPromptTemplate(template: string, context: TemplateContext = {}): string {
+	const compiled = handlebars.compile(template, { noEscape: true, strict: false });
+	const rendered = compiled(context ?? {});
+	return optimizePromptLayout(rendered);
+}
+
+function optimizePromptLayout(input: string): string {
+	// 1) strip CR / normalize line endings
+	let s = input.replace(/\r\n?/g, "\n");
+
+	// normalize NBSP -> space
+	s = s.replace(/\u00A0/g, " ");
+
+	const lines = s.split("\n").map((line) => {
+		// 2) remove trailing whitespace (spaces/tabs) per line
+		let l = line.replace(/[ \t]+$/g, "");
+
+		// 3) lines with only whitespace -> empty line
+		if (/^[ \t]*$/.test(l)) return "";
+
+		// 4) normalize leading indentation: every 2 spaces -> \t (preserve leftover 1 space)
+		//    NOTE: This is intentionally *only* leading indentation to avoid mangling prose.
+		const m = l.match(/^[ \t]+/);
+		if (m) {
+			const indent = m[0];
+			const rest = l.slice(indent.length);
+
+			let out = "";
+			let spaces = 0;
+
+			for (const ch of indent) {
+				if (ch === "\t") {
+					// flush pending spaces before existing tab
+					out += "\t".repeat(Math.floor(spaces / 2));
+					if (spaces % 2) out += " ";
+					spaces = 0;
+					out += "\t";
+				} else {
+					spaces++;
+				}
+			}
+
+			out += "\t".repeat(Math.floor(spaces / 2));
+			if (spaces % 2) out += " ";
+
+			l = out + rest;
+		}
+
+		return l;
+	});
+
+	s = lines.join("\n");
+
+	// 5) collapse excessive blank lines
+	s = s.replace(/\n{3,}/g, "\n\n");
+
+	return s.trim();
+}
+
 /**
  * Parse YAML frontmatter from markdown content
  * Returns { frontmatter, content } where content has frontmatter stripped
@@ -235,7 +503,9 @@ export function expandPromptTemplate(text: string, templates: PromptTemplate[]):
 	const template = templates.find((t) => t.name === templateName);
 	if (template) {
 		const args = parseCommandArgs(argsString);
-		return substituteArgs(template.content, args);
+		const argsText = args.join(" ");
+		const substituted = substituteArgs(template.content, args);
+		return renderPromptTemplate(substituted, { args, ARGUMENTS: argsText, arguments: argsText });
 	}
 
 	return text;

package/src/core/sdk.ts

@@ -71,6 +71,7 @@ import { loadSkills as loadSkillsInternal, type Skill, type SkillWarning } from
 import { type FileSlashCommand, loadSlashCommands as loadSlashCommandsInternal } from "./slash-commands";
 import { closeAllConnections } from "./ssh/connection-manager";
 import { unmountAll } from "./ssh/sshfs-mount";
+import { migrateJsonStorage } from "./storage-migration";
 import {
 	buildSystemPrompt as buildSystemPromptInternal,
 	loadProjectContextFiles as loadContextFilesInternal,
@@ -90,7 +91,6 @@ import {
 	createSshTool,
 	createTools,
 	createWriteTool,
-	filterRulebookRules,
 	getWebSearchTools,
 	setPreferredImageProvider,
 	setPreferredWebSearchProvider,
@@ -242,6 +242,13 @@ export async function discoverAuthStorage(agentDir: string = getDefaultAgentDir(
 
 	logger.debug("discoverAuthStorage", { agentDir, primaryPath, allPaths, fallbackPaths });
 
+	// Migrate legacy JSON files (settings.json, auth.json) to SQLite before loading
+	await migrateJsonStorage({
+		agentDir,
+		settingsPath: join(agentDir, "settings.json"),
+		authPaths: [primaryPath, ...fallbackPaths],
+	});
+
 	const storage = new AuthStorage(primaryPath, fallbackPaths);
 	await storage.reload();
 	return storage;
@@ -646,7 +653,12 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 	time("discoverTtsrRules");
 
 	// Filter rules for the rulebook (non-TTSR, non-alwaysApply, with descriptions)
-	const rulebookRules = filterRulebookRules(rulesResult.items);
+	const rulebookRules = rulesResult.items.filter((rule) => {
+		if (rule.ttsrTrigger) return false;
+		if (rule.alwaysApply) return false;
+		if (!rule.description) return false;
+		return true;
+	});
 	time("filterRulebookRules");
 
 	const contextFiles = options.contextFiles ?? discoverContextFiles(cwd, agentDir);
@@ -658,7 +670,6 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 	const toolSession: ToolSession = {
 		cwd,
 		hasUI: options.hasUI ?? false,
-		rulebookRules,
 		eventBus,
 		outputSchema: options.outputSchema,
 		requireCompleteTool: options.requireCompleteTool,

package/src/core/settings-manager.ts

@@ -1,9 +1,11 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
+import { existsSync, readFileSync, renameSync } from "node:fs";
+import { join } from "node:path";
 import { type Settings as SettingsItem, settingsCapability } from "../capability/settings";
-import { getAgentDir } from "../config";
+import { getAgentDbPath, getAgentDir } from "../config";
 import { loadSync } from "../discovery";
 import type { SymbolPreset } from "../modes/interactive/theme/theme";
+import { AgentStorage } from "./agent-storage";
+import { logger } from "./logger";
 
 export interface CompactionSettings {
 	enabled?: boolean; // default: true
@@ -337,10 +339,36 @@ function normalizeBashInterceptorSettings(
 	return { enabled, simpleLs, patterns };
 }
 
+let cachedNerdFonts: boolean | null = null;
+
+function hasNerdFonts(): boolean {
+	if (cachedNerdFonts !== null) {
+		return cachedNerdFonts;
+	}
+
+	const envOverride = process.env.NERD_FONTS;
+	if (envOverride === "1") {
+		cachedNerdFonts = true;
+		return true;
+	}
+	if (envOverride === "0") {
+		cachedNerdFonts = false;
+		return false;
+	}
+
+	const termProgram = (process.env.TERM_PROGRAM || "").toLowerCase();
+	const term = (process.env.TERM || "").toLowerCase();
+	const nerdTerms = ["iterm", "wezterm", "kitty", "ghostty", "alacritty"];
+	cachedNerdFonts = nerdTerms.some((candidate) => termProgram.includes(candidate) || term.includes(candidate));
+	return cachedNerdFonts;
+}
+
 function normalizeSettings(settings: Settings): Settings {
 	const merged = deepMergeSettings(DEFAULT_SETTINGS, settings);
+	const symbolPreset = merged.symbolPreset ?? (hasNerdFonts() ? "nerd" : "unicode");
 	return {
 		...merged,
+		symbolPreset,
 		bashInterceptor: normalizeBashInterceptorSettings(merged.bashInterceptor),
 	};
 }
@@ -377,15 +405,23 @@ function deepMergeSettings(base: Settings, overrides: Settings): Settings {
 }
 
 export class SettingsManager {
-	private settingsPath: string | null;
+	/** SQLite storage for persisted settings (null for in-memory mode) */
+	private storage: AgentStorage | null;
 	private cwd: string | null;
 	private globalSettings: Settings;
 	private overrides: Settings;
 	private settings!: Settings;
 	private persist: boolean;
 
-	private constructor(settingsPath: string | null, cwd: string | null, initialSettings: Settings, persist: boolean) {
-		this.settingsPath = settingsPath;
+	/**
+	 * Private constructor - use static factory methods instead.
+	 * @param storage - SQLite storage instance for persistence, or null for in-memory mode
+	 * @param cwd - Current working directory for project settings discovery
+	 * @param initialSettings - Initial global settings to use
+	 * @param persist - Whether to persist settings changes to storage
+	 */
+	private constructor(storage: AgentStorage | null, cwd: string | null, initialSettings: Settings, persist: boolean) {
+		this.storage = storage;
 		this.cwd = cwd;
 		this.persist = persist;
 		this.globalSettings = initialSettings;
@@ -416,9 +452,15 @@ export class SettingsManager {
 		}
 	}
 
-	/** Create a SettingsManager that loads from files */
+	/**
+	 * Create a SettingsManager that loads from persistent SQLite storage.
+	 * @param cwd - Current working directory for project settings discovery
+	 * @param agentDir - Agent directory containing agent.db
+	 * @returns Configured SettingsManager with merged global and user settings
+	 */
 	static create(cwd: string = process.cwd(), agentDir: string = getAgentDir()): SettingsManager {
-		const settingsPath = join(agentDir, "settings.json");
+		const storage = AgentStorage.open(getAgentDbPath(agentDir));
+		SettingsManager.migrateLegacySettingsFile(storage, agentDir);
 
 		// Use capability API to load user-level settings from all providers
 		const result = loadSync(settingsCapability.id, { cwd });
@@ -431,29 +473,58 @@ export class SettingsManager {
 			}
 		}
 
-		// Also load from agentDir for backward compatibility (if not covered by providers)
-		const legacySettings = SettingsManager.loadFromFile(settingsPath);
-		globalSettings = deepMergeSettings(globalSettings, legacySettings);
+		// Load persisted settings from agent.db (legacy settings.json is migrated separately)
+		const storedSettings = SettingsManager.loadFromStorage(storage);
+		globalSettings = deepMergeSettings(globalSettings, storedSettings);
 
-		return new SettingsManager(settingsPath, cwd, globalSettings, true);
+		return new SettingsManager(storage, cwd, globalSettings, true);
 	}
 
-	/** Create an in-memory SettingsManager (no file I/O) */
+	/**
+	 * Create an in-memory SettingsManager without persistence.
+	 * @param settings - Initial settings to use
+	 * @returns SettingsManager that won't persist changes to disk
+	 */
 	static inMemory(settings: Partial<Settings> = {}): SettingsManager {
 		return new SettingsManager(null, null, settings, false);
 	}
 
-	private static loadFromFile(path: string): Settings {
-		if (!existsSync(path)) {
+	/**
+	 * Load settings from SQLite storage, applying any schema migrations.
+	 * @param storage - AgentStorage instance, or null for in-memory mode
+	 * @returns Parsed and migrated settings, or empty object if storage is null/empty
+	 */
+	private static loadFromStorage(storage: AgentStorage | null): Settings {
+		if (!storage) {
 			return {};
 		}
+		const settings = storage.getSettings();
+		if (!settings) {
+			return {};
+		}
+		return SettingsManager.migrateSettings(settings as Record<string, unknown>);
+	}
+
+	private static migrateLegacySettingsFile(storage: AgentStorage, agentDir: string): void {
+		const settingsPath = join(agentDir, "settings.json");
+		if (!existsSync(settingsPath)) return;
+		if (storage.getSettings() !== null) return;
+
 		try {
-			const content = readFileSync(path, "utf-8");
-			const settings = JSON.parse(content);
-			return SettingsManager.migrateSettings(settings as Record<string, unknown>);
+			const content = readFileSync(settingsPath, "utf-8");
+			const parsed = JSON.parse(content);
+			if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+				return;
+			}
+			const migrated = SettingsManager.migrateSettings(parsed as Record<string, unknown>);
+			storage.saveSettings(migrated);
+			try {
+				renameSync(settingsPath, `${settingsPath}.bak`);
+			} catch (error) {
+				logger.warn("SettingsManager failed to backup settings.json", { error: String(error) });
+			}
 		} catch (error) {
-			console.error(`Warning: Could not read settings file ${path}: ${error}`);
-			return {};
+			logger.warn("SettingsManager failed to migrate settings.json", { error: String(error) });
 		}
 	}
 
@@ -497,24 +568,19 @@ export class SettingsManager {
 		this.rebuildSettings();
 	}
 
+	/**
+	 * Persist current global settings to SQLite storage and rebuild merged settings.
+	 * Merges with any concurrent changes in storage before saving.
+	 */
 	private save(): void {
-		if (this.persist && this.settingsPath) {
+		if (this.persist && this.storage) {
 			try {
-				const dir = dirname(this.settingsPath);
-				if (!existsSync(dir)) {
-					mkdirSync(dir, { recursive: true });
-				}
-
-				// Re-read current file to preserve any settings added externally while running
-				const currentFileSettings = SettingsManager.loadFromFile(this.settingsPath);
-				// Merge: file settings as base, globalSettings (in-memory changes) as overrides
-				const mergedSettings = deepMergeSettings(currentFileSettings, this.globalSettings);
+				const currentSettings = this.storage.getSettings() ?? {};
+				const mergedSettings = deepMergeSettings(currentSettings, this.globalSettings);
 				this.globalSettings = mergedSettings;
-
-				// Save merged settings (project settings are read-only)
-				writeFileSync(this.settingsPath, JSON.stringify(this.globalSettings, null, 2), "utf-8");
+				this.storage.saveSettings(this.globalSettings);
 			} catch (error) {
-				console.error(`Warning: Could not save settings file: ${error}`);
+				logger.warn("SettingsManager save failed", { error: String(error) });
 			}
 		}
 

package/src/core/slash-commands.ts

@@ -2,6 +2,7 @@ import { slashCommandCapability } from "../capability/slash-command";
 import type { SlashCommand } from "../discovery";
 import { loadSync } from "../discovery";
 import { parseFrontmatter } from "../discovery/helpers";
+import { renderPromptTemplate } from "./prompt-templates";
 import { EMBEDDED_COMMAND_TEMPLATES } from "./tools/task/commands";
 
 /**
@@ -158,7 +159,9 @@ export function expandSlashCommand(text: string, fileCommands: FileSlashCommand[
 	const fileCommand = fileCommands.find((cmd) => cmd.name === commandName);
 	if (fileCommand) {
 		const args = parseCommandArgs(argsString);
-		return substituteArgs(fileCommand.content, args);
+		const argsText = args.join(" ");
+		const substituted = substituteArgs(fileCommand.content, args);
+		return renderPromptTemplate(substituted, { args, ARGUMENTS: argsText, arguments: argsText });
 	}
 
 	return text;