@oh-my-pi/pi-coding-agent 16.0.1 → 16.0.3

package/src/extensibility/extensions/loader.ts

@@ -10,6 +10,7 @@ import type { KeyId } from "@oh-my-pi/pi-tui";
 import { hasFsCode, isEacces, isEnoent, logger } from "@oh-my-pi/pi-utils";
 import { z } from "zod/v4";
 import { type ExtensionModule, extensionModuleCapability } from "../../capability/extension-module";
+import { type Hook, hookCapability } from "../../capability/hook";
 import { loadCapability } from "../../discovery";
 import { getExtensionNameFromPath } from "../../discovery/helpers";
 import type { ExecOptions } from "../../exec/exec";
@@ -479,8 +480,8 @@ async function discoverExtensionsInDir(dir: string): Promise<string[]> {
 /**
  * Discover absolute paths of extensions to load, without importing or
  * binding factories. Hot path on session startup — the scan walks native
- * `.omp`/`.pi` extension capabilities, the installed-plugin tree, and any
- * configured paths.
+ * `.omp`/`.pi` extension capabilities, JS/TS hook factories, the
+ * installed-plugin tree, and any configured paths.
  *
  * Subagents reuse the parent's collected paths via the SDK's
  * `preloadedExtensionPaths` option, then call {@link loadExtensions} themselves
@@ -492,11 +493,12 @@ async function discoverExtensionsInDir(dir: string): Promise<string[]> {
 export async function discoverExtensionPaths(
 	configuredPaths: string[],
 	cwd: string,
-	disabledExtensionIds: string[] = [],
+	disabledExtensionIds?: string[],
 ): Promise<string[]> {
 	const allPaths: string[] = [];
 	const seen = new Set<string>();
-	const disabled = new Set(disabledExtensionIds);
+	const disabled = new Set(disabledExtensionIds ?? []);
+	const loadOptions = disabledExtensionIds ? { cwd, disabledExtensions: disabledExtensionIds } : { cwd };
 
 	const isDisabledName = (name: string): boolean => disabled.has(`extension-module:${name}`);
 
@@ -516,17 +518,27 @@ export async function discoverExtensionPaths(
 	};
 
 	// 1. Discover extension modules via capability API (native .omp/.pi only)
-	const discovered = await loadCapability<ExtensionModule>(extensionModuleCapability.id, { cwd });
+	const discovered = await loadCapability<ExtensionModule>(extensionModuleCapability.id, loadOptions);
 	for (const ext of discovered.items) {
 		if (ext._source.provider !== "native") continue;
-		if (isDisabledName(ext.name)) continue;
 		addPath(ext.path);
 	}
 
-	// 2. Discover extension entry points from installed plugins
+	// 2. Discover JS/TS hook factories from hookCapability and bind them through
+	// the extension runner, which owns the current runtime event bus. Hook
+	// capability loading already applies hook-specific disabled ids; do not also
+	// filter them through extension-module names.
+	const hooks = await loadCapability<Hook>(hookCapability.id, loadOptions);
+	for (const hookPath of hooks.items
+		.map(hook => hook.path)
+		.filter(hookPath => isExtensionFile(path.basename(hookPath)))) {
+		addPath(hookPath);
+	}
+
+	// 3. Discover extension entry points from installed plugins
 	addPaths(await getAllPluginExtensionPaths(cwd));
 
-	// 3. Explicitly configured paths
+	// 4. Explicitly configured paths
 	for (const configuredPath of configuredPaths) {
 		const resolved = resolvePath(configuredPath, cwd);
 
@@ -566,7 +578,7 @@ export async function discoverAndLoadExtensions(
 	configuredPaths: string[],
 	cwd: string,
 	eventBus?: EventBus,
-	disabledExtensionIds: string[] = [],
+	disabledExtensionIds?: string[],
 ): Promise<LoadExtensionsResult> {
 	const paths = await discoverExtensionPaths(configuredPaths, cwd, disabledExtensionIds);
 	return loadExtensions(paths, cwd, eventBus);

package/src/extensibility/extensions/runner.ts

@@ -543,7 +543,9 @@ export class ExtensionRunner {
 			event.type === "session_before_tree"
 		);
 	}
-
+	#isSessionShutdownEvent(event: RunnerEmitEvent): event is Extract<RunnerEmitEvent, { type: "session_shutdown" }> {
+		return event.type === "session_shutdown";
+	}
 	async #runHandlerWithTimeout<TEvent extends { type: string }, TResult>(
 		handler: (event: TEvent, ctx: ExtensionContext) => Promise<TResult | undefined> | TResult | undefined,
 		event: TEvent,
@@ -588,6 +590,20 @@ export class ExtensionRunner {
 		const ctx = this.createContext();
 		let result: SessionBeforeEventResult | SessionCompactingResult | undefined;
 
+		if (this.#isSessionShutdownEvent(event)) {
+			const timeoutMs = handlerTimeoutForEvent(event.type);
+			const promises: Promise<unknown>[] = [];
+			for (const ext of this.extensions) {
+				const handlers = ext.handlers.get(event.type);
+				if (!handlers || handlers.length === 0) continue;
+				for (const handler of handlers) {
+					promises.push(this.#runHandlerWithTimeout(handler, event, ctx, ext, timeoutMs));
+				}
+			}
+			await Promise.all(promises);
+			return result as RunnerEmitResult<TEvent>;
+		}
+
 		for (const ext of this.extensions) {
 			const handlers = ext.handlers.get(event.type);
 			if (!handlers || handlers.length === 0) continue;

package/src/extensibility/plugins/loader.ts

@@ -143,29 +143,161 @@ export async function getEnabledPlugins(cwd: string, opts: { home?: string } = {
 // Path Resolution
 // =============================================================================
 
-const MANIFEST_ENTRY_INDEX_NAMES = ["index.ts", "index.js", "index.mjs", "index.cjs"];
+const MANIFEST_ENTRY_MODULE_EXTENSIONS = [".ts", ".js", ".mjs", ".cjs"];
+const MANIFEST_ENTRY_INDEX_NAMES = MANIFEST_ENTRY_MODULE_EXTENSIONS.map(ext => `index${ext}`);
+
+/** `.d.ts` / `.d.mts` / `.d.cts` TypeScript declaration files — never loadable as modules. */
+const DECLARATION_FILE_RE = /\.d\.[mc]?ts$/;
+
+/** A loadable module file: a .ts/.js/.mjs/.cjs that is not a declaration file. */
+function isModuleFile(name: string): boolean {
+	return MANIFEST_ENTRY_MODULE_EXTENSIONS.includes(path.extname(name)) && !DECLARATION_FILE_RE.test(name);
+}
+
+/** First `index.{ts,js,mjs,cjs}` inside `dir`, or null when none exists. */
+function findDirectoryIndex(dir: string): string | null {
+	for (const name of MANIFEST_ENTRY_INDEX_NAMES) {
+		const candidate = path.join(dir, name);
+		if (fs.existsSync(candidate)) return candidate;
+	}
+	return null;
+}
+
+interface DeclaredManifestEntries {
+	/** True when the directory's package.json declares a non-empty `omp`/`pi` `extensions` array. */
+	declared: boolean;
+	/** Resolved, existing module files for the declared entries (may be empty when declared files are missing). */
+	files: string[];
+}
+
+/**
+ * Read the extension entries declared by `dir`'s own package.json `omp`/`pi`
+ * manifest. `declared` distinguishes "a manifest explicitly lists extensions"
+ * (authoritative — callers must not fall back to index/scan, so a missing
+ * declared file surfaces as a missing entry instead of silently loading a stale
+ * index) from "no manifest / no extensions field" (callers fall back to
+ * convention). Mirrors the manifest branch of the configured-directory (`-e`)
+ * scanner: a declared entry that is a file resolves to itself; one that is a
+ * directory resolves to its direct index.{ts,js,mjs,cjs}.
+ */
+function readDeclaredManifestEntries(dir: string): DeclaredManifestEntries {
+	let raw: string;
+	try {
+		raw = fs.readFileSync(path.join(dir, "package.json"), "utf8");
+	} catch {
+		return { declared: false, files: [] };
+	}
+	let pkg: { omp?: { extensions?: unknown }; pi?: { extensions?: unknown } };
+	try {
+		pkg = JSON.parse(raw) as { omp?: { extensions?: unknown }; pi?: { extensions?: unknown } };
+	} catch {
+		return { declared: false, files: [] };
+	}
+	const declared = (pkg.omp ?? pkg.pi)?.extensions;
+	if (!Array.isArray(declared) || declared.length === 0) {
+		return { declared: false, files: [] };
+	}
+	const files: string[] = [];
+	for (const entry of declared) {
+		if (typeof entry !== "string") continue;
+		const candidate = path.resolve(dir, entry);
+		let candidateStats: fs.Stats;
+		try {
+			candidateStats = fs.statSync(candidate);
+		} catch {
+			continue;
+		}
+		if (candidateStats.isDirectory()) {
+			const index = findDirectoryIndex(candidate);
+			if (index) files.push(index);
+		} else {
+			files.push(candidate);
+		}
+	}
+	return { declared: true, files };
+}
 
 /**
- * Resolve a plugin manifest entry to a concrete loadable file path. Returns the
- * file path itself when the entry points at a file, the matching index file when
- * the entry points at a directory containing index.{ts,js,mjs,cjs}, and null
- * when no entry exists at the joined path.
+ * Resolve a directory to its loadable extension module files, mirroring the
+ * configured-directory (`-e`) scanner in extensions/loader.ts:
+ *   1. the directory's own package.json `omp`/`pi` `extensions` entries —
+ *      authoritative: a manifest that lists extensions suppresses the index/scan
+ *      fallback, so a missing declared file is reported rather than silently
+ *      replaced by a decoy index
+ *   2. a direct index.{ts,js,mjs,cjs}
+ *   3. one level of children: each direct *.{ts,js,mjs,cjs} file plus each
+ *      sub-directory resolved by the same precedence (manifest, then index)
  */
-function resolveManifestEntryFile(joined: string): string | null {
+function resolveDirectoryEntries(dir: string): string[] {
+	const manifest = readDeclaredManifestEntries(dir);
+	if (manifest.declared) return manifest.files;
+
+	const directIndex = findDirectoryIndex(dir);
+	if (directIndex) return [directIndex];
+
+	let children: string[];
+	try {
+		children = fs.readdirSync(dir);
+	} catch {
+		return [];
+	}
+	const resolved: string[] = [];
+	for (const child of children.sort()) {
+		const childPath = path.join(dir, child);
+		let childStats: fs.Stats;
+		try {
+			// statSync follows symlinks, matching the configured-dir loader.
+			childStats = fs.statSync(childPath);
+		} catch {
+			continue;
+		}
+		if (childStats.isDirectory()) {
+			const childManifest = readDeclaredManifestEntries(childPath);
+			if (childManifest.declared) {
+				resolved.push(...childManifest.files);
+			} else {
+				const index = findDirectoryIndex(childPath);
+				if (index) resolved.push(index);
+			}
+		} else if (isModuleFile(child)) {
+			resolved.push(childPath);
+		}
+	}
+	return resolved;
+}
+
+/**
+ * Resolve a plugin manifest entry to the loadable module files it names:
+ * - a file entry → that file
+ * - a directory:
+ *   - when `expandDirectory` (the `extensions` key), resolved by
+ *     {@link resolveDirectoryEntries} — its own package.json `omp`/`pi`
+ *     `extensions`, then a direct index, then a one-level scan of
+ *     sub-extensions — matching the pi `extensions/<name>/index.ts` convention
+ *     and OMP's configured-directory (`-e`) extension loader
+ *   - otherwise (tools/hooks/commands) only a direct index.{ts,js,mjs,cjs}.
+ *     The sub-extension scan and the `omp`/`pi` `extensions` manifest are
+ *     extensions-specific and must not hijack a non-extension directory entry
+ *     (e.g. a `tools: "."` entry must still resolve `./index.ts`).
+ *
+ * Returns an empty array when nothing loadable exists at `joined`, letting
+ * callers flag a missing entry instead of silently dropping it.
+ */
+function resolveManifestEntryFiles(joined: string, expandDirectory: boolean): string[] {
 	let stats: fs.Stats;
 	try {
 		stats = fs.statSync(joined);
 	} catch {
-		return null;
+		return [];
 	}
-	if (stats.isDirectory()) {
-		for (const name of MANIFEST_ENTRY_INDEX_NAMES) {
-			const candidate = path.join(joined, name);
-			if (fs.existsSync(candidate)) return candidate;
-		}
-		return null;
+	if (!stats.isDirectory()) {
+		return [joined];
+	}
+	if (expandDirectory) {
+		return resolveDirectoryEntries(joined);
 	}
-	return joined;
+	const index = findDirectoryIndex(joined);
+	return index ? [index] : [];
 }
 
 /**
@@ -196,16 +328,17 @@ export function resolvePluginManifestEntries(
 	const declared: Array<{ entry: string; resolvedPath: string | null }> = [];
 	const manifest = plugin.manifest;
 
-	const resolveEntry = (entry: string): { entry: string; resolvedPath: string | null } => ({
-		entry,
-		resolvedPath: resolveManifestEntryFile(path.join(plugin.path, entry)),
-	});
+	const expandDirectory = key === "extensions";
+	const resolveEntry = (entry: string): Array<{ entry: string; resolvedPath: string | null }> => {
+		const files = resolveManifestEntryFiles(path.join(plugin.path, entry), expandDirectory);
+		return files.length > 0 ? files.map(resolvedPath => ({ entry, resolvedPath })) : [{ entry, resolvedPath: null }];
+	};
 
 	const base = manifest[key];
 	if (base) {
 		const entries = Array.isArray(base) ? base : [base];
 		for (const entry of entries) {
-			declared.push(resolveEntry(entry));
+			declared.push(...resolveEntry(entry));
 		}
 	}
 
@@ -215,7 +348,7 @@ export function resolvePluginManifestEntries(
 			if (!enabledSet.has(featName)) continue;
 			if (feat[key]) {
 				for (const entry of feat[key]) {
-					declared.push(resolveEntry(entry));
+					declared.push(...resolveEntry(entry));
 				}
 			}
 		}
@@ -225,7 +358,7 @@ export function resolvePluginManifestEntries(
 			if (!feat.default) continue;
 			if (feat[key]) {
 				for (const entry of feat[key]) {
-					declared.push(resolveEntry(entry));
+					declared.push(...resolveEntry(entry));
 				}
 			}
 		}

package/src/extensibility/plugins/manager.ts

@@ -205,6 +205,17 @@ export class PluginManager {
 		}
 	}
 
+	#collectInstalledNames(deps: Record<string, string>, config: PluginRuntimeConfig): Set<string> {
+		const installedNames = new Set<string>();
+		for (const name of Object.keys(deps)) {
+			installedNames.add(name);
+		}
+		for (const name of Object.keys(config.plugins)) {
+			installedNames.add(name);
+		}
+		return installedNames;
+	}
+
 	async #snapshotInstalledPackage(actualName: string | undefined): Promise<PluginPackageSnapshot | null> {
 		if (!actualName) {
 			return null;
@@ -490,21 +501,22 @@ export class PluginManager {
 	 */
 	async list(): Promise<InstalledPlugin[]> {
 		const pkgJsonPath = getPluginsPackageJson();
-		let pkg: { dependencies?: Record<string, string> };
+		let deps: Record<string, string> = {};
 		try {
-			pkg = await Bun.file(pkgJsonPath).json();
+			const pkg: { dependencies?: Record<string, string> } = await Bun.file(pkgJsonPath).json();
+			deps = pkg.dependencies ?? {};
 		} catch (err) {
-			if (isEnoent(err)) return [];
-			throw err;
+			if (!isEnoent(err)) throw err;
 		}
 
-		const deps = pkg.dependencies || {};
 		const projectOverrides = await this.#loadProjectOverrides();
 		const config = await this.#ensureConfigLoaded();
 		const plugins: InstalledPlugin[] = [];
+		const installedNames = this.#collectInstalledNames(deps, config);
 
-		for (const [name] of Object.entries(deps)) {
-			const pluginPkgPath = path.join(getPluginsNodeModules(), name, "package.json");
+		for (const name of installedNames) {
+			const pluginPath = path.join(getPluginsNodeModules(), name);
+			const pluginPkgPath = path.join(pluginPath, "package.json");
 			let pluginPkg: { version: string; omp?: PluginManifest; pi?: PluginManifest };
 			try {
 				pluginPkg = await Bun.file(pluginPkgPath).json();
@@ -521,14 +533,13 @@ export class PluginManager {
 				enabled: true,
 			};
 
-			// Apply project overrides
 			const isDisabledInProject = projectOverrides.disabled?.includes(name) ?? false;
 			const projectFeatures = projectOverrides.features?.[name];
 
 			plugins.push({
 				name,
 				version: pluginPkg.version,
-				path: path.join(getPluginsNodeModules(), name),
+				path: pluginPath,
 				manifest,
 				enabledFeatures: projectFeatures ?? runtimeState.enabledFeatures,
 				enabled: runtimeState.enabled && !isDisabledInProject,
@@ -744,15 +755,14 @@ export class PluginManager {
 			message: hasNodeModules ? "Found" : "Missing (run npm install in plugins dir)",
 		});
 
-		if (!hasPkgJson) {
-			return checks;
-		}
 		const deps = pkg.dependencies || {};
 		const config = await this.#ensureConfigLoaded();
+		const installedNames = this.#collectInstalledNames(deps, config);
 
-		for (const [name] of Object.entries(deps)) {
+		for (const name of installedNames) {
 			const pluginPath = path.join(nodeModulesPath, name);
 			const pluginPkgPath = path.join(pluginPath, "package.json");
+			const fromDependencies = name in deps;
 
 			let pluginPkg: { version: string; description?: string; omp?: PluginManifest; pi?: PluginManifest };
 			try {
@@ -760,13 +770,23 @@ export class PluginManager {
 			} catch (err) {
 				if (isEnoent(err)) {
 					if (!fs.existsSync(pluginPath)) {
-						const fixed = options.fix ? await this.#fixMissingPlugin() : false;
-						checks.push({
-							name: `plugin:${name}`,
-							status: "error",
-							message: "Missing from node_modules",
-							fixed,
-						});
+						if (fromDependencies) {
+							const fixed = options.fix ? await this.#fixMissingPlugin() : false;
+							checks.push({
+								name: `plugin:${name}`,
+								status: "error",
+								message: "Missing from node_modules",
+								fixed,
+							});
+						} else {
+							const fixed = options.fix ? await this.#removeOrphanedConfig(name) : false;
+							checks.push({
+								name: `orphan:${name}`,
+								status: "warning",
+								message: "Plugin in config but not installed",
+								fixed,
+							});
+						}
 					} else {
 						checks.push({
 							name: `plugin:${name}`,
@@ -844,19 +864,6 @@ export class PluginManager {
 			}
 		}
 
-		// Check for orphaned runtime config entries
-		for (const name of Object.keys(config.plugins)) {
-			if (!(name in deps)) {
-				const fixed = options.fix ? await this.#removeOrphanedConfig(name) : false;
-				checks.push({
-					name: `orphan:${name}`,
-					status: "warning",
-					message: "Plugin in config but not installed",
-					fixed,
-				});
-			}
-		}
-
 		return checks;
 	}
 

package/src/goals/runtime.ts

@@ -1,4 +1,4 @@
-import { prompt, Snowflake } from "@oh-my-pi/pi-utils";
+import { escapeXmlText, prompt, Snowflake } from "@oh-my-pi/pi-utils";
 import goalBudgetLimitPrompt from "../prompts/goals/goal-budget-limit.md" with { type: "text" };
 import goalContinuationPrompt from "../prompts/goals/goal-continuation.md" with { type: "text" };
 import goalModeActivePrompt from "../prompts/goals/goal-mode-active.md" with { type: "text" };
@@ -58,28 +58,6 @@ export function remainingTokens(goal: Goal | null | undefined): number | null {
 	return Math.max(0, goal.tokenBudget - goal.tokensUsed);
 }
 
-export function escapeXmlText(input: string): string {
-	let firstEscapable = -1;
-	for (let index = 0; index < input.length; index++) {
-		const char = input.charCodeAt(index);
-		if (char === 38 || char === 60 || char === 62) {
-			firstEscapable = index;
-			break;
-		}
-	}
-	if (firstEscapable === -1) return input;
-
-	let output = input.slice(0, firstEscapable);
-	for (let index = firstEscapable; index < input.length; index++) {
-		const char = input[index];
-		if (char === "&") output += "&amp;";
-		else if (char === "<") output += "&lt;";
-		else if (char === ">") output += "&gt;";
-		else output += char;
-	}
-	return output;
-}
-
 export function renderTrustedObjective(objective: string): string {
 	return `<objective>\n${escapeXmlText(objective)}\n</objective>`;
 }