@opencow-ai/opencow-agent-sdk 0.4.22 → 0.4.23

package/dist/cli.mjs

@@ -33074,7 +33074,10 @@ var init_schemas3 = __esm(() => {
   NO_AUTO_UPDATE_OFFICIAL_MARKETPLACES = new Set(["knowledge-work-plugins"]);
   BLOCKED_OFFICIAL_NAME_PATTERN = /(?:official[^a-z0-9]*(anthropic|claude)|(?:anthropic|claude)[^a-z0-9]*official|^(?:anthropic|claude)[^a-z0-9]*(marketplace|plugins|official))/i;
   NON_ASCII_PATTERN = /[^\u0020-\u007E]/;
-  RelativePath = lazySchema(() => exports_external.string().startsWith("../../utils/plugins"));
+  RelativePath = lazySchema(() => exports_external.string().min(1).refine((path9) => {
+    const normalized = path9.replaceAll("\\", "/");
+    return !normalized.includes("\x00") && !normalized.startsWith("/") && !/^[a-z][a-z0-9+.-]*:/i.test(normalized) && normalized.split("/").every((segment) => segment !== "..");
+  }, "Path must be relative and remain within the plugin root"));
   RelativeJSONPath = lazySchema(() => RelativePath().endsWith(".json"));
   McpbPath = lazySchema(() => exports_external.union([
     RelativePath().refine((path9) => path9.endsWith(".mcpb") || path9.endsWith(".dxt"), {
@@ -88740,7 +88743,11 @@ function buildQueryContextFromSdk(options) {
       agentColorIndex: 0,
       systemPromptSectionCache: new Map,
       cachedClaudeMdContent: null,
-      settingsCache: { session: null, perSource: new Map, parseFile: new Map },
+      settingsCache: {
+        session: null,
+        perSource: new Map,
+        parseFile: new Map
+      },
       memoryExtractionState: {
         config: {
           minimumMessageTokensToInit: 1e4,
@@ -88761,7 +88768,9 @@ function buildQueryContextFromSdk(options) {
         conditional: new Map,
         activatedConditional: new Set,
         loaded: createSignal()
-      }
+      },
+      pluginDataPaths: new Map,
+      lspManager: null
     },
     diagnostics: createFreshDiagnostics(),
     provider: options.provider ?? resolveProviderFromEnv(freezeEnvMap(options.env)),
@@ -89425,6 +89434,25 @@ function resetSdkInitState() {
   r.initJsonSchema = null;
   r.registeredHooks = null;
 }
+function setExplicitPluginRuntimeContext(dataPaths, lspManager) {
+  const registries2 = getQueryContext().registries;
+  registries2.pluginDataPaths = new Map(dataPaths);
+  registries2.lspManager = lspManager;
+}
+function tryGetExplicitPluginDataPath(pluginId) {
+  try {
+    return getQueryContext().registries.pluginDataPaths.get(pluginId);
+  } catch {
+    return;
+  }
+}
+function tryGetSessionLspManager() {
+  try {
+    return getQueryContext().registries.lspManager ?? undefined;
+  } catch {
+    return;
+  }
+}
 function addInvokedSkill(skillName, skillPath, content, agentId = null) {
   const key = `${agentId ?? ""}:${skillName}`;
   getQueryContext().registries.invokedSkills.set(key, {
@@ -89876,6 +89904,7 @@ __export(exports_state, {
   setCwdState: () => setCwdState,
   setDirectConnectServerUrl: () => setDirectConnectServerUrl,
   setEnvVar: () => setEnvVar,
+  setExplicitPluginRuntimeContext: () => setExplicitPluginRuntimeContext,
   setFastModeHeaderLatched: () => setFastModeHeaderLatched,
   setFlagSettingsInline: () => setFlagSettingsInline,
   setHasDevChannels: () => setHasDevChannels,
@@ -89910,7 +89939,9 @@ __export(exports_state, {
   setThinkingClearLatched: () => setThinkingClearLatched,
   snapshotOutputTokensForTurn: () => snapshotOutputTokensForTurn,
   switchSession: () => switchSession,
+  tryGetExplicitPluginDataPath: () => tryGetExplicitPluginDataPath,
   tryGetQueryContext: () => tryGetQueryContext,
+  tryGetSessionLspManager: () => tryGetSessionLspManager,
   unregisterCreatedTeam: () => unregisterCreatedTeam
 });
 var init_state = __esm(() => {
@@ -92241,9 +92272,7 @@ function createBootQueryContext() {
     resolvedCwd = "";
   }
   const sessionId = randomUUID3();
-  const {
-    computeSessionPaths: computeSessionPaths2
-  } = (init_paths(), __toCommonJS(exports_paths));
+  const { computeSessionPaths: computeSessionPaths2 } = (init_paths(), __toCommonJS(exports_paths));
   const { resolveLayoutProfile: resolveLayoutProfile2, DEFAULT_LAYOUT_PROFILE: DEFAULT_LAYOUT_PROFILE2 } = (init_LayoutProfile(), __toCommonJS(exports_LayoutProfile));
   const { getManagedFilePath: getManagedFilePath2 } = (init_managedPath(), __toCommonJS(exports_managedPath));
   const { homedir: homedir11 } = __require("node:os");
@@ -92323,7 +92352,11 @@ function createBootQueryContext() {
       agentColorIndex: 0,
       systemPromptSectionCache: new Map,
       cachedClaudeMdContent: null,
-      settingsCache: { session: null, perSource: new Map, parseFile: new Map },
+      settingsCache: {
+        session: null,
+        perSource: new Map,
+        parseFile: new Map
+      },
       memoryExtractionState: {
         config: {
           minimumMessageTokensToInit: 1e4,
@@ -92344,7 +92377,9 @@ function createBootQueryContext() {
         conditional: new Map,
         activatedConditional: new Set,
         loaded: createSignal()
-      }
+      },
+      pluginDataPaths: new Map,
+      lspManager: null
     },
     diagnostics: createFreshDiagnostics(),
     provider: (() => {
@@ -92414,7 +92449,11 @@ function deriveSubagentRegistries(parent) {
     agentColorIndex: parent.agentColorIndex,
     systemPromptSectionCache: new Map,
     cachedClaudeMdContent: null,
-    settingsCache: { session: null, perSource: new Map, parseFile: new Map },
+    settingsCache: {
+      session: null,
+      perSource: new Map,
+      parseFile: new Map
+    },
     memoryExtractionState: {
       config: {
         minimumMessageTokensToInit: 1e4,
@@ -92429,7 +92468,9 @@ function deriveSubagentRegistries(parent) {
     systemPromptInjection: null,
     sentSkillNames: new Set,
     skillListingSuppressNext: false,
-    dynamicSkills: parent.dynamicSkills
+    dynamicSkills: parent.dynamicSkills,
+    pluginDataPaths: parent.pluginDataPaths,
+    lspManager: parent.lspManager
   };
 }
 function cloneHookRegistry(registry2) {
@@ -94777,7 +94818,7 @@ function printStartupScreen() {
   const sLen = ` ● ${sL}    Ready — type /help to begin`.length;
   out.push(boxRow(sRow, W2, sLen));
   out.push(`${rgb(...BORDER)}╚${"═".repeat(W2 - 2)}╝${RESET}`);
-  out.push(`  ${DIM}${rgb(...DIMCOL)}opencow ${RESET}${rgb(...ACCENT)}v${"0.4.22"}${RESET}`);
+  out.push(`  ${DIM}${rgb(...DIMCOL)}opencow ${RESET}${rgb(...ACCENT)}v${"0.4.23"}${RESET}`);
   out.push("");
   process.stdout.write(out.join(`
 `) + `
@@ -144752,7 +144793,7 @@ function pluginDataDirPath(pluginId) {
   return join46(getPluginsDirectory(), "data", sanitizePluginId(pluginId));
 }
 function getPluginDataDir(pluginId) {
-  const dir = pluginDataDirPath(pluginId);
+  const dir = tryGetExplicitPluginDataPath(pluginId) ?? pluginDataDirPath(pluginId);
   getFsImplementation().mkdirSync(dir, { recursive: true });
   return dir;
 }
@@ -144760,7 +144801,9 @@ async function getPluginDataDirSize(pluginId) {
   const dir = pluginDataDirPath(pluginId);
   let bytes = 0;
   const walk = async (p) => {
-    for (const entry of await getFsImplementation().readdir(p, { withFileTypes: true })) {
+    for (const entry of await getFsImplementation().readdir(p, {
+      withFileTypes: true
+    })) {
       const full = join46(p, entry.name);
       if (entry.isDirectory()) {
         await walk(full);
@@ -144921,7 +144964,7 @@ function substitutePluginVariables(value, plugin) {
   let out = value.replace(/\$\{CLAUDE_PLUGIN_ROOT\}/g, () => normalize10(plugin.path));
   if (plugin.source) {
     const source = plugin.source;
-    out = out.replace(/\$\{CLAUDE_PLUGIN_DATA\}/g, () => normalize10(getPluginDataDir(source)));
+    out = out.replace(/\$\{CLAUDE_PLUGIN_DATA\}/g, () => normalize10(plugin.dataPath ?? getPluginDataDir(source)));
   }
   return out;
 }
@@ -144955,7 +144998,10 @@ var init_pluginOptionsStorage = __esm(() => {
   init_settings2();
   init_mcpbHandler();
   init_pluginDirectories();
+  init_state();
   loadPluginOptions = memoize_default((pluginId) => {
+    if (tryGetExplicitPluginDataPath(pluginId))
+      return {};
     const settings = getSettings_DEPRECATED();
     const nonSensitive = settings.pluginConfigs?.[pluginId]?.options ?? {};
     const storage = getSecureStorage();
@@ -145018,7 +145064,7 @@ async function loadMcpServersFromMcpb(plugin, mcpbPath, errors4) {
 }
 async function loadPluginMcpServers(plugin, errors4 = []) {
   let servers = {};
-  const defaultMcpServers = await loadMcpServersFromFile(plugin.path, PATH_SEGMENTS.settings.mcpProjectConfig);
+  const defaultMcpServers = await loadMcpServersFromFile(plugin.path, PATH_SEGMENTS.settings.mcpProjectConfig, errors4, plugin, false);
   if (defaultMcpServers) {
     servers = { ...servers, ...defaultMcpServers };
   }
@@ -145031,7 +145077,7 @@ async function loadPluginMcpServers(plugin, errors4 = []) {
           servers = { ...servers, ...mcpbServers };
         }
       } else {
-        const mcpServers = await loadMcpServersFromFile(plugin.path, mcpServersSpec);
+        const mcpServers = await loadMcpServersFromFile(plugin.path, mcpServersSpec, errors4, plugin, true);
         if (mcpServers) {
           servers = { ...servers, ...mcpServers };
         }
@@ -145043,11 +145089,18 @@ async function loadPluginMcpServers(plugin, errors4 = []) {
             if (isMcpbSource(spec)) {
               return await loadMcpServersFromMcpb(plugin, spec, errors4);
             }
-            return await loadMcpServersFromFile(plugin.path, spec);
+            return await loadMcpServersFromFile(plugin.path, spec, errors4, plugin, true);
           }
           return spec;
         } catch (e) {
           logForDebugging2(`Failed to load MCP servers from spec for plugin ${plugin.name}: ${e}`, { level: "error" });
+          errors4.push({
+            type: "mcp-config-invalid",
+            source: plugin.source,
+            plugin: plugin.name,
+            serverName: "manifest",
+            validationError: errorMessage(e)
+          });
           return null;
         }
       }));
@@ -145062,19 +145115,26 @@ async function loadPluginMcpServers(plugin, errors4 = []) {
   }
   return Object.keys(servers).length > 0 ? servers : undefined;
 }
-async function loadMcpServersFromFile(pluginPath, relativePath) {
+async function loadMcpServersFromFile(pluginPath, relativePath, errors4, plugin, required2) {
   const fs2 = getFsImplementation();
   const filePath = join47(pluginPath, relativePath);
   let content;
   try {
     content = await fs2.readFile(filePath, { encoding: "utf-8" });
   } catch (e) {
-    if (isENOENT(e)) {
+    if (isENOENT(e) && !required2) {
       return null;
     }
     logForDebugging2(`Failed to load MCP servers from ${filePath}: ${e}`, {
       level: "error"
     });
+    errors4.push({
+      type: "mcp-config-invalid",
+      source: plugin.source,
+      plugin: plugin.name,
+      serverName: relativePath,
+      validationError: errorMessage(e)
+    });
     return null;
   }
   try {
@@ -145087,6 +145147,13 @@ async function loadMcpServersFromFile(pluginPath, relativePath) {
         validatedServers[name] = result.data;
       } else {
         logForDebugging2(`Invalid MCP server config for ${name} in ${filePath}: ${result.error.message}`, { level: "error" });
+        errors4.push({
+          type: "mcp-config-invalid",
+          source: plugin.source,
+          plugin: plugin.name,
+          serverName: name,
+          validationError: result.error.message
+        });
       }
     }
     return validatedServers;
@@ -145094,6 +145161,13 @@ async function loadMcpServersFromFile(pluginPath, relativePath) {
     logForDebugging2(`Failed to load MCP servers from ${filePath}: ${error41}`, {
       level: "error"
     });
+    errors4.push({
+      type: "mcp-config-invalid",
+      source: plugin.source,
+      plugin: plugin.name,
+      serverName: relativePath,
+      validationError: errorMessage(error41)
+    });
     return null;
   }
 }
@@ -145171,7 +145245,7 @@ function resolvePluginMcpEnvironment(config2, plugin, userConfig, errors4, plugi
       }
       const resolvedEnv = {
         CLAUDE_PLUGIN_ROOT: plugin.path,
-        CLAUDE_PLUGIN_DATA: getPluginDataDir(plugin.source),
+        CLAUDE_PLUGIN_DATA: plugin.dataPath ?? getPluginDataDir(plugin.source),
         ...stdioConfig.env || {}
       };
       for (const [key, value] of Object.entries(resolvedEnv)) {
@@ -145633,16 +145707,16 @@ var init_walkPluginMarkdown = __esm(() => {
 
 // src/capabilities/plugins/loadPluginAgents.ts
 import { basename as basename9 } from "path";
-async function loadAgentsFromDirectory(agentsPath, pluginName, sourceName, pluginPath, pluginManifest, loadedPaths) {
+async function loadAgentsFromDirectory(agentsPath, pluginName, sourceName, pluginPath, dataPath, pluginManifest, loadedPaths, strict = false) {
   const agents = [];
   await walkPluginMarkdown(agentsPath, async (fullPath, namespace) => {
-    const agent = await loadAgentFromFile(fullPath, pluginName, namespace, sourceName, pluginPath, pluginManifest, loadedPaths);
+    const agent = await loadAgentFromFile(fullPath, pluginName, namespace, sourceName, pluginPath, dataPath, pluginManifest, loadedPaths, strict);
     if (agent)
       agents.push(agent);
   }, { logLabel: "agents" });
   return agents;
 }
-async function loadAgentFromFile(filePath, pluginName, namespace, sourceName, pluginPath, pluginManifest, loadedPaths) {
+async function loadAgentFromFile(filePath, pluginName, namespace, sourceName, pluginPath, dataPath, pluginManifest, loadedPaths, strict = false) {
   const fs2 = getFsImplementation();
   if (isDuplicatePath(fs2, filePath, loadedPaths)) {
     return null;
@@ -145667,7 +145741,8 @@ async function loadAgentFromFile(filePath, pluginName, namespace, sourceName, pl
     const background = backgroundRaw === "true" || backgroundRaw === true ? true : undefined;
     let systemPrompt = substitutePluginVariables(markdownContent.trim(), {
       path: pluginPath,
-      source: sourceName
+      source: sourceName,
+      dataPath
     });
     if (pluginManifest.userConfig) {
       systemPrompt = substituteUserConfigInContent(systemPrompt, loadPluginOptions(sourceName), pluginManifest.userConfig);
@@ -145730,6 +145805,7 @@ async function loadAgentFromFile(filePath, pluginName, namespace, sourceName, pl
       color,
       model,
       filename: baseAgentName,
+      sourcePath: filePath,
       plugin: sourceName,
       ...background ? { background } : {},
       ...memory ? { memory } : {},
@@ -145738,12 +145814,68 @@ async function loadAgentFromFile(filePath, pluginName, namespace, sourceName, pl
       ...maxTurns !== undefined ? { maxTurns } : {}
     };
   } catch (error41) {
+    if (strict)
+      throw error41;
     logForDebugging2(`Failed to load agent from ${filePath}: ${error41}`, {
       level: "error"
     });
     return null;
   }
 }
+async function loadPluginAgentsFromPlugins(enabled, options2 = {}) {
+  const strict = options2.strict ?? false;
+  const perPluginAgents = await Promise.all(enabled.map(async (plugin) => {
+    const loadedPaths = new Set;
+    const pluginAgents = [];
+    if (plugin.agentsPath) {
+      try {
+        const agents = await loadAgentsFromDirectory(plugin.agentsPath, plugin.name, plugin.source, plugin.path, plugin.dataPath, plugin.manifest, loadedPaths, strict);
+        pluginAgents.push(...agents);
+        if (agents.length > 0) {
+          logForDebugging2(`Loaded ${agents.length} agents from plugin ${plugin.name} default directory`);
+        }
+      } catch (error41) {
+        if (strict)
+          throw error41;
+        logForDebugging2(`Failed to load agents from plugin ${plugin.name} default directory: ${error41}`, { level: "error" });
+      }
+    }
+    if (plugin.agentsPaths) {
+      const pathResults = await Promise.all(plugin.agentsPaths.map(async (agentPath) => {
+        try {
+          const fs2 = getFsImplementation();
+          const stats = await fs2.stat(agentPath);
+          if (stats.isDirectory()) {
+            const agents = await loadAgentsFromDirectory(agentPath, plugin.name, plugin.source, plugin.path, plugin.dataPath, plugin.manifest, loadedPaths, strict);
+            if (agents.length > 0) {
+              logForDebugging2(`Loaded ${agents.length} agents from plugin ${plugin.name} custom path: ${agentPath}`);
+            }
+            return agents;
+          } else if (stats.isFile() && agentPath.endsWith(".md")) {
+            const agent = await loadAgentFromFile(agentPath, plugin.name, [], plugin.source, plugin.path, plugin.dataPath, plugin.manifest, loadedPaths, strict);
+            if (agent) {
+              logForDebugging2(`Loaded agent from plugin ${plugin.name} custom file: ${agentPath}`);
+              return [agent];
+            }
+          }
+          return [];
+        } catch (error41) {
+          if (strict)
+            throw error41;
+          logForDebugging2(`Failed to load agents from plugin ${plugin.name} custom path ${agentPath}: ${error41}`, { level: "error" });
+          return [];
+        }
+      }));
+      for (const agents of pathResults) {
+        pluginAgents.push(...agents);
+      }
+    }
+    return pluginAgents;
+  }));
+  const allAgents = perPluginAgents.flat();
+  logForDebugging2(`Total plugin agents loaded: ${allAgents.length}`);
+  return allAgents;
+}
 function clearPluginAgentCache() {
   loadPluginAgents.cache?.clear?.();
 }
@@ -145766,53 +145898,7 @@ var init_loadPluginAgents = __esm(() => {
     if (errors4.length > 0) {
       logForDebugging2(`Plugin loading errors: ${errors4.map((e) => getPluginErrorMessage(e)).join(", ")}`);
     }
-    const perPluginAgents = await Promise.all(enabled.map(async (plugin) => {
-      const loadedPaths = new Set;
-      const pluginAgents = [];
-      if (plugin.agentsPath) {
-        try {
-          const agents = await loadAgentsFromDirectory(plugin.agentsPath, plugin.name, plugin.source, plugin.path, plugin.manifest, loadedPaths);
-          pluginAgents.push(...agents);
-          if (agents.length > 0) {
-            logForDebugging2(`Loaded ${agents.length} agents from plugin ${plugin.name} default directory`);
-          }
-        } catch (error41) {
-          logForDebugging2(`Failed to load agents from plugin ${plugin.name} default directory: ${error41}`, { level: "error" });
-        }
-      }
-      if (plugin.agentsPaths) {
-        const pathResults = await Promise.all(plugin.agentsPaths.map(async (agentPath) => {
-          try {
-            const fs2 = getFsImplementation();
-            const stats = await fs2.stat(agentPath);
-            if (stats.isDirectory()) {
-              const agents = await loadAgentsFromDirectory(agentPath, plugin.name, plugin.source, plugin.path, plugin.manifest, loadedPaths);
-              if (agents.length > 0) {
-                logForDebugging2(`Loaded ${agents.length} agents from plugin ${plugin.name} custom path: ${agentPath}`);
-              }
-              return agents;
-            } else if (stats.isFile() && agentPath.endsWith(".md")) {
-              const agent = await loadAgentFromFile(agentPath, plugin.name, [], plugin.source, plugin.path, plugin.manifest, loadedPaths);
-              if (agent) {
-                logForDebugging2(`Loaded agent from plugin ${plugin.name} custom file: ${agentPath}`);
-                return [agent];
-              }
-            }
-            return [];
-          } catch (error41) {
-            logForDebugging2(`Failed to load agents from plugin ${plugin.name} custom path ${agentPath}: ${error41}`, { level: "error" });
-            return [];
-          }
-        }));
-        for (const agents of pathResults) {
-          pluginAgents.push(...agents);
-        }
-      }
-      return pluginAgents;
-    }));
-    const allAgents = perPluginAgents.flat();
-    logForDebugging2(`Total plugin agents loaded: ${allAgents.length}`);
-    return allAgents;
+    return loadPluginAgentsFromPlugins(enabled);
   });
 });
 
@@ -244805,7 +244891,7 @@ function getAnthropicEnvMetadata() {
 function getBuildAgeMinutes() {
   if (false)
     ;
-  const buildTime = new Date("2026-08-21T04:07:58.719Z").getTime();
+  const buildTime = new Date("2026-08-28T10:03:59.640Z").getTime();
   if (isNaN(buildTime))
     return;
   return Math.floor((Date.now() - buildTime) / 60000);
@@ -266822,7 +266908,7 @@ function resolvePluginLspEnvironment(config2, plugin, userConfig, _errors) {
   }
   const resolvedEnv = {
     CLAUDE_PLUGIN_ROOT: plugin.path,
-    CLAUDE_PLUGIN_DATA: getPluginDataDir(plugin.source),
+    CLAUDE_PLUGIN_DATA: plugin.dataPath ?? getPluginDataDir(plugin.source),
     ...resolved.env || {}
   };
   for (const [key, value] of Object.entries(resolvedEnv)) {
@@ -270678,14 +270764,14 @@ var init_LSPServerInstance = __esm(() => {
 // src/capabilities/lsp/LSPServerManager.ts
 import * as path12 from "path";
 import { pathToFileURL as pathToFileURL2 } from "url";
-function createLSPServerManager() {
+function createLSPServerManager(explicitServerConfigs) {
   const servers = new Map;
   const extensionMap = new Map;
   const openedFiles = new Map;
   async function initialize3() {
     let serverConfigs;
     try {
-      const result = await getAllLspServers();
+      const result = explicitServerConfigs ? { servers: { ...explicitServerConfigs } } : await getAllLspServers();
       serverConfigs = result.servers;
       logForDebugging2(`[LSP SERVER MANAGER] getAllLspServers returned ${Object.keys(serverConfigs).length} server(s)`);
     } catch (error41) {
@@ -271050,6 +271136,9 @@ var init_passiveFeedback = __esm(() => {
 
 // src/capabilities/lsp/manager.ts
 function getLspServerManager() {
+  const sessionManager = tryGetSessionLspManager();
+  if (sessionManager)
+    return sessionManager;
   if (initializationState === "failed") {
     return;
   }
@@ -271071,8 +271160,6 @@ function getInitializationStatus() {
   return { status: "success" };
 }
 function isLspConnected() {
-  if (initializationState === "failed")
-    return false;
   const manager = getLspServerManager();
   if (!manager)
     return false;
@@ -271170,6 +271257,7 @@ var init_manager = __esm(() => {
   init_log3();
   init_LSPServerManager();
   init_passiveFeedback();
+  init_registries2();
 });
 
 // src/capabilities/tools/shared/teamMemorySync/teamMemSecretGuard.ts
@@ -284046,20 +284134,20 @@ function transformPluginSkillFiles(files) {
   }
   return result;
 }
-async function loadCommandsFromDirectory(commandsPath, pluginName, sourceName, pluginManifest, pluginPath, config2 = { isSkillMode: false }, loadedPaths = new Set) {
+async function loadCommandsFromDirectory(commandsPath, pluginName, sourceName, pluginManifest, pluginPath, config2 = { isSkillMode: false }, loadedPaths = new Set, pluginDataPath, strict = false) {
   const markdownFiles = await collectMarkdownFiles(commandsPath, commandsPath, loadedPaths);
   const processedFiles = transformPluginSkillFiles(markdownFiles);
   const commands = [];
   for (const file2 of processedFiles) {
     const commandName = getCommandNameFromFile(file2.filePath, file2.baseDir, pluginName);
-    const command = createPluginCommand(commandName, file2, sourceName, pluginManifest, pluginPath, isSkillFile(file2.filePath), config2);
+    const command = createPluginCommand(commandName, file2, sourceName, pluginManifest, pluginPath, isSkillFile(file2.filePath), config2, pluginDataPath, strict);
     if (command) {
       commands.push(command);
     }
   }
   return commands;
 }
-function createPluginCommand(commandName, file2, sourceName, pluginManifest, pluginPath, isSkill, config2 = { isSkillMode: false }) {
+function createPluginCommand(commandName, file2, sourceName, pluginManifest, pluginPath, isSkill, config2 = { isSkillMode: false }, pluginDataPath, strict = false) {
   try {
     const { frontmatter, content } = file2;
     const validatedDescription = coerceDescriptionToString(frontmatter.description, commandName);
@@ -284067,10 +284155,12 @@ function createPluginCommand(commandName, file2, sourceName, pluginManifest, plu
     const rawAllowedTools = frontmatter["allowed-tools"];
     const substitutedAllowedTools = typeof rawAllowedTools === "string" ? substitutePluginVariables(rawAllowedTools, {
       path: pluginPath,
-      source: sourceName
+      source: sourceName,
+      dataPath: pluginDataPath
     }) : Array.isArray(rawAllowedTools) ? rawAllowedTools.map((tool) => typeof tool === "string" ? substitutePluginVariables(tool, {
       path: pluginPath,
-      source: sourceName
+      source: sourceName,
+      dataPath: pluginDataPath
     }) : tool) : rawAllowedTools;
     const allowedTools = parseSlashCommandToolsFromFrontmatter(substitutedAllowedTools);
     const argumentHint = frontmatter["argument-hint"];
@@ -284091,6 +284181,7 @@ function createPluginCommand(commandName, file2, sourceName, pluginManifest, plu
     return {
       type: "prompt",
       name: commandName,
+      sourcePath: file2.filePath,
       description,
       hasUserSpecifiedDescription: validatedDescription !== null,
       allowedTools,
@@ -284115,13 +284206,20 @@ function createPluginCommand(commandName, file2, sourceName, pluginManifest, plu
         return displayName || commandName;
       },
       async getPromptForCommand(args, context4) {
-        let finalContent = config2.isSkillMode ? `Base directory for this skill: ${dirname29(file2.filePath)}
+        const sourceContext = [
+          `Source file: ${file2.filePath}`,
+          `Plugin root: ${pluginPath}`,
+          ...config2.isSkillMode ? [`Base directory for this skill: ${dirname29(file2.filePath)}`] : []
+        ];
+        let finalContent = `${sourceContext.join(`
+`)}
 
-${content}` : content;
+${content}`;
         finalContent = substituteArguments(finalContent, args, true, argumentNames);
         finalContent = substitutePluginVariables(finalContent, {
           path: pluginPath,
-          source: sourceName
+          source: sourceName,
+          dataPath: pluginDataPath
         });
         if (pluginManifest.userConfig) {
           finalContent = substituteUserConfigInContent(finalContent, loadPluginOptions(sourceName), pluginManifest.userConfig);
@@ -284152,16 +284250,161 @@ ${content}` : content;
       }
     };
   } catch (error41) {
+    if (strict)
+      throw error41;
     logForDebugging2(`Failed to create command from ${file2.filePath}: ${error41}`, {
       level: "error"
     });
     return null;
   }
 }
+async function loadPluginCommandsFromPlugins(enabled, options2 = {}) {
+  const strict = options2.strict ?? false;
+  const perPluginCommands = await Promise.all(enabled.map(async (plugin) => {
+    const loadedPaths = new Set;
+    const pluginCommands = [];
+    if (plugin.commandsPath) {
+      try {
+        const commands = await loadCommandsFromDirectory(plugin.commandsPath, plugin.name, plugin.source, plugin.manifest, plugin.path, { isSkillMode: false }, loadedPaths, plugin.dataPath, strict);
+        pluginCommands.push(...commands);
+        if (commands.length > 0) {
+          logForDebugging2(`Loaded ${commands.length} commands from plugin ${plugin.name} default directory`);
+        }
+      } catch (error41) {
+        if (strict)
+          throw error41;
+        logForDebugging2(`Failed to load commands from plugin ${plugin.name} default directory: ${error41}`, { level: "error" });
+      }
+    }
+    if (plugin.commandsPaths) {
+      logForDebugging2(`Plugin ${plugin.name} has commandsPaths: ${plugin.commandsPaths.join(", ")}`);
+      const pathResults = await Promise.all(plugin.commandsPaths.map(async (commandPath) => {
+        try {
+          const fs2 = getFsImplementation();
+          const stats = await fs2.stat(commandPath);
+          logForDebugging2(`Checking commandPath ${commandPath} - isDirectory: ${stats.isDirectory()}, isFile: ${stats.isFile()}`);
+          if (stats.isDirectory()) {
+            const commands = await loadCommandsFromDirectory(commandPath, plugin.name, plugin.source, plugin.manifest, plugin.path, { isSkillMode: false }, loadedPaths, plugin.dataPath, strict);
+            if (commands.length > 0) {
+              logForDebugging2(`Loaded ${commands.length} commands from plugin ${plugin.name} custom path: ${commandPath}`);
+            } else {
+              logForDebugging2(`Warning: No commands found in plugin ${plugin.name} custom directory: ${commandPath}. Expected .md files or SKILL.md in subdirectories.`, { level: "warn" });
+            }
+            return commands;
+          } else if (stats.isFile() && commandPath.endsWith(".md")) {
+            if (isDuplicatePath(fs2, commandPath, loadedPaths)) {
+              return [];
+            }
+            const content = await fs2.readFile(commandPath, {
+              encoding: "utf-8"
+            });
+            const { frontmatter, content: markdownContent } = parseFrontmatter(content, commandPath);
+            let commandName;
+            let metadataOverride;
+            if (plugin.commandsMetadata) {
+              for (const [name, metadata] of Object.entries(plugin.commandsMetadata)) {
+                if (metadata.source) {
+                  const fullMetadataPath = join62(plugin.path, metadata.source);
+                  if (commandPath === fullMetadataPath) {
+                    commandName = `${plugin.name}:${name}`;
+                    metadataOverride = metadata;
+                    break;
+                  }
+                }
+              }
+            }
+            if (!commandName) {
+              commandName = `${plugin.name}:${basename16(commandPath).replace(/\.md$/, "")}`;
+            }
+            const finalFrontmatter = metadataOverride ? {
+              ...frontmatter,
+              ...metadataOverride.description && {
+                description: metadataOverride.description
+              },
+              ...metadataOverride.argumentHint && {
+                "argument-hint": metadataOverride.argumentHint
+              },
+              ...metadataOverride.model && {
+                model: metadataOverride.model
+              },
+              ...metadataOverride.allowedTools && {
+                "allowed-tools": metadataOverride.allowedTools.join(",")
+              }
+            } : frontmatter;
+            const file2 = {
+              filePath: commandPath,
+              baseDir: dirname29(commandPath),
+              frontmatter: finalFrontmatter,
+              content: markdownContent
+            };
+            const command = createPluginCommand(commandName, file2, plugin.source, plugin.manifest, plugin.path, false, { isSkillMode: false }, plugin.dataPath, strict);
+            if (command) {
+              logForDebugging2(`Loaded command from plugin ${plugin.name} custom file: ${commandPath}${metadataOverride ? " (with metadata override)" : ""}`);
+              return [command];
+            }
+          }
+          return [];
+        } catch (error41) {
+          if (strict)
+            throw error41;
+          logForDebugging2(`Failed to load commands from plugin ${plugin.name} custom path ${commandPath}: ${error41}`, { level: "error" });
+          return [];
+        }
+      }));
+      for (const commands of pathResults) {
+        pluginCommands.push(...commands);
+      }
+    }
+    if (plugin.commandsMetadata) {
+      for (const [name, metadata] of Object.entries(plugin.commandsMetadata)) {
+        if (metadata.content && !metadata.source) {
+          try {
+            const { frontmatter, content: markdownContent } = parseFrontmatter(metadata.content, `<inline:${plugin.name}:${name}>`);
+            const finalFrontmatter = {
+              ...frontmatter,
+              ...metadata.description && {
+                description: metadata.description
+              },
+              ...metadata.argumentHint && {
+                "argument-hint": metadata.argumentHint
+              },
+              ...metadata.model && {
+                model: metadata.model
+              },
+              ...metadata.allowedTools && {
+                "allowed-tools": metadata.allowedTools.join(",")
+              }
+            };
+            const commandName = `${plugin.name}:${name}`;
+            const file2 = {
+              filePath: `<inline:${commandName}>`,
+              baseDir: plugin.path,
+              frontmatter: finalFrontmatter,
+              content: markdownContent
+            };
+            const command = createPluginCommand(commandName, file2, plugin.source, plugin.manifest, plugin.path, false, { isSkillMode: false }, plugin.dataPath, strict);
+            if (command) {
+              pluginCommands.push(command);
+              logForDebugging2(`Loaded inline content command from plugin ${plugin.name}: ${commandName}`);
+            }
+          } catch (error41) {
+            if (strict)
+              throw error41;
+            logForDebugging2(`Failed to load inline content command ${name} from plugin ${plugin.name}: ${error41}`, { level: "error" });
+          }
+        }
+      }
+    }
+    return pluginCommands;
+  }));
+  const allCommands = perPluginCommands.flat();
+  logForDebugging2(`Total plugin commands loaded: ${allCommands.length}`);
+  return allCommands;
+}
 function clearPluginCommandCache() {
   getPluginCommands.cache?.clear?.();
 }
-async function loadSkillsFromDirectory(skillsPath, pluginName, sourceName, pluginManifest, pluginPath, loadedPaths) {
+async function loadSkillsFromDirectory(skillsPath, pluginName, sourceName, pluginManifest, pluginPath, loadedPaths, pluginDataPath, strict = false) {
   const fs2 = getFsImplementation();
   const skills = [];
   const directSkillPath = join62(skillsPath, "SKILL.md");
@@ -284172,6 +284415,8 @@ async function loadSkillsFromDirectory(skillsPath, pluginName, sourceName, plugi
     });
   } catch (e) {
     if (!isENOENT(e)) {
+      if (strict)
+        throw e;
       logForDebugging2(`Failed to load skill from ${directSkillPath}: ${e}`, {
         level: "error"
       });
@@ -284191,11 +284436,13 @@ async function loadSkillsFromDirectory(skillsPath, pluginName, sourceName, plugi
         frontmatter,
         content: markdownContent
       };
-      const skill = createPluginCommand(skillName, file2, sourceName, pluginManifest, pluginPath, true, { isSkillMode: true });
+      const skill = createPluginCommand(skillName, file2, sourceName, pluginManifest, pluginPath, true, { isSkillMode: true }, pluginDataPath, strict);
       if (skill) {
         skills.push(skill);
       }
     } catch (error41) {
+      if (strict)
+        throw error41;
       logForDebugging2(`Failed to load skill from ${directSkillPath}: ${error41}`, {
         level: "error"
       });
@@ -284207,6 +284454,8 @@ async function loadSkillsFromDirectory(skillsPath, pluginName, sourceName, plugi
     entries = await fs2.readdir(skillsPath);
   } catch (e) {
     if (!isENOENT(e)) {
+      if (strict)
+        throw e;
       logForDebugging2(`Failed to load skills from directory ${skillsPath}: ${e}`, { level: "error" });
     }
     return skills;
@@ -284222,6 +284471,8 @@ async function loadSkillsFromDirectory(skillsPath, pluginName, sourceName, plugi
       content = await fs2.readFile(skillFilePath, { encoding: "utf-8" });
     } catch (e) {
       if (!isENOENT(e)) {
+        if (strict)
+          throw e;
         logForDebugging2(`Failed to load skill from ${skillFilePath}: ${e}`, {
           level: "error"
         });
@@ -284240,16 +284491,61 @@ async function loadSkillsFromDirectory(skillsPath, pluginName, sourceName, plugi
         frontmatter,
         content: markdownContent
       };
-      const skill = createPluginCommand(skillName, file2, sourceName, pluginManifest, pluginPath, true, { isSkillMode: true });
+      const skill = createPluginCommand(skillName, file2, sourceName, pluginManifest, pluginPath, true, { isSkillMode: true }, pluginDataPath, strict);
       if (skill) {
         skills.push(skill);
       }
     } catch (error41) {
+      if (strict)
+        throw error41;
       logForDebugging2(`Failed to load skill from ${skillFilePath}: ${error41}`, { level: "error" });
     }
   }));
   return skills;
 }
+async function loadPluginSkillsFromPlugins(enabled, options2 = {}) {
+  const strict = options2.strict ?? false;
+  const perPluginSkills = await Promise.all(enabled.map(async (plugin) => {
+    const loadedPaths = new Set;
+    const pluginSkills = [];
+    logForDebugging2(`Checking plugin ${plugin.name}: skillsPath=${plugin.skillsPath ? "exists" : "none"}, skillsPaths=${plugin.skillsPaths ? plugin.skillsPaths.length : 0} paths`);
+    if (plugin.skillsPath) {
+      logForDebugging2(`Attempting to load skills from plugin ${plugin.name} default skillsPath: ${plugin.skillsPath}`);
+      try {
+        const skills = await loadSkillsFromDirectory(plugin.skillsPath, plugin.name, plugin.source, plugin.manifest, plugin.path, loadedPaths, plugin.dataPath, strict);
+        pluginSkills.push(...skills);
+        logForDebugging2(`Loaded ${skills.length} skills from plugin ${plugin.name} default directory`);
+      } catch (error41) {
+        if (strict)
+          throw error41;
+        logForDebugging2(`Failed to load skills from plugin ${plugin.name} default directory: ${error41}`, { level: "error" });
+      }
+    }
+    if (plugin.skillsPaths) {
+      logForDebugging2(`Attempting to load skills from plugin ${plugin.name} skillsPaths: ${plugin.skillsPaths.join(", ")}`);
+      const pathResults = await Promise.all(plugin.skillsPaths.map(async (skillPath) => {
+        try {
+          logForDebugging2(`Loading from skillPath: ${skillPath} for plugin ${plugin.name}`);
+          const skills = await loadSkillsFromDirectory(skillPath, plugin.name, plugin.source, plugin.manifest, plugin.path, loadedPaths, plugin.dataPath, strict);
+          logForDebugging2(`Loaded ${skills.length} skills from plugin ${plugin.name} custom path: ${skillPath}`);
+          return skills;
+        } catch (error41) {
+          if (strict)
+            throw error41;
+          logForDebugging2(`Failed to load skills from plugin ${plugin.name} custom path ${skillPath}: ${error41}`, { level: "error" });
+          return [];
+        }
+      }));
+      for (const skills of pathResults) {
+        pluginSkills.push(...skills);
+      }
+    }
+    return pluginSkills;
+  }));
+  const allSkills = perPluginSkills.flat();
+  logForDebugging2(`Total plugin skills loaded: ${allSkills.length}`);
+  return allSkills;
+}
 function clearPluginSkillsCache() {
   getPluginSkills.cache?.clear?.();
 }
@@ -284278,140 +284574,7 @@ var init_loadPluginCommands = __esm(() => {
     if (errors4.length > 0) {
       logForDebugging2(`Plugin loading errors: ${errors4.map((e) => getPluginErrorMessage(e)).join(", ")}`);
     }
-    const perPluginCommands = await Promise.all(enabled.map(async (plugin) => {
-      const loadedPaths = new Set;
-      const pluginCommands = [];
-      if (plugin.commandsPath) {
-        try {
-          const commands = await loadCommandsFromDirectory(plugin.commandsPath, plugin.name, plugin.source, plugin.manifest, plugin.path, { isSkillMode: false }, loadedPaths);
-          pluginCommands.push(...commands);
-          if (commands.length > 0) {
-            logForDebugging2(`Loaded ${commands.length} commands from plugin ${plugin.name} default directory`);
-          }
-        } catch (error41) {
-          logForDebugging2(`Failed to load commands from plugin ${plugin.name} default directory: ${error41}`, { level: "error" });
-        }
-      }
-      if (plugin.commandsPaths) {
-        logForDebugging2(`Plugin ${plugin.name} has commandsPaths: ${plugin.commandsPaths.join(", ")}`);
-        const pathResults = await Promise.all(plugin.commandsPaths.map(async (commandPath) => {
-          try {
-            const fs2 = getFsImplementation();
-            const stats = await fs2.stat(commandPath);
-            logForDebugging2(`Checking commandPath ${commandPath} - isDirectory: ${stats.isDirectory()}, isFile: ${stats.isFile()}`);
-            if (stats.isDirectory()) {
-              const commands = await loadCommandsFromDirectory(commandPath, plugin.name, plugin.source, plugin.manifest, plugin.path, { isSkillMode: false }, loadedPaths);
-              if (commands.length > 0) {
-                logForDebugging2(`Loaded ${commands.length} commands from plugin ${plugin.name} custom path: ${commandPath}`);
-              } else {
-                logForDebugging2(`Warning: No commands found in plugin ${plugin.name} custom directory: ${commandPath}. Expected .md files or SKILL.md in subdirectories.`, { level: "warn" });
-              }
-              return commands;
-            } else if (stats.isFile() && commandPath.endsWith(".md")) {
-              if (isDuplicatePath(fs2, commandPath, loadedPaths)) {
-                return [];
-              }
-              const content = await fs2.readFile(commandPath, {
-                encoding: "utf-8"
-              });
-              const { frontmatter, content: markdownContent } = parseFrontmatter(content, commandPath);
-              let commandName;
-              let metadataOverride;
-              if (plugin.commandsMetadata) {
-                for (const [name, metadata] of Object.entries(plugin.commandsMetadata)) {
-                  if (metadata.source) {
-                    const fullMetadataPath = join62(plugin.path, metadata.source);
-                    if (commandPath === fullMetadataPath) {
-                      commandName = `${plugin.name}:${name}`;
-                      metadataOverride = metadata;
-                      break;
-                    }
-                  }
-                }
-              }
-              if (!commandName) {
-                commandName = `${plugin.name}:${basename16(commandPath).replace(/\.md$/, "")}`;
-              }
-              const finalFrontmatter = metadataOverride ? {
-                ...frontmatter,
-                ...metadataOverride.description && {
-                  description: metadataOverride.description
-                },
-                ...metadataOverride.argumentHint && {
-                  "argument-hint": metadataOverride.argumentHint
-                },
-                ...metadataOverride.model && {
-                  model: metadataOverride.model
-                },
-                ...metadataOverride.allowedTools && {
-                  "allowed-tools": metadataOverride.allowedTools.join(",")
-                }
-              } : frontmatter;
-              const file2 = {
-                filePath: commandPath,
-                baseDir: dirname29(commandPath),
-                frontmatter: finalFrontmatter,
-                content: markdownContent
-              };
-              const command = createPluginCommand(commandName, file2, plugin.source, plugin.manifest, plugin.path, false);
-              if (command) {
-                logForDebugging2(`Loaded command from plugin ${plugin.name} custom file: ${commandPath}${metadataOverride ? " (with metadata override)" : ""}`);
-                return [command];
-              }
-            }
-            return [];
-          } catch (error41) {
-            logForDebugging2(`Failed to load commands from plugin ${plugin.name} custom path ${commandPath}: ${error41}`, { level: "error" });
-            return [];
-          }
-        }));
-        for (const commands of pathResults) {
-          pluginCommands.push(...commands);
-        }
-      }
-      if (plugin.commandsMetadata) {
-        for (const [name, metadata] of Object.entries(plugin.commandsMetadata)) {
-          if (metadata.content && !metadata.source) {
-            try {
-              const { frontmatter, content: markdownContent } = parseFrontmatter(metadata.content, `<inline:${plugin.name}:${name}>`);
-              const finalFrontmatter = {
-                ...frontmatter,
-                ...metadata.description && {
-                  description: metadata.description
-                },
-                ...metadata.argumentHint && {
-                  "argument-hint": metadata.argumentHint
-                },
-                ...metadata.model && {
-                  model: metadata.model
-                },
-                ...metadata.allowedTools && {
-                  "allowed-tools": metadata.allowedTools.join(",")
-                }
-              };
-              const commandName = `${plugin.name}:${name}`;
-              const file2 = {
-                filePath: `<inline:${commandName}>`,
-                baseDir: plugin.path,
-                frontmatter: finalFrontmatter,
-                content: markdownContent
-              };
-              const command = createPluginCommand(commandName, file2, plugin.source, plugin.manifest, plugin.path, false);
-              if (command) {
-                pluginCommands.push(command);
-                logForDebugging2(`Loaded inline content command from plugin ${plugin.name}: ${commandName}`);
-              }
-            } catch (error41) {
-              logForDebugging2(`Failed to load inline content command ${name} from plugin ${plugin.name}: ${error41}`, { level: "error" });
-            }
-          }
-        }
-      }
-      return pluginCommands;
-    }));
-    const allCommands = perPluginCommands.flat();
-    logForDebugging2(`Total plugin commands loaded: ${allCommands.length}`);
-    return allCommands;
+    return loadPluginCommandsFromPlugins(enabled);
   });
   getPluginSkills = memoize_default(async () => {
     if (isBareMode() && getInlinePlugins().length === 0) {
@@ -284422,48 +284585,14 @@ var init_loadPluginCommands = __esm(() => {
       logForDebugging2(`Plugin loading errors: ${errors4.map((e) => getPluginErrorMessage(e)).join(", ")}`);
     }
     logForDebugging2(`getPluginSkills: Processing ${enabled.length} enabled plugins`);
-    const perPluginSkills = await Promise.all(enabled.map(async (plugin) => {
-      const loadedPaths = new Set;
-      const pluginSkills = [];
-      logForDebugging2(`Checking plugin ${plugin.name}: skillsPath=${plugin.skillsPath ? "exists" : "none"}, skillsPaths=${plugin.skillsPaths ? plugin.skillsPaths.length : 0} paths`);
-      if (plugin.skillsPath) {
-        logForDebugging2(`Attempting to load skills from plugin ${plugin.name} default skillsPath: ${plugin.skillsPath}`);
-        try {
-          const skills = await loadSkillsFromDirectory(plugin.skillsPath, plugin.name, plugin.source, plugin.manifest, plugin.path, loadedPaths);
-          pluginSkills.push(...skills);
-          logForDebugging2(`Loaded ${skills.length} skills from plugin ${plugin.name} default directory`);
-        } catch (error41) {
-          logForDebugging2(`Failed to load skills from plugin ${plugin.name} default directory: ${error41}`, { level: "error" });
-        }
-      }
-      if (plugin.skillsPaths) {
-        logForDebugging2(`Attempting to load skills from plugin ${plugin.name} skillsPaths: ${plugin.skillsPaths.join(", ")}`);
-        const pathResults = await Promise.all(plugin.skillsPaths.map(async (skillPath) => {
-          try {
-            logForDebugging2(`Loading from skillPath: ${skillPath} for plugin ${plugin.name}`);
-            const skills = await loadSkillsFromDirectory(skillPath, plugin.name, plugin.source, plugin.manifest, plugin.path, loadedPaths);
-            logForDebugging2(`Loaded ${skills.length} skills from plugin ${plugin.name} custom path: ${skillPath}`);
-            return skills;
-          } catch (error41) {
-            logForDebugging2(`Failed to load skills from plugin ${plugin.name} custom path ${skillPath}: ${error41}`, { level: "error" });
-            return [];
-          }
-        }));
-        for (const skills of pathResults) {
-          pluginSkills.push(...skills);
-        }
-      }
-      return pluginSkills;
-    }));
-    const allSkills = perPluginSkills.flat();
-    logForDebugging2(`Total plugin skills loaded: ${allSkills.length}`);
-    return allSkills;
+    return loadPluginSkillsFromPlugins(enabled);
   });
 });
 
 // src/capabilities/plugins/loadPluginHooks.ts
 var exports_loadPluginHooks = {};
 __export(exports_loadPluginHooks, {
+  buildExplicitPluginHookMatchers: () => buildExplicitPluginHookMatchers,
   clearPluginHookCache: () => clearPluginHookCache,
   getPluginAffectingSettingsSnapshot: () => getPluginAffectingSettingsSnapshot,
   loadPluginHooks: () => loadPluginHooks,
@@ -284471,6 +284600,33 @@ __export(exports_loadPluginHooks, {
   resetHotReloadState: () => resetHotReloadState,
   setupPluginHookHotReload: () => setupPluginHookHotReload
 });
+function buildExplicitPluginHookMatchers(plugins) {
+  const result = {};
+  for (const event of PLUGIN_HOOK_EVENTS)
+    result[event] = [];
+  for (const plugin of plugins) {
+    if (!plugin.hooksConfig)
+      continue;
+    for (const [event, matchers] of Object.entries(plugin.hooksConfig)) {
+      if (!PLUGIN_HOOK_EVENTS.includes(event))
+        continue;
+      const hookEvent = event;
+      const target = result[hookEvent];
+      for (const matcher of matchers ?? []) {
+        if (matcher.hooks.length === 0)
+          continue;
+        target.push({
+          matcher: matcher.matcher,
+          hooks: matcher.hooks,
+          pluginRoot: plugin.path,
+          pluginName: plugin.name,
+          pluginId: plugin.source
+        });
+      }
+    }
+  }
+  return result;
+}
 function convertPluginHooksToMatchers(plugin) {
   const pluginMatchers = {
     PreToolUse: [],
@@ -284579,7 +284735,7 @@ function setupPluginHookHotReload() {
     }
   });
 }
-var hotReloadSubscribed = false, lastPluginSettingsSnapshot, loadPluginHooks;
+var hotReloadSubscribed = false, lastPluginSettingsSnapshot, PLUGIN_HOOK_EVENTS, loadPluginHooks;
 var init_loadPluginHooks = __esm(() => {
   init_memoize();
   init_state2();
@@ -284588,6 +284744,35 @@ var init_loadPluginHooks = __esm(() => {
   init_settings2();
   init_slowOperations();
   init_pluginLoader();
+  PLUGIN_HOOK_EVENTS = [
+    "PreToolUse",
+    "PostToolUse",
+    "PostToolUseFailure",
+    "PermissionDenied",
+    "Notification",
+    "UserPromptSubmit",
+    "SessionStart",
+    "SessionEnd",
+    "Stop",
+    "StopFailure",
+    "SubagentStart",
+    "SubagentStop",
+    "PreCompact",
+    "PostCompact",
+    "PermissionRequest",
+    "Setup",
+    "TeammateIdle",
+    "TaskCreated",
+    "TaskCompleted",
+    "Elicitation",
+    "ElicitationResult",
+    "ConfigChange",
+    "WorktreeCreate",
+    "WorktreeRemove",
+    "InstructionsLoaded",
+    "CwdChanged",
+    "FileChanged"
+  ];
   loadPluginHooks = memoize_default(async () => {
     const { enabled } = await loadAllPluginsCacheOnly();
     const allPluginHooks = {
@@ -284638,16 +284823,16 @@ var init_loadPluginHooks = __esm(() => {
 
 // src/capabilities/plugins/loadPluginOutputStyles.ts
 import { basename as basename17 } from "path";
-async function loadOutputStylesFromDirectory(outputStylesPath, pluginName, loadedPaths) {
+async function loadOutputStylesFromDirectory(outputStylesPath, pluginName, sourceName, loadedPaths, strict = false) {
   const styles4 = [];
   await walkPluginMarkdown(outputStylesPath, async (fullPath) => {
-    const style = await loadOutputStyleFromFile(fullPath, pluginName, loadedPaths);
+    const style = await loadOutputStyleFromFile(fullPath, pluginName, sourceName, loadedPaths, strict);
     if (style)
       styles4.push(style);
   }, { logLabel: "output-styles" });
   return styles4;
 }
-async function loadOutputStyleFromFile(filePath, pluginName, loadedPaths) {
+async function loadOutputStyleFromFile(filePath, pluginName, sourceName, loadedPaths, strict = false) {
   const fs2 = getFsImplementation();
   if (isDuplicatePath(fs2, filePath, loadedPaths)) {
     return null;
@@ -284666,15 +284851,65 @@ async function loadOutputStyleFromFile(filePath, pluginName, loadedPaths) {
       description,
       prompt: markdownContent.trim(),
       source: "plugin",
+      plugin: sourceName,
       forceForPlugin
     };
   } catch (error41) {
+    if (strict)
+      throw error41;
     logForDebugging2(`Failed to load output style from ${filePath}: ${error41}`, {
       level: "error"
     });
     return null;
   }
 }
+async function loadPluginOutputStylesFromPlugins(enabled, options2 = {}) {
+  const strict = options2.strict ?? false;
+  const allStyles = [];
+  for (const plugin of enabled) {
+    const loadedPaths = new Set;
+    if (plugin.outputStylesPath) {
+      try {
+        const styles4 = await loadOutputStylesFromDirectory(plugin.outputStylesPath, plugin.name, plugin.source, loadedPaths, strict);
+        allStyles.push(...styles4);
+        if (styles4.length > 0) {
+          logForDebugging2(`Loaded ${styles4.length} output styles from plugin ${plugin.name} default directory`);
+        }
+      } catch (error41) {
+        if (strict)
+          throw error41;
+        logForDebugging2(`Failed to load output styles from plugin ${plugin.name} default directory: ${error41}`, { level: "error" });
+      }
+    }
+    if (plugin.outputStylesPaths) {
+      for (const stylePath of plugin.outputStylesPaths) {
+        try {
+          const fs2 = getFsImplementation();
+          const stats = await fs2.stat(stylePath);
+          if (stats.isDirectory()) {
+            const styles4 = await loadOutputStylesFromDirectory(stylePath, plugin.name, plugin.source, loadedPaths, strict);
+            allStyles.push(...styles4);
+            if (styles4.length > 0) {
+              logForDebugging2(`Loaded ${styles4.length} output styles from plugin ${plugin.name} custom path: ${stylePath}`);
+            }
+          } else if (stats.isFile() && stylePath.endsWith(".md")) {
+            const style = await loadOutputStyleFromFile(stylePath, plugin.name, plugin.source, loadedPaths, strict);
+            if (style) {
+              allStyles.push(style);
+              logForDebugging2(`Loaded output style from plugin ${plugin.name} custom file: ${stylePath}`);
+            }
+          }
+        } catch (error41) {
+          if (strict)
+            throw error41;
+          logForDebugging2(`Failed to load output styles from plugin ${plugin.name} custom path ${stylePath}: ${error41}`, { level: "error" });
+        }
+      }
+    }
+  }
+  logForDebugging2(`Total plugin output styles loaded: ${allStyles.length}`);
+  return allStyles;
+}
 function clearPluginOutputStyleCache() {
   loadPluginOutputStyles.cache?.clear?.();
 }
@@ -284689,49 +284924,10 @@ var init_loadPluginOutputStyles = __esm(() => {
   init_walkPluginMarkdown();
   loadPluginOutputStyles = memoize_default(async () => {
     const { enabled, errors: errors4 } = await loadAllPluginsCacheOnly();
-    const allStyles = [];
     if (errors4.length > 0) {
       logForDebugging2(`Plugin loading errors: ${errors4.map((e) => getPluginErrorMessage(e)).join(", ")}`);
     }
-    for (const plugin of enabled) {
-      const loadedPaths = new Set;
-      if (plugin.outputStylesPath) {
-        try {
-          const styles4 = await loadOutputStylesFromDirectory(plugin.outputStylesPath, plugin.name, loadedPaths);
-          allStyles.push(...styles4);
-          if (styles4.length > 0) {
-            logForDebugging2(`Loaded ${styles4.length} output styles from plugin ${plugin.name} default directory`);
-          }
-        } catch (error41) {
-          logForDebugging2(`Failed to load output styles from plugin ${plugin.name} default directory: ${error41}`, { level: "error" });
-        }
-      }
-      if (plugin.outputStylesPaths) {
-        for (const stylePath of plugin.outputStylesPaths) {
-          try {
-            const fs2 = getFsImplementation();
-            const stats = await fs2.stat(stylePath);
-            if (stats.isDirectory()) {
-              const styles4 = await loadOutputStylesFromDirectory(stylePath, plugin.name, loadedPaths);
-              allStyles.push(...styles4);
-              if (styles4.length > 0) {
-                logForDebugging2(`Loaded ${styles4.length} output styles from plugin ${plugin.name} custom path: ${stylePath}`);
-              }
-            } else if (stats.isFile() && stylePath.endsWith(".md")) {
-              const style = await loadOutputStyleFromFile(stylePath, plugin.name, loadedPaths);
-              if (style) {
-                allStyles.push(style);
-                logForDebugging2(`Loaded output style from plugin ${plugin.name} custom file: ${stylePath}`);
-              }
-            }
-          } catch (error41) {
-            logForDebugging2(`Failed to load output styles from plugin ${plugin.name} custom path ${stylePath}: ${error41}`, { level: "error" });
-          }
-        }
-      }
-    }
-    logForDebugging2(`Total plugin output styles loaded: ${allStyles.length}`);
-    return allStyles;
+    return loadPluginOutputStylesFromPlugins(enabled);
   });
 });
 
@@ -287606,7 +287802,7 @@ var init_pluginInstallationHelpers = __esm(() => {
 });
 
 // src/capabilities/plugins/pluginLoader.ts
-import { basename as basename20, dirname as dirname35, join as join69, relative as relative11, resolve as resolve29, sep as sep20 } from "path";
+import { basename as basename20, dirname as dirname35, isAbsolute as isAbsolute21, join as join69, relative as relative11, resolve as resolve29, sep as sep20 } from "path";
 function getPluginCachePath() {
   return join69(getPluginsDirectory(), "cache");
 }
@@ -288103,14 +288299,31 @@ async function loadPluginHooks2(hooksConfigPath, pluginName) {
   return validatedPluginHooks.hooks;
 }
 async function validatePluginPaths(relPaths, pluginPath, pluginName, source, component, componentLabel, contextLabel, errors4) {
+  const fs2 = getFsImplementation();
+  const pluginRoot = await fs2.realpath(pluginPath);
   const checks4 = await Promise.all(relPaths.map(async (relPath) => {
-    const fullPath = join69(pluginPath, relPath);
-    return { relPath, fullPath, exists: await pathExists(fullPath) };
+    const fullPath = resolve29(pluginPath, relPath);
+    if (!await pathExists(fullPath)) {
+      return { relPath, fullPath, exists: false, escaped: false };
+    }
+    const realPath = await fs2.realpath(fullPath);
+    const pathFromRoot = relative11(pluginRoot, realPath);
+    const escaped = pathFromRoot === ".." || pathFromRoot.startsWith(`..${sep20}`) || isAbsolute21(pathFromRoot);
+    return { relPath, fullPath, exists: true, escaped };
   }));
   const validPaths = [];
-  for (const { relPath, fullPath, exists } of checks4) {
-    if (exists) {
+  for (const { relPath, fullPath, exists, escaped } of checks4) {
+    if (exists && !escaped) {
       validPaths.push(fullPath);
+    } else if (escaped) {
+      errors4.push({
+        type: "component-load-failed",
+        source,
+        plugin: pluginName,
+        path: fullPath,
+        component,
+        reason: "Path resolves outside the plugin root"
+      });
     } else {
       logForDebugging2(`${componentLabel} path ${relPath} ${contextLabel} not found at ${fullPath} for ${pluginName}`, { level: "warn" });
       logError2(new Error(`Plugin component file not found: ${fullPath} for ${pluginName}`));
@@ -305546,7 +305759,7 @@ var builders = null;
 import {
   basename as basename22,
   dirname as dirname39,
-  isAbsolute as isAbsolute21,
+  isAbsolute as isAbsolute22,
   join as join78,
   sep as pathSep2,
   relative as relative13
@@ -306029,8 +306242,8 @@ function activateConditionalSkillsForPaths(filePaths, cwd) {
     }
     const skillIgnore = import_ignore2.default().add(skill.paths);
     for (const filePath of filePaths) {
-      const relativePath = isAbsolute21(filePath) ? relative13(cwd, filePath) : filePath;
-      if (!relativePath || relativePath.startsWith("..") || isAbsolute21(relativePath)) {
+      const relativePath = isAbsolute22(filePath) ? relative13(cwd, filePath) : filePath;
+      if (!relativePath || relativePath.startsWith("..") || isAbsolute22(relativePath)) {
         continue;
       }
       if (skillIgnore.ignores(relativePath)) {
@@ -342619,14 +342832,14 @@ var init_measure_text = __esm(() => {
 });
 
 // src/cli/ink/node-cache.ts
-function addPendingClear(parent, rect, isAbsolute22) {
+function addPendingClear(parent, rect, isAbsolute23) {
   const existing = pendingClears.get(parent);
   if (existing) {
     existing.push(rect);
   } else {
     pendingClears.set(parent, [rect]);
   }
-  if (isAbsolute22) {
+  if (isAbsolute23) {
     absoluteNodeRemoved = true;
   }
 }
@@ -343008,17 +343221,17 @@ function collectRemovedRects(parent, removed, underAbsolute = false) {
   if (!removed || removed.nodeName === "#text")
     return;
   const elem = removed;
-  const isAbsolute22 = underAbsolute || elem.style?.position === "absolute";
+  const isAbsolute23 = underAbsolute || elem.style?.position === "absolute";
   const cached3 = nodeCache.get(elem);
   if (cached3) {
-    addPendingClear(parent, cached3, isAbsolute22);
+    addPendingClear(parent, cached3, isAbsolute23);
     nodeCache.delete(elem);
   }
   const childNodes = Array.isArray(elem.childNodes) ? [...elem.childNodes] : [];
   for (const child of childNodes) {
     if (!child)
       continue;
-    collectRemovedRects(parent, child, isAbsolute22);
+    collectRemovedRects(parent, child, isAbsolute23);
   }
 }
 function stylesEqual(a2, b) {
@@ -349480,16 +349693,16 @@ function renderChildren(node, output, offsetX, offsetY, hasRemovedChild, prevScr
     }
     const childElem = childNode;
     const wasDirty = childElem.dirty;
-    const isAbsolute22 = childElem.style.position === "absolute";
+    const isAbsolute23 = childElem.style.position === "absolute";
     renderNodeToOutput(childElem, output, {
       offsetX,
       offsetY,
       prevScreen: hasRemovedChild || seenDirtyChild ? undefined : prevScreen,
-      skipSelfBlit: seenDirtyClipped && isAbsolute22 && !childElem.style.opaque && childElem.style.backgroundColor === undefined,
+      skipSelfBlit: seenDirtyClipped && isAbsolute23 && !childElem.style.opaque && childElem.style.backgroundColor === undefined,
       inheritedBackgroundColor
     });
     if (wasDirty && !seenDirtyChild) {
-      if (!clipsBothAxes(childElem) || isAbsolute22) {
+      if (!clipsBothAxes(childElem) || isAbsolute23) {
         seenDirtyChild = true;
       } else {
         seenDirtyClipped = true;
@@ -353657,7 +353870,7 @@ var init_ink3 = __esm(() => {
 
 // src/capabilities/imagePaste.ts
 import { randomBytes as randomBytes12 } from "crypto";
-import { basename as basename27, extname as extname8, isAbsolute as isAbsolute22, join as join85 } from "path";
+import { basename as basename27, extname as extname8, isAbsolute as isAbsolute23, join as join85 } from "path";
 function buildLinuxClipboardCheckCommand() {
   const mimePattern = LINUX_CLIPBOARD_IMAGE_MIME_TYPES.map((mimeType) => mimeType.replace("/", "\\/")).join("|");
   return `xclip -selection clipboard -t TARGETS -o 2>/dev/null | grep -E "${mimePattern}" || wl-paste -l 2>/dev/null | grep -E "${mimePattern}"`;
@@ -353804,7 +354017,7 @@ async function tryReadImageFromPath(text) {
   const imagePath = cleanedPath;
   let imageBuffer;
   try {
-    if (isAbsolute22(imagePath)) {
+    if (isAbsolute23(imagePath)) {
       imageBuffer = getFsImplementation().readFileBytesSync(imagePath);
     } else {
       const clipboardPath = await getImagePathFromClipboard();
@@ -482433,7 +482646,7 @@ var init_usePluginAutoupdateNotification = __esm(() => {
 });
 
 // src/capabilities/plugins/reconciler.ts
-import { isAbsolute as isAbsolute23, resolve as resolve37 } from "path";
+import { isAbsolute as isAbsolute24, resolve as resolve37 } from "path";
 function diffMarketplaces(declared, materialized, opts) {
   const missing = [];
   const sourceChanged = [];
@@ -482541,7 +482754,7 @@ async function reconcileMarketplaces(opts) {
   return { installed, updated, failed, upToDate: diff2.upToDate, skipped };
 }
 function normalizeSource(source, projectRoot) {
-  if ((source.source === "directory" || source.source === "file") && !isAbsolute23(source.path)) {
+  if ((source.source === "directory" || source.source === "file") && !isAbsolute24(source.path)) {
     const base2 = projectRoot ?? getOriginalCwd();
     const canonicalRoot = findCanonicalGitRoot(base2);
     return {
@@ -492185,7 +492398,7 @@ function buildPrimarySection() {
   }, undefined, false, undefined, this);
   return [{
     label: "Version",
-    value: "0.4.22"
+    value: "0.4.23"
   }, {
     label: "Session name",
     value: nameValue
@@ -540327,7 +540540,7 @@ var init_bridge_kick = __esm(() => {
 var call58 = async () => {
   return {
     type: "text",
-    value: `${"99.0.0"} (built ${"2026-08-21T04:07:58.719Z"})`
+    value: `${"99.0.0"} (built ${"2026-08-28T10:03:59.640Z"})`
   };
 }, version2, version_default;
 var init_version = __esm(() => {
@@ -553010,7 +553223,7 @@ __export(exports_UI12, {
   renderToolUseRejectedMessage: () => renderToolUseRejectedMessage14,
   userFacingName: () => userFacingName11
 });
-import { isAbsolute as isAbsolute24, relative as relative31, resolve as resolve41 } from "path";
+import { isAbsolute as isAbsolute25, relative as relative31, resolve as resolve41 } from "path";
 function countLines(content) {
   const parts = content.split(EOL5);
   return content.endsWith(EOL5) ? parts.length - 1 : parts.length;
@@ -553334,7 +553547,7 @@ function WriteRejectionBody(t0) {
 }
 async function loadRejectionDiff2(filePath, content) {
   try {
-    const fullFilePath = isAbsolute24(filePath) ? filePath : resolve41(getCwd2(), filePath);
+    const fullFilePath = isAbsolute25(filePath) ? filePath : resolve41(getCwd2(), filePath);
     const handle = await openForScan(fullFilePath);
     if (handle === null)
       return {
@@ -558094,7 +558307,7 @@ function WelcomeV2() {
             dimColor: true,
             children: [
               "v",
-              "0.4.22",
+              "0.4.23",
               " "
             ]
           }, undefined, true, undefined, this)
@@ -558294,7 +558507,7 @@ function WelcomeV2() {
           dimColor: true,
           children: [
             "v",
-            "0.4.22",
+            "0.4.23",
             " "
           ]
         }, undefined, true, undefined, this)
@@ -558520,7 +558733,7 @@ function AppleTerminalWelcomeV2(t0) {
         dimColor: true,
         children: [
           "v",
-          "0.4.22",
+          "0.4.23",
           " "
         ]
       }, undefined, true, undefined, this);
@@ -558774,7 +558987,7 @@ function AppleTerminalWelcomeV2(t0) {
       dimColor: true,
       children: [
         "v",
-        "0.4.22",
+        "0.4.23",
         " "
       ]
     }, undefined, true, undefined, this);
@@ -579759,7 +579972,7 @@ Usage: claude --remote "your task description"`, () => gracefulShutdown(1));
         pendingHookMessages
       }, renderAndRun);
     }
-  }).version("0.4.22 (OpenCow)", "-v, --version", "Output the version number");
+  }).version("0.4.23 (OpenCow)", "-v, --version", "Output the version number");
   program2.option("-w, --worktree [name]", "Create a new git worktree for this session (optionally specify a name)");
   program2.option("--tmux", "Create a tmux session for the worktree (requires --worktree). Uses iTerm2 native panes when available; use --tmux=classic for traditional tmux.");
   if (canUserConfigureAdvisor()) {
@@ -580404,7 +580617,7 @@ if (false) {}
 async function main2() {
   const args = process.argv.slice(2);
   if (args.length === 1 && (args[0] === "--version" || args[0] === "-v" || args[0] === "-V")) {
-    console.log(`${"0.4.22"} (OpenCow)`);
+    console.log(`${"0.4.23"} (OpenCow)`);
     return;
   }
   if (args.includes("--provider")) {
@@ -580522,4 +580735,4 @@ async function main2() {
 }
 main2();
 
-//# debugId=42468A73C022880964756E2164756E21
+//# debugId=76BE00AA5948715464756E2164756E21