@orchid-labs/pluxx 0.1.13 → 0.1.14

package/dist/cli/index.js

@@ -85,7 +85,7 @@ var require_src = __commonJS({
 });
 
 // src/cli/index.ts
-import { readFileSync as readFileSync19 } from "fs";
+import { readFileSync as readFileSync20 } from "fs";
 
 // src/config/load.ts
 import { resolve, extname, dirname } from "path";
@@ -4462,10 +4462,20 @@ var McpServerSchema = external_exports.preprocess(
   external_exports.discriminatedUnion("transport", [McpServerHttpSchema, McpServerSseSchema, McpServerStdioSchema])
 );
 var HookEntrySchema = external_exports.object({
-  type: external_exports.enum(["command", "prompt"]).default("command"),
+  type: external_exports.enum(["command", "http", "mcp_tool", "prompt", "agent"]).default("command"),
   command: external_exports.string().optional(),
   prompt: external_exports.string().optional(),
   model: external_exports.string().optional(),
+  url: external_exports.string().url().optional(),
+  headers: external_exports.record(external_exports.string(), external_exports.string()).optional(),
+  allowedEnvVars: external_exports.array(external_exports.string()).optional(),
+  server: external_exports.string().optional(),
+  tool: external_exports.string().optional(),
+  input: external_exports.record(external_exports.string(), external_exports.unknown()).optional(),
+  if: external_exports.string().optional(),
+  async: external_exports.boolean().optional(),
+  asyncRewake: external_exports.boolean().optional(),
+  shell: external_exports.enum(["bash"]).optional(),
   timeout: external_exports.number().optional(),
   matcher: external_exports.union([external_exports.string(), external_exports.record(external_exports.string(), external_exports.unknown())]).optional(),
   failClosed: external_exports.boolean().optional(),
@@ -4478,11 +4488,34 @@ var HookEntrySchema = external_exports.object({
       message: "Command hooks require a command."
     });
   }
-  if (entry.type === "prompt" && !entry.prompt) {
+  if (entry.type === "http" && !entry.url) {
+    ctx.addIssue({
+      code: external_exports.ZodIssueCode.custom,
+      path: ["url"],
+      message: "HTTP hooks require a url."
+    });
+  }
+  if (entry.type === "mcp_tool") {
+    if (!entry.server) {
+      ctx.addIssue({
+        code: external_exports.ZodIssueCode.custom,
+        path: ["server"],
+        message: "MCP tool hooks require a server."
+      });
+    }
+    if (!entry.tool) {
+      ctx.addIssue({
+        code: external_exports.ZodIssueCode.custom,
+        path: ["tool"],
+        message: "MCP tool hooks require a tool."
+      });
+    }
+  }
+  if ((entry.type === "prompt" || entry.type === "agent") && !entry.prompt) {
     ctx.addIssue({
       code: external_exports.ZodIssueCode.custom,
       path: ["prompt"],
-      message: "Prompt hooks require a prompt."
+      message: `${entry.type === "agent" ? "Agent" : "Prompt"} hooks require a prompt.`
     });
   }
 });
@@ -4896,7 +4929,7 @@ async function loadConfig(dir = process.cwd()) {
 
 // src/generators/index.ts
 import { rmSync, mkdirSync as mkdirSync3 } from "fs";
-import { resolve as resolve10, relative as relative6 } from "path";
+import { resolve as resolve11, relative as relative6 } from "path";
 
 // src/generators/base.ts
 import { resolve as resolve4, join, relative } from "path";
@@ -4910,6 +4943,7 @@ var CompilerIntentSkillPolicySchema = external_exports.object({
   skillDir: external_exports.string(),
   title: external_exports.string(),
   description: external_exports.string().optional(),
+  sourceFrontmatter: external_exports.record(external_exports.unknown()).optional(),
   source: external_exports.object({
     kind: external_exports.literal("claude-allowed-tools"),
     platform: external_exports.literal("claude-code").default("claude-code")
@@ -5175,14 +5209,28 @@ var Generator = class {
 };
 
 // src/generators/shared/claude-family.ts
-import { existsSync as existsSync6 } from "fs";
-import { resolve as resolve6 } from "path";
+import { resolve as resolve7 } from "path";
 
 // src/hook-translation-registry.ts
 var HOOK_PLATFORM_REGISTRY = {
   "claude-code": {
     fields: {
-      prompt: { mode: "drop" },
+      prompt: {
+        mode: "preserve",
+        supportedEvents: [
+          "PermissionRequest",
+          "PostToolBatch",
+          "PostToolUse",
+          "PostToolUseFailure",
+          "PreToolUse",
+          "Stop",
+          "SubagentStop",
+          "TaskCompleted",
+          "TaskCreated",
+          "UserPromptExpansion",
+          "UserPromptSubmit"
+        ]
+      },
       matcher: { mode: "preserve" },
       failClosed: { mode: "drop" },
       loop_limit: { mode: "drop" }
@@ -5197,8 +5245,8 @@ var HOOK_PLATFORM_REGISTRY = {
     }
   },
   codex: {
-    supportedEvents: ["SessionStart", "PreToolUse", "PostToolUse", "UserPromptSubmit", "Stop"],
-    unsupportedEventReason: "Codex currently documents only SessionStart, PreToolUse, PostToolUse, UserPromptSubmit, and Stop for hook configuration.",
+    supportedEvents: ["SessionStart", "PreToolUse", "PermissionRequest", "PostToolUse", "UserPromptSubmit", "Stop"],
+    unsupportedEventReason: "Codex currently documents only SessionStart, PreToolUse, PermissionRequest, PostToolUse, UserPromptSubmit, and Stop for hook configuration.",
     fields: {
       prompt: { mode: "drop" },
       matcher: { mode: "preserve" },
@@ -5304,7 +5352,7 @@ function warnDroppedHookFields(platform, event, entries) {
   const hasMatcher = entries.some((entry) => entry.matcher !== void 0);
   const hasFailClosed = entries.some((entry) => entry.failClosed !== void 0);
   const hasLoopLimit = entries.some((entry) => entry.loop_limit !== void 0);
-  if (hasPromptHooks) {
+  if (hasPromptHooks && !isHookFieldPreserved(platform, "prompt", event)) {
     console.warn(
       `[pluxx] ${platform} generator dropped unsupported prompt-based hook for event "${event}".`
     );
@@ -5675,7 +5723,7 @@ function getEnabledRuntimeReadinessBindings(capability, plan) {
   });
 }
 var NAMED_PROMPT_TARGET_NOTE = "Named `skills` / `commands` readiness targets currently translate through prompt-entry gating with best-effort matching because the core four do not share one exact per-skill or per-command runtime interception surface.";
-var CODEX_EXTERNAL_NOTE = "Codex readiness currently translates into generated hook/config guidance rather than an enforced plugin-bundled runtime surface.";
+var CODEX_EXTERNAL_NOTE = "Codex readiness now bundles translated hooks in the plugin, but Pluxx still emits `.codex/readiness.generated.json` and `.codex/hooks.generated.json` companion guidance because some Codex runtimes still gate hook activation behind `codex_hooks`.";
 function getRuntimeReadinessNamedPromptTargetNote() {
   return NAMED_PROMPT_TARGET_NOTE;
 }
@@ -5744,7 +5792,7 @@ function getRuntimeReadinessCapability(platform, pluginRootVar = "PLUGIN_ROOT")
         bundleEnforced: false,
         namedPromptTargetScope: "best-effort",
         scriptPath: ".codex/pluxx-readiness.mjs",
-        companionArtifacts: [".codex/readiness.generated.json", ".codex/hooks.generated.json"],
+        companionArtifacts: [".codex/readiness.generated.json", "hooks/hooks.json", ".codex/hooks.generated.json"],
         bindings: [
           {
             gate: "session-start",
@@ -5794,9 +5842,37 @@ function getRuntimeReadinessCapability(platform, pluginRootVar = "PLUGIN_ROOT")
   }
 }
 
+// src/instructions.ts
+import { existsSync as existsSync5, readFileSync as readFileSync2 } from "fs";
+import { resolve as resolve5 } from "path";
+function resolveInstructionsPath(rootDir, config) {
+  if (!config.instructions) return null;
+  const instructionsPath = resolve5(rootDir, config.instructions);
+  return existsSync5(instructionsPath) ? instructionsPath : null;
+}
+async function readInstructionsContent(rootDir, config) {
+  const instructionsPath = resolveInstructionsPath(rootDir, config);
+  if (!instructionsPath) return null;
+  return readTextFile(instructionsPath);
+}
+function readInstructionsContentSync(rootDir, config) {
+  const instructionsPath = resolveInstructionsPath(rootDir, config);
+  if (!instructionsPath) return null;
+  return readFileSync2(instructionsPath, "utf-8");
+}
+function renderTitledInstructionsDocument(config, content, titleSuffix = "Plugin") {
+  return [
+    `# ${config.brand?.displayName ?? config.name} ${titleSuffix}`,
+    "",
+    config.brand?.shortDescription ?? config.description,
+    "",
+    content
+  ].join("\n");
+}
+
 // src/agents.ts
-import { existsSync as existsSync5, readdirSync, readFileSync as readFileSync2, statSync } from "fs";
-import { basename, resolve as resolve5 } from "path";
+import { existsSync as existsSync6, readdirSync, readFileSync as readFileSync3, statSync } from "fs";
+import { basename, resolve as resolve6 } from "path";
 function firstHeading(content) {
   const lines = content.split(/\r?\n/);
   for (const line of lines) {
@@ -5873,7 +5949,7 @@ function walkMarkdownFiles(dir) {
   const entries = readdirSync(dir);
   const files = [];
   for (const entry of entries) {
-    const fullPath = resolve5(dir, entry);
+    const fullPath = resolve6(dir, entry);
     const stat = statSync(fullPath);
     if (stat.isDirectory()) {
       files.push(...walkMarkdownFiles(fullPath));
@@ -5886,7 +5962,7 @@ function walkMarkdownFiles(dir) {
   return files;
 }
 function parseCanonicalAgentFile(agentPath) {
-  const content = readFileSync2(agentPath, "utf-8");
+  const content = readFileSync3(agentPath, "utf-8");
   const { frontmatterLines, body } = splitMarkdownFrontmatter(content);
   const frontmatter = parseAgentFrontmatter(frontmatterLines);
   const fileStem = basename(agentPath, ".md");
@@ -5902,31 +5978,52 @@ function parseCanonicalAgentFile(agentPath) {
   };
 }
 function readCanonicalAgentFiles(agentsDir) {
-  if (!agentsDir || !existsSync5(agentsDir)) return [];
+  if (!agentsDir || !existsSync6(agentsDir)) return [];
   return walkMarkdownFiles(agentsDir).sort((a, b) => a.localeCompare(b)).map(parseCanonicalAgentFile);
 }
-
-// src/generators/shared/claude-family.ts
-async function generateClaudeFamilyOutputs(args2) {
-  const {
-    config,
-    rootDir,
-    platform,
-    options,
-    writeJson,
-    writeFile: writeFile3
-  } = args2;
-  await Promise.all([
-    writeManifest(config, rootDir, options, writeJson),
-    writeMcpConfig(config, platform, writeJson),
-    writeHooks(config, platform, options, writeJson, writeFile3),
-    writeInstructions(config, rootDir, options, writeFile3)
-  ]);
+function getCanonicalAgentMetadata(agent) {
+  const frontmatter = agent.frontmatter;
+  return {
+    name: agent.name,
+    description: agent.description ?? `${agent.name} specialist.`,
+    body: agent.body,
+    mode: asString(frontmatter.mode),
+    hidden: frontmatter.hidden === true,
+    model: asString(frontmatter.model),
+    modelReasoningEffort: asString(frontmatter.model_reasoning_effort) ?? asString(frontmatter.effort),
+    sandboxMode: asString(frontmatter.sandbox_mode),
+    temperature: asNumber(frontmatter.temperature),
+    steps: asNumber(frontmatter.steps) ?? asNumber(frontmatter.maxSteps),
+    disabled: asBoolean(frontmatter.disable),
+    color: asString(frontmatter.color),
+    topP: asNumber(frontmatter.topP) ?? asNumber(frontmatter.top_p),
+    skills: asString(frontmatter.skills),
+    memory: asString(frontmatter.memory),
+    background: asBoolean(frontmatter.background),
+    isolation: asString(frontmatter.isolation),
+    permission: asMap(frontmatter.permission),
+    tools: frontmatter.tools
+  };
 }
+function asString(value) {
+  return typeof value === "string" && value ? value : void 0;
+}
+function asNumber(value) {
+  return typeof value === "number" ? value : void 0;
+}
+function asBoolean(value) {
+  return typeof value === "boolean" ? value : void 0;
+}
+function asMap(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  return value;
+}
+
+// src/hook-command-env.ts
 function shellSingleQuote(value) {
   return `'${value.replace(/'/g, `'"'"'`)}'`;
 }
-function buildClaudeHookCommandWrapperScript(command2) {
+function buildHookCommandWrapperScript(command2, pluginRootVar, envFileVar) {
   const serializedCommand = shellSingleQuote(command2);
   const exportLoader = [
     'import { readFileSync } from "node:fs"',
@@ -5945,20 +6042,23 @@ function buildClaudeHookCommandWrapperScript(command2) {
     "  process.stdout.write(`export ${key}=${shellSingleQuote(value)}\\0`)",
     "}"
   ].join("\n");
+  const maybeAppendEnvFile = envFileVar ? [
+    `      if [ -n "\${${envFileVar}:-}" ]; then`,
+    `        printf '%s\\n' "$pluxx_export" >> "\${${envFileVar}}"`,
+    "      fi"
+  ] : [];
   return [
     "#!/usr/bin/env bash",
     "set -euo pipefail",
     "",
-    'PLUXX_PLUGIN_ROOT="${CLAUDE_PLUGIN_ROOT:-$(cd "$(dirname "$0")/.." && pwd)}"',
+    `PLUXX_PLUGIN_ROOT="\${${pluginRootVar}:-$(cd "$(dirname "$0")/.." && pwd)}"`,
     'PLUXX_USER_CONFIG_PATH="$PLUXX_PLUGIN_ROOT/.pluxx-user.json"',
     "",
     'if [ -f "$PLUXX_USER_CONFIG_PATH" ]; then',
     "  while IFS= read -r -d '' pluxx_export; do",
     '    if [ -n "$pluxx_export" ]; then',
     '      eval "$pluxx_export"',
-    '      if [ -n "${CLAUDE_ENV_FILE:-}" ]; then',
-    `        printf '%s\\n' "$pluxx_export" >> "$CLAUDE_ENV_FILE"`,
-    "      fi",
+    ...maybeAppendEnvFile,
     "    fi",
     "  done < <(",
     `    node --input-type=module -e ${shellSingleQuote(exportLoader)} "$PLUXX_USER_CONFIG_PATH"`,
@@ -5970,6 +6070,24 @@ function buildClaudeHookCommandWrapperScript(command2) {
     ""
   ].join("\n");
 }
+
+// src/generators/shared/claude-family.ts
+async function generateClaudeFamilyOutputs(args2) {
+  const {
+    config,
+    rootDir,
+    platform,
+    options,
+    writeJson,
+    writeFile: writeFile3
+  } = args2;
+  await Promise.all([
+    writeManifest(config, rootDir, options, writeJson),
+    writeMcpConfig(config, platform, writeJson),
+    writeHooks(config, platform, options, writeJson, writeFile3),
+    writeInstructions(config, rootDir, options, writeFile3)
+  ]);
+}
 async function writeManifest(config, rootDir, options, writeJson) {
   const manifest = {
     name: config.name,
@@ -5991,7 +6109,7 @@ async function writeManifest(config, rootDir, options, writeJson) {
   if (config.agents && agentsManifestMode === "directory") {
     manifest.agents = "./agents/";
   } else if (config.agents && agentsManifestMode === "files") {
-    const agentsDir = resolve6(rootDir, config.agents);
+    const agentsDir = resolve7(rootDir, config.agents);
     const agents = readCanonicalAgentFiles(agentsDir);
     if (agents.length > 0) {
       manifest.agents = agents.map((agent) => `./agents/${agent.fileStem}.md`);
@@ -6107,51 +6225,112 @@ async function writeHooks(config, platform, options, writeJson, writeFile3) {
   }
   for (const [event, entries] of Object.entries(config.hooks)) {
     if (!entries) continue;
-    warnDroppedHookFields(platform, event, entries);
     const mappedEvent = mapEventName(event);
-    const commandEntries = entries.filter((entry) => {
-      if (entry.type === "prompt" || !entry.command) return false;
-      if (usesPlatformManagedAuth && entry.command.includes("check-env.sh")) {
-        return false;
-      }
-      return true;
-    });
-    if (commandEntries.length === 0) continue;
+    warnDroppedHookFields(platform, mappedEvent, entries);
+    const translatedEntries = (await Promise.all(entries.map(async (entry) => mapClaudeHookEntry({
+      entry,
+      mappedEvent,
+      options,
+      shouldWrapClaudeHookCommands,
+      usesPlatformManagedAuth,
+      writeFile: writeFile3,
+      nextWrapperIndex: () => {
+        generatedClaudeHookCommandCount += 1;
+        return generatedClaudeHookCommandCount;
+      }
+    })))).filter((entry) => entry !== null);
+    if (translatedEntries.length === 0) continue;
     hooks[mappedEvent] = [
       ...hooks[mappedEvent] ?? [],
-      ...await Promise.all(commandEntries.map(async (entry) => {
-        const command2 = entry.command.replace("${PLUGIN_ROOT}", `\${${options.pluginRootVar}}`);
-        const finalCommand = shouldWrapClaudeHookCommands ? await (async () => {
-          generatedClaudeHookCommandCount += 1;
-          const relativePath = `hooks/pluxx-hook-command-${generatedClaudeHookCommandCount}.sh`;
-          await writeFile3(relativePath, buildClaudeHookCommandWrapperScript(command2));
-          return `bash "\${${options.pluginRootVar}}/${relativePath}"`;
-        })() : command2;
-        return {
-          ...entry.matcher !== void 0 ? { matcher: entry.matcher } : {},
-          hooks: [{
-            type: "command",
-            command: finalCommand
-          }]
-        };
-      }))
+      ...translatedEntries
     ];
   }
   await writeJson("hooks/hooks.json", { hooks });
 }
+async function mapClaudeHookEntry(args2) {
+  const {
+    entry,
+    mappedEvent,
+    options,
+    shouldWrapClaudeHookCommands,
+    usesPlatformManagedAuth,
+    writeFile: writeFile3,
+    nextWrapperIndex
+  } = args2;
+  const entryType = entry.type ?? "command";
+  if (entryType === "prompt" && !isHookFieldPreserved("claude-code", "prompt", mappedEvent)) {
+    return null;
+  }
+  if (entryType === "command") {
+    if (!entry.command) return null;
+    if (usesPlatformManagedAuth && entry.command.includes("check-env.sh")) {
+      return null;
+    }
+    const command2 = entry.command.replace("${PLUGIN_ROOT}", `\${${options.pluginRootVar}}`);
+    const finalCommand = shouldWrapClaudeHookCommands ? await (async () => {
+      const relativePath = `hooks/pluxx-hook-command-${nextWrapperIndex()}.sh`;
+      await writeFile3(relativePath, buildHookCommandWrapperScript(command2, options.pluginRootVar, "CLAUDE_ENV_FILE"));
+      return `bash "\${${options.pluginRootVar}}/${relativePath}"`;
+    })() : command2;
+    return {
+      ...entry.matcher !== void 0 ? { matcher: entry.matcher } : {},
+      hooks: [{
+        type: "command",
+        command: finalCommand,
+        ...entry.if !== void 0 ? { if: entry.if } : {},
+        ...entry.timeout !== void 0 ? { timeout: entry.timeout } : {},
+        ...entry.async !== void 0 ? { async: entry.async } : {},
+        ...entry.asyncRewake !== void 0 ? { asyncRewake: entry.asyncRewake } : {},
+        ...entry.shell !== void 0 ? { shell: entry.shell } : {}
+      }]
+    };
+  }
+  if (entryType === "http") {
+    if (!entry.url) return null;
+    return {
+      ...entry.matcher !== void 0 ? { matcher: entry.matcher } : {},
+      hooks: [{
+        type: "http",
+        url: entry.url,
+        ...entry.if !== void 0 ? { if: entry.if } : {},
+        ...entry.timeout !== void 0 ? { timeout: entry.timeout } : {},
+        ...entry.headers !== void 0 ? { headers: entry.headers } : {},
+        ...entry.allowedEnvVars !== void 0 ? { allowedEnvVars: entry.allowedEnvVars } : {}
+      }]
+    };
+  }
+  if (entryType === "mcp_tool") {
+    if (!entry.server || !entry.tool) return null;
+    return {
+      ...entry.matcher !== void 0 ? { matcher: entry.matcher } : {},
+      hooks: [{
+        type: "mcp_tool",
+        server: entry.server,
+        tool: entry.tool,
+        ...entry.if !== void 0 ? { if: entry.if } : {},
+        ...entry.input !== void 0 ? { input: entry.input } : {}
+      }]
+    };
+  }
+  if (entryType === "prompt" || entryType === "agent") {
+    if (!entry.prompt) return null;
+    return {
+      ...entry.matcher !== void 0 ? { matcher: entry.matcher } : {},
+      hooks: [{
+        type: entryType,
+        prompt: entry.prompt,
+        ...entry.if !== void 0 ? { if: entry.if } : {},
+        ...entry.model !== void 0 ? { model: entry.model } : {}
+      }]
+    };
+  }
+  return null;
+}
 async function writeInstructions(config, rootDir, options, writeFile3) {
-  if (!config.instructions) return;
-  const srcPath = resolve6(rootDir, config.instructions);
-  if (!existsSync6(srcPath)) return;
-  const content = await readTextFile(srcPath);
+  const content = await readInstructionsContent(rootDir, config);
+  if (!content) return;
   const titleSuffix = options.titleSuffix ?? "Plugin";
-  const instructions = [
-    `# ${config.brand?.displayName ?? config.name} ${titleSuffix}`,
-    "",
-    config.brand?.shortDescription ?? config.description,
-    "",
-    content
-  ].join("\n");
+  const instructions = renderTitledInstructionsDocument(config, content, titleSuffix);
   await writeFile3(options.instructionsFile, instructions);
 }
 function defaultMapEventName(event) {
@@ -6159,14 +6338,14 @@ function defaultMapEventName(event) {
 }
 
 // src/generators/claude-code/index.ts
-import { existsSync as existsSync8, mkdirSync as mkdirSync2, readFileSync as readFileSync4, readdirSync as readdirSync3, writeFileSync } from "fs";
+import { existsSync as existsSync8, mkdirSync as mkdirSync2, readFileSync as readFileSync5, readdirSync as readdirSync3, writeFileSync } from "fs";
 import { basename as basename2, join as join2 } from "path";
 
 // src/delegation.ts
 function getPortableDelegationProfile(frontmatter) {
-  const permission = asMap(frontmatter.permission);
-  const bash = asMap(permission?.bash);
-  const task = asMap(permission?.task);
+  const permission = asMap2(frontmatter.permission);
+  const bash = asMap2(permission?.bash);
+  const task = asMap2(permission?.task);
   return {
     mode: typeof frontmatter.mode === "string" ? frontmatter.mode : void 0,
     hidden: frontmatter.hidden === true,
@@ -6196,14 +6375,14 @@ function buildDelegationBehaviorNotes(frontmatter) {
   }
   return notes;
 }
-function asMap(value) {
+function asMap2(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
   return value;
 }
 
 // src/skills.ts
-import { existsSync as existsSync7, readdirSync as readdirSync2, readFileSync as readFileSync3, statSync as statSync2 } from "fs";
-import { relative as relative2, resolve as resolve7 } from "path";
+import { existsSync as existsSync7, readdirSync as readdirSync2, readFileSync as readFileSync4, statSync as statSync2 } from "fs";
+import { relative as relative2, resolve as resolve8 } from "path";
 function unquote(value) {
   const trimmed = value.trim();
   if (trimmed.length >= 2) {
@@ -6287,6 +6466,34 @@ function parseAllowedTools(hasValidFrontmatter, frontmatterLines, frontmatterFie
   }
   return tools;
 }
+function parseBooleanField(frontmatterFields, key) {
+  const value = frontmatterFields.get(key)?.value.trim().toLowerCase();
+  if (value === "true") return true;
+  if (value === "false") return false;
+  return void 0;
+}
+function parseInlineStringArray(rawValue) {
+  const trimmed = rawValue.trim();
+  if (!trimmed.startsWith("[") || !trimmed.endsWith("]")) return [];
+  const inner = trimmed.slice(1, -1).trim();
+  if (!inner) return [];
+  return inner.split(",").map((part) => unquote(part).value.trim()).filter(Boolean);
+}
+function parseStringArrayField(frontmatterFields, key) {
+  const rawValue = frontmatterFields.get(key)?.rawValue;
+  if (!rawValue) return [];
+  return parseInlineStringArray(rawValue);
+}
+function parseJsonField(frontmatterFields, key) {
+  const rawValue = frontmatterFields.get(key)?.rawValue?.trim();
+  if (!rawValue) return void 0;
+  if (!(rawValue.startsWith("{") || rawValue.startsWith("["))) return void 0;
+  try {
+    return JSON.parse(rawValue);
+  } catch {
+    return void 0;
+  }
+}
 function parseSkillMarkdown(content) {
   const {
     hasValidFrontmatter,
@@ -6301,7 +6508,19 @@ function parseSkillMarkdown(content) {
     body,
     name: frontmatterFields.get("name")?.value,
     description: frontmatterFields.get("description")?.value,
+    whenToUse: frontmatterFields.get("when_to_use")?.value,
+    argumentHint: frontmatterFields.get("argument-hint")?.value,
+    arguments: parseStringArrayField(frontmatterFields, "arguments"),
+    disableModelInvocation: parseBooleanField(frontmatterFields, "disable-model-invocation"),
+    userInvocable: parseBooleanField(frontmatterFields, "user-invocable"),
     allowedTools: parseAllowedTools(hasValidFrontmatter, frontmatterLines, frontmatterFields),
+    model: frontmatterFields.get("model")?.value,
+    effort: frontmatterFields.get("effort")?.value,
+    context: frontmatterFields.get("context")?.value,
+    agent: frontmatterFields.get("agent")?.value,
+    hooks: parseJsonField(frontmatterFields, "hooks"),
+    paths: parseStringArrayField(frontmatterFields, "paths"),
+    shell: frontmatterFields.get("shell")?.value,
     firstHeading: firstHeading2(body)
   };
 }
@@ -6310,7 +6529,7 @@ function walkSkillFiles(skillsDir) {
   const entries = readdirSync2(skillsDir);
   const files = [];
   for (const entry of entries) {
-    const fullPath = resolve7(skillsDir, entry);
+    const fullPath = resolve8(skillsDir, entry);
     const stat = statSync2(fullPath);
     if (stat.isDirectory()) {
       files.push(...walkSkillFiles(fullPath));
@@ -6323,7 +6542,7 @@ function walkSkillFiles(skillsDir) {
   return files;
 }
 function readSkillMarkdownFile(filePath) {
-  return parseSkillMarkdown(readFileSync3(filePath, "utf-8"));
+  return parseSkillMarkdown(readFileSync4(filePath, "utf-8"));
 }
 function readCanonicalSkillFiles(skillsDir) {
   if (!skillsDir || !existsSync7(skillsDir)) return [];
@@ -6374,7 +6593,7 @@ var ClaudeCodeGenerator = class extends Generator {
     for (const skill of collidingSkills) {
       const outputPath = join2(this.outDir, "skills", skill.dirName, "SKILL.md");
       if (!existsSync8(outputPath)) continue;
-      const current = readFileSync4(outputPath, "utf-8");
+      const current = readFileSync5(outputPath, "utf-8");
       const hiddenName = buildHiddenSkillName(skill.effectiveName);
       const rewritten = rewriteClaudeSkillVisibility(current, {
         nameOverride: hiddenName,
@@ -6388,7 +6607,7 @@ var ClaudeCodeGenerator = class extends Generator {
       if (collidingSkills.some((entry) => entry.dirName === skill.dirName)) continue;
       const outputPath = join2(this.outDir, "skills", skill.dirName, "SKILL.md");
       if (!existsSync8(outputPath)) continue;
-      const current = readFileSync4(outputPath, "utf-8");
+      const current = readFileSync5(outputPath, "utf-8");
       const rewritten = rewriteClaudeSkillVisibility(current, {
         userInvocable: false
       });
@@ -6404,21 +6623,20 @@ var ClaudeCodeGenerator = class extends Generator {
     if (agents.length === 0) return;
     mkdirSync2(join2(this.outDir, "agents"), { recursive: true });
     for (const agent of agents) {
+      const metadata = getCanonicalAgentMetadata(agent);
       const frontmatter = [
         "---",
-        `name: ${JSON.stringify(agent.name)}`,
-        `description: ${JSON.stringify(agent.description ?? `${agent.name} specialist.`)}`
+        `name: ${JSON.stringify(metadata.name)}`,
+        `description: ${JSON.stringify(metadata.description)}`
       ];
-      if (typeof agent.frontmatter.model === "string" && agent.frontmatter.model) {
-        frontmatter.push(`model: ${JSON.stringify(agent.frontmatter.model)}`);
+      if (metadata.model) {
+        frontmatter.push(`model: ${JSON.stringify(metadata.model)}`);
       }
-      const effort = typeof agent.frontmatter.model_reasoning_effort === "string" && agent.frontmatter.model_reasoning_effort ? agent.frontmatter.model_reasoning_effort : typeof agent.frontmatter.effort === "string" && agent.frontmatter.effort ? agent.frontmatter.effort : void 0;
-      if (effort) {
-        frontmatter.push(`effort: ${JSON.stringify(effort)}`);
+      if (metadata.modelReasoningEffort) {
+        frontmatter.push(`effort: ${JSON.stringify(metadata.modelReasoningEffort)}`);
       }
-      const maxTurns = typeof agent.frontmatter.maxTurns === "number" ? agent.frontmatter.maxTurns : typeof agent.frontmatter.steps === "number" ? agent.frontmatter.steps : typeof agent.frontmatter.maxSteps === "number" ? agent.frontmatter.maxSteps : void 0;
-      if (typeof maxTurns === "number") {
-        frontmatter.push(`maxTurns: ${maxTurns}`);
+      if (typeof metadata.steps === "number") {
+        frontmatter.push(`maxTurns: ${metadata.steps}`);
       }
       const claudeTools = selectClaudeToolsField(agent.frontmatter);
       if (claudeTools) {
@@ -6428,20 +6646,20 @@ var ClaudeCodeGenerator = class extends Generator {
       if (disallowedTools.length > 0) {
         frontmatter.push(`disallowedTools: ${disallowedTools.join(", ")}`);
       }
-      if (typeof agent.frontmatter.skills === "string" && agent.frontmatter.skills.trim()) {
-        frontmatter.push(`skills: ${agent.frontmatter.skills}`);
+      if (metadata.skills) {
+        frontmatter.push(`skills: ${metadata.skills}`);
       }
-      if (typeof agent.frontmatter.memory === "string" && agent.frontmatter.memory.trim()) {
-        frontmatter.push(`memory: ${JSON.stringify(agent.frontmatter.memory)}`);
+      if (metadata.memory) {
+        frontmatter.push(`memory: ${JSON.stringify(metadata.memory)}`);
       }
-      if (typeof agent.frontmatter.background === "boolean") {
-        frontmatter.push(`background: ${agent.frontmatter.background}`);
+      if (typeof metadata.background === "boolean") {
+        frontmatter.push(`background: ${metadata.background}`);
       }
-      if (typeof agent.frontmatter.isolation === "string" && agent.frontmatter.isolation.trim()) {
-        frontmatter.push(`isolation: ${JSON.stringify(agent.frontmatter.isolation)}`);
+      if (metadata.isolation) {
+        frontmatter.push(`isolation: ${JSON.stringify(metadata.isolation)}`);
       }
-      if (typeof agent.frontmatter.color === "string" && agent.frontmatter.color.trim()) {
-        frontmatter.push(`color: ${JSON.stringify(agent.frontmatter.color)}`);
+      if (metadata.color) {
+        frontmatter.push(`color: ${JSON.stringify(metadata.color)}`);
       }
       frontmatter.push("---");
       const delegationNotes = buildDelegationBehaviorNotes(agent.frontmatter);
@@ -6451,7 +6669,7 @@ var ClaudeCodeGenerator = class extends Generator {
           ...delegationNotes.map((note) => `- ${note}`),
           ""
         ] : [],
-        agent.body
+        metadata.body
       ].filter(Boolean);
       const outputPath = join2(this.outDir, "agents", `${agent.fileStem}.md`);
       writeFileSync(outputPath, `${frontmatter.join("\n")}
@@ -6505,7 +6723,7 @@ function collectWrappedSkillNames(commandsRoot) {
   const wrappedSkills = /* @__PURE__ */ new Set();
   for (const entry of readdirSync3(commandsRoot, { withFileTypes: true })) {
     if (!entry.isFile() || !entry.name.toLowerCase().endsWith(".md")) continue;
-    const content = readFileSync4(join2(commandsRoot, entry.name), "utf-8");
+    const content = readFileSync5(join2(commandsRoot, entry.name), "utf-8");
     for (const match of content.matchAll(/Use the `([^`]+)` skill\./g)) {
       const skillName = match[1]?.trim();
       if (skillName) wrappedSkills.add(skillName);
@@ -6552,9 +6770,9 @@ function rewriteClaudeSkillVisibility(content, options) {
 }
 function buildClaudeDisallowedTools(frontmatter) {
   const tools = /* @__PURE__ */ new Set();
-  const permission = asMap2(frontmatter.permission);
-  const bash = asMap2(permission?.bash);
-  const legacyTools = asMap2(frontmatter.tools);
+  const permission = asMap3(frontmatter.permission);
+  const bash = asMap3(permission?.bash);
+  const legacyTools = asMap3(frontmatter.tools);
   if (permission?.edit === "deny") {
     tools.add("Write");
     tools.add("Edit");
@@ -6588,13 +6806,12 @@ function selectClaudeToolsField(frontmatter) {
   }
   return tools.join(", ");
 }
-function asMap2(value) {
+function asMap3(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
   return value;
 }
 
 // src/generators/cursor/index.ts
-import { existsSync as existsSync9 } from "fs";
 var CursorGenerator = class extends Generator {
   platform = "cursor";
   async generate() {
@@ -6639,6 +6856,7 @@ var CursorGenerator = class extends Generator {
     if (!this.config.hooks && !permissionScript && !readinessPlan.hasReadiness) return;
     const usesPlatformManagedAuth = this.config.platforms?.cursor?.mcpAuth === "platform";
     const hooks = {};
+    let nextWrapperIndex = 0;
     if (readinessPlan.hasReadiness && this.config.readiness) {
       await this.writeFile("hooks/pluxx-readiness.mjs", buildGeneratedReadinessScript(this.config.readiness));
       for (const binding of getEnabledRuntimeReadinessBindings(readinessCapability, readinessPlan)) {
@@ -6690,25 +6908,36 @@ var CursorGenerator = class extends Generator {
         return true;
       });
       if (filteredEntries.length === 0) continue;
+      const mappedEntries = [];
+      for (const entry of filteredEntries) {
+        const hookDef = {};
+        if (entry.type === "prompt") {
+          hookDef.type = "prompt";
+          hookDef.prompt = entry.prompt;
+          if (entry.model) hookDef.model = entry.model;
+        } else if (entry.command) {
+          nextWrapperIndex += 1;
+          const relativePath = `hooks/pluxx-hook-command-${nextWrapperIndex}.sh`;
+          await this.writeFile(
+            relativePath,
+            buildHookCommandWrapperScript(entry.command.replace("${PLUGIN_ROOT}", "."), "CURSOR_PLUGIN_ROOT")
+          );
+          hookDef.command = `bash ./${relativePath}`;
+        }
+        if (entry.timeout) hookDef.timeout = entry.timeout;
+        if (entry.matcher) hookDef.matcher = entry.matcher;
+        if (entry.failClosed) hookDef.failClosed = entry.failClosed;
+        if (entry.loop_limit !== void 0 && getHookFieldSupportedEvents("cursor", "loop_limit").includes(event)) {
+          hookDef.loop_limit = entry.loop_limit;
+        }
+        if (Object.keys(hookDef).length > 0) {
+          mappedEntries.push(hookDef);
+        }
+      }
+      if (mappedEntries.length === 0) continue;
       hooks[event] = [
         ...hooks[event] ?? [],
-        ...filteredEntries.map((entry) => {
-          const hookDef = {};
-          if (entry.type === "prompt") {
-            hookDef.type = "prompt";
-            hookDef.prompt = entry.prompt;
-            if (entry.model) hookDef.model = entry.model;
-          } else if (entry.command) {
-            hookDef.command = entry.command.replace("${PLUGIN_ROOT}", ".");
-          }
-          if (entry.timeout) hookDef.timeout = entry.timeout;
-          if (entry.matcher) hookDef.matcher = entry.matcher;
-          if (entry.failClosed) hookDef.failClosed = entry.failClosed;
-          if (entry.loop_limit !== void 0 && getHookFieldSupportedEvents("cursor", "loop_limit").includes(event)) {
-            hookDef.loop_limit = entry.loop_limit;
-          }
-          return hookDef;
-        })
+        ...mappedEntries
       ];
     }
     await this.writeJson("hooks/hooks.json", { version: 1, hooks });
@@ -6741,10 +6970,8 @@ var CursorGenerator = class extends Generator {
     }
   }
   async generateAgentsMd() {
-    if (!this.config.instructions) return;
-    const srcPath = this.resolveConfigPath(this.config.instructions, "instructions");
-    if (!existsSync9(srcPath)) return;
-    const content = await readTextFile(srcPath);
+    const content = await readInstructionsContent(this.rootDir, this.config);
+    if (!content) return;
     await this.writeFile("AGENTS.md", content);
   }
   async generateAgents() {
@@ -6753,13 +6980,14 @@ var CursorGenerator = class extends Generator {
     const agents = readCanonicalAgentFiles(agentsDir);
     if (agents.length === 0) return;
     for (const agent of agents) {
+      const metadata = getCanonicalAgentMetadata(agent);
       const frontmatter = [
         "---",
-        `name: ${JSON.stringify(agent.name)}`,
-        `description: ${JSON.stringify(agent.description ?? `${agent.name} specialist.`)}`
+        `name: ${JSON.stringify(metadata.name)}`,
+        `description: ${JSON.stringify(metadata.description)}`
       ];
-      if (typeof agent.frontmatter.model === "string" && agent.frontmatter.model) {
-        frontmatter.push(`model: ${JSON.stringify(agent.frontmatter.model)}`);
+      if (metadata.model) {
+        frontmatter.push(`model: ${JSON.stringify(metadata.model)}`);
       }
       frontmatter.push("---");
       const translatedNotes = buildCursorAgentTranslationNotes(agent.frontmatter);
@@ -6784,12 +7012,11 @@ function buildCursorAgentTranslationNotes(frontmatter) {
 }
 
 // src/generators/codex/index.ts
-import { existsSync as existsSync11 } from "fs";
 import { relative as relative4 } from "path";
 
 // src/commands.ts
-import { existsSync as existsSync10, readdirSync as readdirSync4, readFileSync as readFileSync5, statSync as statSync3 } from "fs";
-import { relative as relative3, resolve as resolve8 } from "path";
+import { existsSync as existsSync9, readdirSync as readdirSync4, readFileSync as readFileSync6, statSync as statSync3 } from "fs";
+import { relative as relative3, resolve as resolve9 } from "path";
 function firstHeading3(content) {
   const lines = content.split(/\r?\n/);
   for (const line of lines) {
@@ -6861,7 +7088,7 @@ function walkMarkdownFiles2(dir) {
   const entries = readdirSync4(dir);
   const files = [];
   for (const entry of entries) {
-    const fullPath = resolve8(dir, entry);
+    const fullPath = resolve9(dir, entry);
     const stat = statSync3(fullPath);
     if (stat.isDirectory()) {
       files.push(...walkMarkdownFiles2(fullPath));
@@ -6874,9 +7101,9 @@ function walkMarkdownFiles2(dir) {
   return files;
 }
 function readCanonicalCommandFiles(commandsDir) {
-  if (!commandsDir || !existsSync10(commandsDir)) return [];
+  if (!commandsDir || !existsSync9(commandsDir)) return [];
   return walkMarkdownFiles2(commandsDir).sort((a, b) => a.localeCompare(b)).map((filePath) => {
-    const content = readFileSync5(filePath, "utf-8");
+    const content = readFileSync6(filePath, "utf-8");
     const { frontmatterLines, body } = splitMarkdownFrontmatter3(content);
     const relativeStem = relative3(commandsDir, filePath).replace(/\\/g, "/").replace(/\.md$/i, "");
     const commandId = relativeStem.replace(/\//g, "-").toLowerCase();
@@ -6895,6 +7122,18 @@ function readCanonicalCommandFiles(commandsDir) {
     };
   });
 }
+function getCanonicalCommandMetadata(command2) {
+  return {
+    commandId: command2.commandId,
+    title: command2.title,
+    ...command2.description ? { description: command2.description } : {},
+    ...command2.argumentHint ? { argumentHint: command2.argumentHint } : {},
+    ...command2.agent ? { agent: command2.agent } : {},
+    ...typeof command2.subtask === "boolean" ? { subtask: command2.subtask } : {},
+    ...command2.model ? { model: command2.model } : {},
+    template: command2.body
+  };
+}
 
 // src/generators/codex/index.ts
 var CodexGenerator = class extends Generator {
@@ -6958,6 +7197,9 @@ var CodexGenerator = class extends Generator {
     if (this.config.keywords) manifest.keywords = this.config.keywords;
     manifest.skills = "./skills/";
     if (this.config.mcp) manifest.mcpServers = "./.mcp.json";
+    if (this.config.hooks || getRuntimeReadinessPlan(this.config.readiness).hasReadiness) {
+      manifest.hooks = "./hooks/hooks.json";
+    }
     if (this.config.brand) {
       const iface = {
         displayName: this.config.brand.displayName,
@@ -7018,11 +7260,9 @@ var CodexGenerator = class extends Generator {
   }
   async generateAgentsMd() {
     const sections = [];
-    if (this.config.instructions) {
-      const srcPath = this.resolveConfigPath(this.config.instructions, "instructions");
-      if (existsSync11(srcPath)) {
-        sections.push((await readTextFile(srcPath)).trim());
-      }
+    const instructions = await readInstructionsContent(this.rootDir, this.config);
+    if (instructions?.trim()) {
+      sections.push(instructions.trim());
     }
     const commandsSection = this.buildCodexCommandRoutingSection();
     if (commandsSection) {
@@ -7037,19 +7277,20 @@ var CodexGenerator = class extends Generator {
     const agents = readCanonicalAgentFiles(agentsDir);
     if (agents.length === 0) return;
     for (const agent of agents) {
+      const metadata = getCanonicalAgentMetadata(agent);
       const relativePath = relative4(agentsDir, agent.filePath).replace(/\\/g, "/").replace(/\.md$/i, ".toml");
       const lines = [
-        `name = ${JSON.stringify(agent.name)}`,
-        `description = ${JSON.stringify(agent.description ?? `${agent.name} specialist.`)}`
+        `name = ${JSON.stringify(metadata.name)}`,
+        `description = ${JSON.stringify(metadata.description)}`
       ];
-      if (typeof agent.frontmatter.model === "string" && agent.frontmatter.model) {
-        lines.push(`model = ${JSON.stringify(agent.frontmatter.model)}`);
+      if (metadata.model) {
+        lines.push(`model = ${JSON.stringify(metadata.model)}`);
       }
-      if (typeof agent.frontmatter.model_reasoning_effort === "string" && agent.frontmatter.model_reasoning_effort) {
-        lines.push(`model_reasoning_effort = ${JSON.stringify(agent.frontmatter.model_reasoning_effort)}`);
+      if (metadata.modelReasoningEffort) {
+        lines.push(`model_reasoning_effort = ${JSON.stringify(metadata.modelReasoningEffort)}`);
       }
-      if (typeof agent.frontmatter.sandbox_mode === "string" && agent.frontmatter.sandbox_mode) {
-        lines.push(`sandbox_mode = ${JSON.stringify(agent.frontmatter.sandbox_mode)}`);
+      if (metadata.sandboxMode) {
+        lines.push(`sandbox_mode = ${JSON.stringify(metadata.sandboxMode)}`);
       }
       const delegationNotes = buildDelegationBehaviorNotes(agent.frontmatter);
       const developerInstructions = [
@@ -7058,7 +7299,7 @@ var CodexGenerator = class extends Generator {
           ...delegationNotes.map((note) => `- ${note}`),
           ""
         ] : [],
-        agent.body
+        metadata.body
       ].filter(Boolean).join("\n");
       if (developerInstructions) {
         lines.push('developer_instructions = """');
@@ -7075,6 +7316,7 @@ var CodexGenerator = class extends Generator {
     if (!this.config.hooks && !readinessPlan.hasReadiness) return;
     const hooks = {};
     const unsupported = [];
+    let nextWrapperIndex = 0;
     if (readinessPlan.hasReadiness && this.config.readiness) {
       await this.writeFile(".codex/pluxx-readiness.mjs", buildGeneratedReadinessScript(this.config.readiness));
       for (const binding of getEnabledRuntimeReadinessBindings(readinessCapability, readinessPlan)) {
@@ -7090,12 +7332,22 @@ var CodexGenerator = class extends Generator {
     for (const [event, entries] of Object.entries(this.config.hooks ?? {})) {
       if (!entries || entries.length === 0) continue;
       const codexEvent = mapHookEventToPascalCase(event);
-      const mappedEntries = entries.filter((entry) => entry.type !== "prompt" && entry.command).map((entry) => ({
-        command: entry.command?.replace("${PLUGIN_ROOT}", "."),
-        ...entry.matcher !== void 0 ? { matcher: entry.matcher } : {},
-        ...entry.timeout ? { timeout: entry.timeout } : {},
-        ...entry.failClosed !== void 0 ? { failClosed: entry.failClosed } : {}
-      }));
+      const mappedEntries = [];
+      for (const entry of entries) {
+        if (entry.type === "prompt" || !entry.command) continue;
+        nextWrapperIndex += 1;
+        const relativePath = `hooks/pluxx-hook-command-${nextWrapperIndex}.sh`;
+        await this.writeFile(
+          relativePath,
+          buildHookCommandWrapperScript(entry.command.replace("${PLUGIN_ROOT}", "."), "CODEX_PLUGIN_ROOT")
+        );
+        mappedEntries.push({
+          command: `bash ./${relativePath}`,
+          ...entry.matcher !== void 0 ? { matcher: entry.matcher } : {},
+          ...entry.timeout ? { timeout: entry.timeout } : {},
+          ...entry.failClosed !== void 0 ? { failClosed: entry.failClosed } : {}
+        });
+      }
       if (mappedEntries.length === 0) continue;
       if (!isHookEventSupported("codex", codexEvent)) {
         unsupported.push({
@@ -7111,11 +7363,15 @@ var CodexGenerator = class extends Generator {
       ];
     }
     if (Object.keys(hooks).length === 0 && unsupported.length === 0) return;
+    await this.writeJson("hooks/hooks.json", {
+      version: 1,
+      hooks
+    });
     await this.writeJson(".codex/hooks.generated.json", {
       model: "pluxx.codex-hooks.v1",
-      enforcedByPluginBundle: false,
+      enforcedByPluginBundle: true,
       featureFlag: "codex_hooks",
-      note: "Codex hook configuration lives outside the plugin bundle. Use this file as a generated mirror for <repo>/.codex/hooks.json or ~/.codex/hooks.json and enable codex_hooks in Codex.",
+      note: "Codex hook configuration is bundled at hooks/hooks.json in the plugin. This companion mirror preserves the translated native event names and highlights any dropped events or fields; enable codex_hooks in Codex if your runtime still requires that feature gate.",
       hooks,
       ...unsupported.length > 0 ? { unsupported } : {}
     });
@@ -7133,7 +7389,7 @@ var CodexGenerator = class extends Generator {
     await this.writeJson(".codex/readiness.generated.json", {
       model: "pluxx.readiness.v1",
       enforcedByPluginBundle: readinessCapability.bundleEnforced,
-      note: `${getRuntimeReadinessExternalConfigNote()} Use this file together with .codex/hooks.generated.json when wiring readiness into Codex hook config.`,
+      note: `${getRuntimeReadinessExternalConfigNote()} Use this file together with hooks/hooks.json (and .codex/hooks.generated.json when debugging translated event names) when wiring readiness into Codex hook config.`,
       dependencies: this.config.readiness.dependencies,
       gates: this.config.readiness.gates,
       translatedHooks: {
@@ -7152,13 +7408,19 @@ var CodexGenerator = class extends Generator {
       model: "pluxx.commands.v1",
       nativeSurface: "degraded-to-guidance",
       note: "Codex does not currently document plugin-packaged slash commands. Use these canonical command entries as workflow routing guidance alongside AGENTS.md.",
-      commands: commands.map((command2) => ({
-        id: command2.commandId,
-        title: command2.title,
-        ...command2.description ? { description: command2.description } : {},
-        ...command2.argumentHint ? { argumentHint: command2.argumentHint } : {},
-        template: command2.body
-      }))
+      commands: commands.map((command2) => {
+        const metadata = getCanonicalCommandMetadata(command2);
+        return {
+          id: metadata.commandId,
+          title: metadata.title,
+          ...metadata.description ? { description: metadata.description } : {},
+          ...metadata.argumentHint ? { argumentHint: metadata.argumentHint } : {},
+          ...metadata.agent ? { agent: metadata.agent } : {},
+          ...typeof metadata.subtask === "boolean" ? { subtask: metadata.subtask } : {},
+          ...metadata.model ? { model: metadata.model } : {},
+          template: metadata.template
+        };
+      })
     });
   }
   buildCodexCommandRoutingSection() {
@@ -7171,15 +7433,18 @@ var CodexGenerator = class extends Generator {
       "",
       "This plugin defines canonical command entrypoints. Codex does not package them as native slash commands today, so route those requests through the matching workflow directly.",
       "",
-      ...commands.map((command2) => `- \`/${command2.commandId}\` - ${command2.description ?? command2.title}${command2.argumentHint ? ` (arguments: ${command2.argumentHint})` : ""}`)
+      ...commands.map((command2) => {
+        const metadata = getCanonicalCommandMetadata(command2);
+        return `- \`/${metadata.commandId}\` - ${metadata.description ?? metadata.title}${metadata.argumentHint ? ` (arguments: ${metadata.argumentHint})` : ""}`;
+      })
     ];
     return lines.join("\n");
   }
 };
 
 // src/generators/opencode/index.ts
-import { existsSync as existsSync12, readdirSync as readdirSync5, readFileSync as readFileSync6, statSync as statSync4, writeFileSync as writeFileSync2 } from "fs";
-import { basename as basename3, resolve as resolve9 } from "path";
+import { existsSync as existsSync10, readdirSync as readdirSync5, readFileSync as readFileSync7, statSync as statSync4, writeFileSync as writeFileSync2 } from "fs";
+import { basename as basename3, resolve as resolve10 } from "path";
 var OpenCodeGenerator = class extends Generator {
   platform = "opencode";
   async generate() {
@@ -7346,9 +7611,21 @@ var OpenCodeGenerator = class extends Generator {
       ` * Generated by pluxx \u2014 do not edit manually.`,
       ` */`,
       `export const ${pluginName}: Plugin = async ({ project, client, $, directory }) => {`,
+      `  const shellSingleQuote = (input: string): string => \`'\${String(input ?? "").replace(/'/g, \`'"'"'\`)}'\``,
+      "",
+      `  const buildHookShellCommand = (rawCommand: string): string => {`,
+      `    const userEnv = loadUserConfig(directory).env ?? {}`,
+      `    const exports = Object.entries(userEnv)`,
+      `      .filter(([key]) => /^[A-Za-z_][A-Za-z0-9_]*$/.test(key))`,
+      `      .map(([key, value]) => \`export \${key}=\${shellSingleQuote(String(value))}\`)`,
+      `      .join("; ")`,
+      `    const command = rawCommand.replaceAll("\${PLUGIN_ROOT}", directory)`,
+      `    return exports ? \`\${exports}; \${command}\` : command`,
+      `  }`,
+      "",
       `  const runHook = async (hook: GeneratedHook, context: Record<string, string>): Promise<void> => {`,
       `    try {`,
-      `      const command = hook.command.replaceAll("\${PLUGIN_ROOT}", directory)`,
+      `      const command = buildHookShellCommand(hook.command)`,
       `      const execution = $\`bash -lc \${command}\``,
       `      if (hook.timeout) {`,
       `        await Promise.race([`,
@@ -7383,8 +7660,6 @@ var OpenCodeGenerator = class extends Generator {
       `    }`,
       `  }`,
       "",
-      `  const shellSingleQuote = (input: string): string => \`'\${String(input ?? "").replace(/'/g, \`'"'"'\`)}'\``,
-      "",
       `  const runReadiness = async (mode: string, event: Record<string, unknown>): Promise<void> => {`,
       `    if (!READINESS_SCRIPT) return`,
       `    const payload = Buffer.from(JSON.stringify(event ?? {}), "utf-8").toString("base64")`,
@@ -7531,13 +7806,14 @@ var OpenCodeGenerator = class extends Generator {
     const commands = readCanonicalCommandFiles(commandsDir);
     const output = {};
     for (const command2 of commands) {
-      output[command2.commandId] = {
-        template: command2.body,
-        ...command2.description ? { description: command2.description } : {},
-        ...command2.argumentHint ? { argumentHint: command2.argumentHint } : {},
-        ...command2.agent ? { agent: command2.agent } : {},
-        ...typeof command2.subtask === "boolean" ? { subtask: command2.subtask } : {},
-        ...command2.model ? { model: command2.model } : {}
+      const metadata = getCanonicalCommandMetadata(command2);
+      output[metadata.commandId] = {
+        template: metadata.template,
+        ...metadata.description ? { description: metadata.description } : {},
+        ...metadata.argumentHint ? { argumentHint: metadata.argumentHint } : {},
+        ...metadata.agent ? { agent: metadata.agent } : {},
+        ...typeof metadata.subtask === "boolean" ? { subtask: metadata.subtask } : {},
+        ...metadata.model ? { model: metadata.model } : {}
       };
     }
     return output;
@@ -7548,41 +7824,36 @@ var OpenCodeGenerator = class extends Generator {
     const agents = readCanonicalAgentFiles(agentsDir);
     const output = {};
     for (const agent of agents) {
+      const metadata = getCanonicalAgentMetadata(agent);
       const definition = {
-        description: agent.description ?? `${agent.name} specialist.`
+        description: metadata.description
       };
-      if (agent.body) {
-        definition.prompt = agent.body;
-      }
-      if (typeof agent.frontmatter.mode === "string" && agent.frontmatter.mode) {
-        definition.mode = agent.frontmatter.mode;
+      if (metadata.body) {
+        definition.prompt = metadata.body;
       }
-      if (typeof agent.frontmatter.model === "string" && agent.frontmatter.model) {
-        definition.model = agent.frontmatter.model;
+      if (metadata.mode) {
+        definition.mode = metadata.mode;
       }
-      if (typeof agent.frontmatter.temperature === "number") {
-        definition.temperature = agent.frontmatter.temperature;
+      if (metadata.model) {
+        definition.model = metadata.model;
       }
-      if (typeof agent.frontmatter.steps === "number") {
-        definition.steps = agent.frontmatter.steps;
+      if (typeof metadata.temperature === "number") {
+        definition.temperature = metadata.temperature;
       }
-      if (typeof agent.frontmatter.maxSteps === "number" && definition.steps === void 0) {
-        definition.steps = agent.frontmatter.maxSteps;
+      if (typeof metadata.steps === "number") {
+        definition.steps = metadata.steps;
       }
-      if (typeof agent.frontmatter.disable === "boolean") {
-        definition.disable = agent.frontmatter.disable;
+      if (typeof metadata.disabled === "boolean") {
+        definition.disable = metadata.disabled;
       }
-      if (typeof agent.frontmatter.hidden === "boolean") {
-        definition.hidden = agent.frontmatter.hidden;
+      if (metadata.hidden) {
+        definition.hidden = metadata.hidden;
       }
-      if (typeof agent.frontmatter.color === "string" && agent.frontmatter.color) {
-        definition.color = agent.frontmatter.color;
+      if (metadata.color) {
+        definition.color = metadata.color;
       }
-      if (typeof agent.frontmatter.topP === "number") {
-        definition.topP = agent.frontmatter.topP;
-      }
-      if (typeof agent.frontmatter.top_p === "number" && definition.topP === void 0) {
-        definition.topP = agent.frontmatter.top_p;
+      if (typeof metadata.topP === "number") {
+        definition.topP = metadata.topP;
       }
       const legacyToolTranslation = translateLegacyOpenCodeTools(agent.frontmatter.tools);
       const permission = mergeOpenCodeMaps(
@@ -7596,15 +7867,12 @@ var OpenCodeGenerator = class extends Generator {
       if (tools) {
         definition.tools = tools;
       }
-      output[agent.name] = definition;
+      output[metadata.name] = definition;
     }
     return output;
   }
   getInstructionsContent() {
-    if (!this.config.instructions) return null;
-    const instructionsPath = this.resolveConfigPath(this.config.instructions, "instructions");
-    if (!existsSync12(instructionsPath)) return null;
-    return readFileSync6(instructionsPath, "utf-8").trim();
+    return readInstructionsContentSync(this.rootDir, this.config)?.trim() ?? null;
   }
   getOpenCodeHookPlan() {
     const plan = {
@@ -7664,7 +7932,7 @@ var OpenCodeGenerator = class extends Generator {
     const entries = readdirSync5(dir);
     const files = [];
     for (const entry of entries) {
-      const fullPath = resolve9(dir, entry);
+      const fullPath = resolve10(dir, entry);
       const stat = statSync4(fullPath);
       if (stat.isDirectory()) {
         files.push(...this.walkFiles(fullPath));
@@ -7676,14 +7944,14 @@ var OpenCodeGenerator = class extends Generator {
   }
   rewriteOpenCodeSkillAgentMentions() {
     if (!this.config.agents || !this.config.skills) return;
-    const skillsDir = resolve9(this.outDir, "skills");
-    if (!existsSync12(skillsDir)) return;
+    const skillsDir = resolve10(this.outDir, "skills");
+    if (!existsSync10(skillsDir)) return;
     const agentsDir = this.resolveConfigPath(this.config.agents, "agents");
     const agentNames = readCanonicalAgentFiles(agentsDir).map((agent) => agent.name).filter(Boolean);
     if (agentNames.length === 0) return;
     for (const filePath of this.walkFiles(skillsDir)) {
       if (basename3(filePath) !== "SKILL.md") continue;
-      const source = readFileSync6(filePath, "utf-8");
+      const source = readFileSync7(filePath, "utf-8");
       let rewritten = source;
       for (const agentName of agentNames) {
         const escaped = escapeRegExp(agentName);
@@ -7842,7 +8110,7 @@ var OpenHandsGenerator = class extends Generator {
 };
 
 // src/generators/warp/index.ts
-import { existsSync as existsSync13 } from "fs";
+import { existsSync as existsSync11 } from "fs";
 var WarpGenerator = class extends Generator {
   platform = "warp";
   async generate() {
@@ -7857,14 +8125,14 @@ var WarpGenerator = class extends Generator {
   async generateAgentsMd() {
     if (!this.config.instructions) return;
     const srcPath = this.resolveConfigPath(this.config.instructions, "instructions");
-    if (!existsSync13(srcPath)) return;
+    if (!existsSync11(srcPath)) return;
     const content = await readTextFile(srcPath);
     await this.writeFile("AGENTS.md", content);
   }
 };
 
 // src/generators/gemini-cli/index.ts
-import { existsSync as existsSync14 } from "fs";
+import { existsSync as existsSync12 } from "fs";
 var GeminiCliGenerator = class extends Generator {
   platform = "gemini-cli";
   async generate() {
@@ -7912,7 +8180,7 @@ var GeminiCliGenerator = class extends Generator {
   async generateInstructions() {
     if (!this.config.instructions) return;
     const srcPath = this.resolveConfigPath(this.config.instructions, "instructions");
-    if (!existsSync14(srcPath)) return;
+    if (!existsSync12(srcPath)) return;
     const content = await readTextFile(srcPath);
     const geminiMd = [
       `# ${this.config.brand?.displayName ?? this.config.name}`,
@@ -7926,7 +8194,7 @@ var GeminiCliGenerator = class extends Generator {
 };
 
 // src/generators/roo-code/index.ts
-import { existsSync as existsSync15 } from "fs";
+import { existsSync as existsSync13 } from "fs";
 var RooCodeGenerator = class extends Generator {
   platform = "roo-code";
   async generate() {
@@ -7941,7 +8209,7 @@ var RooCodeGenerator = class extends Generator {
   async generateRules() {
     if (!this.config.instructions) return;
     const srcPath = this.resolveConfigPath(this.config.instructions, "instructions");
-    if (!existsSync15(srcPath)) return;
+    if (!existsSync13(srcPath)) return;
     const content = await readTextFile(srcPath);
     await this.writeFile(".roorules", content);
   }
@@ -7952,7 +8220,7 @@ var RooCodeGenerator = class extends Generator {
 };
 
 // src/generators/cline/index.ts
-import { existsSync as existsSync16 } from "fs";
+import { existsSync as existsSync14 } from "fs";
 var ClineGenerator = class extends Generator {
   platform = "cline";
   async generate() {
@@ -7967,7 +8235,7 @@ var ClineGenerator = class extends Generator {
   async generateRules() {
     if (!this.config.instructions) return;
     const srcPath = this.resolveConfigPath(this.config.instructions, "instructions");
-    if (!existsSync16(srcPath)) return;
+    if (!existsSync14(srcPath)) return;
     const content = await readTextFile(srcPath);
     await this.writeFile(".clinerules", content);
   }
@@ -7978,7 +8246,7 @@ var ClineGenerator = class extends Generator {
 };
 
 // src/generators/amp/index.ts
-import { existsSync as existsSync17 } from "fs";
+import { existsSync as existsSync15 } from "fs";
 var AmpGenerator = class extends Generator {
   platform = "amp";
   async generate() {
@@ -7994,7 +8262,7 @@ var AmpGenerator = class extends Generator {
   async generateAgentMd() {
     if (!this.config.instructions) return;
     const srcPath = this.resolveConfigPath(this.config.instructions, "instructions");
-    if (!existsSync17(srcPath)) return;
+    if (!existsSync15(srcPath)) return;
     const content = await readTextFile(srcPath);
     const agentMd = [
       `# ${this.config.brand?.displayName ?? this.config.name}`,
@@ -8038,7 +8306,7 @@ var GENERATORS = {
   amp: AmpGenerator
 };
 function assertPathWithinRoot(rootDir, configPath, configKey) {
-  const resolvedPath = resolve10(rootDir, configPath);
+  const resolvedPath = resolve11(rootDir, configPath);
   const rel = relative6(rootDir, resolvedPath);
   if (rel.startsWith("..")) {
     throw new Error(`${configKey} path "${configPath}" resolves outside the project root.`);
@@ -8073,9 +8341,9 @@ function validateConfiguredPaths(config, rootDir) {
 }
 async function build(config, rootDir, options = {}) {
   const targets = options.targets ?? config.targets;
-  const outDir = resolve10(rootDir, config.outDir);
+  const outDir = resolve11(rootDir, config.outDir);
   const rel = relative6(rootDir, outDir);
-  if (rel.startsWith("..") || resolve10(outDir) === resolve10(rootDir)) {
+  if (rel.startsWith("..") || resolve11(outDir) === resolve11(rootDir)) {
     throw new Error(
       `outDir "${config.outDir}" resolves outside the project root. Refusing to delete.`
     );
@@ -8096,15 +8364,15 @@ async function build(config, rootDir, options = {}) {
 }
 
 // src/cli/agent.ts
-import { existsSync as existsSync23 } from "fs";
+import { existsSync as existsSync21 } from "fs";
 import { chmod, copyFile, mkdir as mkdir3, mkdtemp, readFile as readFile3, rm as rm2 } from "fs/promises";
 import { homedir, tmpdir as tmpdir2 } from "os";
-import { relative as relative10, resolve as resolve16 } from "path";
+import { relative as relative10, resolve as resolve17 } from "path";
 import { spawn as spawn2 } from "child_process";
 
 // src/cli/lint.ts
-import { existsSync as existsSync18, lstatSync, readdirSync as readdirSync6, readFileSync as readFileSync7 } from "fs";
-import { resolve as resolve11, relative as relative7, basename as basename4, dirname as dirname3 } from "path";
+import { existsSync as existsSync16, lstatSync, readdirSync as readdirSync6, readFileSync as readFileSync8 } from "fs";
+import { resolve as resolve12, relative as relative7, basename as basename4, dirname as dirname3 } from "path";
 
 // src/validation/platform-rules.ts
 var STANDARD_SKILL_FRONTMATTER = [
@@ -8280,7 +8548,7 @@ var PLATFORM_LIMIT_POLICIES = {
 var PLATFORM_VALIDATION_RULES = {
   "claude-code": {
     platform: "claude-code",
-    summary: "Claude Code plugins use an optional manifest at .claude-plugin/plugin.json with auto-discovery for skills, commands, agents, hooks, MCP, marketplaces, and output styles.",
+    summary: "Claude Code plugins use an optional manifest at .claude-plugin/plugin.json with auto-discovery for skills, commands, agents, hooks, MCP, marketplaces, output styles, and adjacent plugin assets like LSP, monitors, and themes.",
     limits: PLATFORM_LIMITS["claude-code"],
     limitPolicies: PLATFORM_LIMIT_POLICIES["claude-code"],
     skillDiscoveryDirs: [
@@ -8319,13 +8587,13 @@ var PLATFORM_VALIDATION_RULES = {
     hooks: {
       supported: true,
       files: ["hooks/hooks.json", ".claude-plugin/plugin.json", "~/.claude/settings.json", ".claude/settings.json", ".claude/settings.local.json"],
-      eventNames: ["SessionStart", "PreToolUse", "PostToolUse", "PermissionRequest", "TaskCreated", "TaskCompleted", "Stop", "Notification", "ConfigChange"],
-      notes: "Hook configs can be stored in hooks/hooks.json, inlined in plugin.json, added in settings files, or scoped through skill and agent frontmatter."
+      eventNames: ["SessionStart", "Setup", "UserPromptSubmit", "UserPromptExpansion", "PreToolUse", "PermissionRequest", "PermissionDenied", "PostToolUse", "PostToolUseFailure", "PostToolBatch", "Notification", "SubagentStart", "SubagentStop", "TaskCreated", "TaskCompleted", "Stop", "StopFailure", "TeammateIdle", "InstructionsLoaded", "ConfigChange", "CwdChanged", "FileChanged", "WorktreeCreate", "WorktreeRemove", "PreCompact", "PostCompact", "Elicitation", "ElicitationResult", "SessionEnd"],
+      notes: "Hook configs can be stored in hooks/hooks.json, inlined in plugin.json, added in settings files, or scoped through skill and agent frontmatter. Claude also documents a broader lifecycle event set than the older simplified Pluxx model."
     },
     instructions: {
       files: ["CLAUDE.md"],
       format: "markdown",
-      notes: "Claude keeps persistent instructions in CLAUDE.md and pushes longer procedures into skills."
+      notes: "Claude keeps persistent instructions in CLAUDE.md and pushes longer procedures into skills. Related enforcement and distribution config also depends on managed, user, project, and local settings scopes."
     },
     sources: [
       { label: "Claude Code MCP docs", url: "https://code.claude.com/docs/en/mcp" },
@@ -8339,6 +8607,9 @@ var PLATFORM_VALIDATION_RULES = {
       { label: "Claude Code plugins reference", url: "https://code.claude.com/docs/en/plugins-reference" },
       { label: "Claude Code hooks guide", url: "https://code.claude.com/docs/en/hooks-guide" },
       { label: "Claude Code hooks docs", url: "https://code.claude.com/docs/en/hooks" },
+      { label: "Claude Code settings docs", url: "https://code.claude.com/docs/en/settings" },
+      { label: "Claude Code permissions docs", url: "https://code.claude.com/docs/en/permissions" },
+      { label: "Claude Code memory docs", url: "https://code.claude.com/docs/en/memory" },
       { label: "Claude Code skills docs", url: "https://code.claude.com/docs/en/skills" },
       { label: "Claude Code sub-agents docs", url: "https://code.claude.com/docs/en/sub-agents" },
       { label: "Claude Code env vars docs", url: "https://code.claude.com/docs/en/env-vars" }
@@ -8377,13 +8648,13 @@ var PLATFORM_VALIDATION_RULES = {
     hooks: {
       supported: true,
       files: ["hooks/hooks.json", ".cursor/hooks.json", "~/.cursor/hooks.json"],
-      eventNames: ["sessionStart", "preToolUse", "postToolUse", "subagentStart", "subagentStop", "beforeShellExecution", "afterShellExecution"],
-      notes: "Cursor plugin hooks live under hooks/hooks.json; project and user hooks also exist separately and reload on save."
+      eventNames: ["sessionStart", "sessionEnd", "preToolUse", "postToolUse", "postToolUseFailure", "subagentStart", "subagentStop", "beforeShellExecution", "afterShellExecution", "beforeMCPExecution", "afterMCPExecution", "beforeReadFile", "afterFileEdit", "beforeSubmitPrompt", "preCompact", "stop", "afterAgentResponse", "afterAgentThought", "beforeTabFileRead", "afterTabFileEdit"],
+      notes: "Cursor plugin hooks live under hooks/hooks.json; project and user hooks also exist separately and reload on save. The official event surface spans both Agent and Tab flows."
     },
     instructions: {
       files: ["rules/", "AGENTS.md"],
       format: "mdc + markdown",
-      notes: "rules/ is the plugin-native instruction surface. AGENTS.md remains useful as shared repo guidance. Cursor subagents use markdown files under .cursor/agents or ~/.cursor/agents (with .claude/.codex compatibility paths)."
+      notes: "rules/ is the plugin-native instruction surface. AGENTS.md remains useful as shared repo guidance. Cursor subagents use markdown files under .cursor/agents or ~/.cursor/agents (with .claude/.codex compatibility paths). Cursor rules do not apply to Tab."
     },
     sources: [
       { label: "Cursor plugins overview", url: "https://cursor.com/docs/plugins" },
@@ -8403,7 +8674,7 @@ var PLATFORM_VALIDATION_RULES = {
   },
   "codex": {
     platform: "codex",
-    summary: "Codex plugins use .codex-plugin/plugin.json with skills, optional .mcp.json and .app.json, marketplace catalogs, cache installs, AGENTS.md instructions, and separate hook configuration.",
+    summary: "Codex plugins use .codex-plugin/plugin.json with skills, optional .mcp.json and .app.json, marketplace catalogs, cache installs, AGENTS.md instructions, and native bundled hook support plus broader project or user hook config.",
     limits: PLATFORM_LIMITS["codex"],
     limitPolicies: PLATFORM_LIMIT_POLICIES["codex"],
     skillDiscoveryDirs: [
@@ -8431,9 +8702,9 @@ var PLATFORM_VALIDATION_RULES = {
     },
     hooks: {
       supported: true,
-      files: [".codex/hooks.json", "~/.codex/hooks.json"],
+      files: ["hooks/hooks.json", ".codex/hooks.json", "~/.codex/hooks.json"],
       eventNames: ["SessionStart", "PreToolUse", "PermissionRequest", "PostToolUse", "UserPromptSubmit", "Stop"],
-      notes: "Codex documents hooks in project/user config, guarded by the codex_hooks feature flag; the current plugin build guide does not document plugin-packaged hooks."
+      notes: "Codex documents hooks in project and user config, and the hooks docs still mention the codex_hooks feature flag/runtime caveat. The official hooks docs also cover plugin-bundled hooks, which Pluxx now emits at hooks/hooks.json."
     },
     instructions: {
       files: ["AGENTS.md", "AGENTS.override.md"],
@@ -8451,6 +8722,9 @@ var PLATFORM_VALIDATION_RULES = {
       { label: "Codex hooks docs", url: "https://developers.openai.com/codex/hooks" },
       { label: "Codex skills docs", url: "https://developers.openai.com/codex/skills" },
       { label: "Codex MCP docs", url: "https://developers.openai.com/codex/mcp" },
+      { label: "Codex basic config docs", url: "https://developers.openai.com/codex/config-basic" },
+      { label: "Codex agent approvals and security docs", url: "https://developers.openai.com/codex/agent-approvals-security" },
+      { label: "Codex app commands docs", url: "https://developers.openai.com/codex/app/commands" },
       { label: "Codex AGENTS.md guide", url: "https://developers.openai.com/codex/guides/agents-md" },
       { label: "Codex subagents docs", url: "https://developers.openai.com/codex/subagents" },
       { label: "Codex subagents concept docs", url: "https://developers.openai.com/codex/concepts/subagents" },
@@ -8461,7 +8735,7 @@ var PLATFORM_VALIDATION_RULES = {
   },
   "opencode": {
     platform: "opencode",
-    summary: "OpenCode plugins are code-first JS or TS modules loaded from local plugin dirs or npm references in config, with native skills, commands, agents, MCP, and permission surfaces.",
+    summary: "OpenCode plugins are code-first JS or TS modules loaded from local plugin dirs or npm references in config, with native skills, commands, agents, MCP, permission, custom-tool, and plugin-event surfaces.",
     limits: PLATFORM_LIMITS["opencode"],
     limitPolicies: PLATFORM_LIMIT_POLICIES["opencode"],
     skillDiscoveryDirs: [
@@ -8491,13 +8765,13 @@ var PLATFORM_VALIDATION_RULES = {
     hooks: {
       supported: true,
       files: ["plugin module (index.ts/index.js)"],
-      eventNames: [],
-      notes: "OpenCode hooks are plugin event handlers implemented in code, not a separate hooks.json file."
+      eventNames: ["command.executed", "file.edited", "file.watcher.updated", "installation.updated", "lsp.client.diagnostics", "lsp.updated", "message.part.removed", "message.part.updated", "message.removed", "message.updated", "permission.asked", "permission.replied", "server.connected", "session.created", "session.compacted", "session.deleted", "session.diff", "session.error", "session.idle", "session.status", "session.updated", "todo.updated", "shell.env", "tool.execute.before", "tool.execute.after", "tui.prompt.append", "tui.command.execute", "tui.toast.show", "experimental.session.compacting"],
+      notes: "OpenCode hooks are plugin event handlers implemented in code, not a separate hooks.json file. The official surface is an event bus rather than a small lifecycle-hook JSON schema."
     },
     instructions: {
       files: ["AGENTS.md", "CLAUDE.md", "opencode.json"],
       format: "markdown + json + code",
-      notes: "OpenCode supports AGENTS.md, CLAUDE.md fallback, config instructions, and plugin runtime instruction injection."
+      notes: "OpenCode supports AGENTS.md, CLAUDE.md fallback, config instructions, and plugin runtime instruction injection. Config layering also includes remote config, managed config files, and macOS managed preferences."
     },
     sources: [
       { label: "OpenCode SDK docs", url: "https://opencode.ai/docs/sdk/" },
@@ -8868,8 +9142,8 @@ var CORE_FOUR_PRIMITIVE_CAPABILITIES = {
       },
       hooks: {
         mode: "translate",
-        nativeSurfaces: [".codex/hooks.json", "~/.codex/hooks.json"],
-        notes: "Hooks are native, but they currently live next to config layers rather than inside the documented plugin bundle structure."
+        nativeSurfaces: ["hooks/hooks.json", ".codex/hooks.json", "~/.codex/hooks.json"],
+        notes: "Hooks are native. Pluxx bundles translated Codex hooks in the plugin and still tracks the project/user config paths plus the codex_hooks feature-gate caveat."
       },
       permissions: {
         mode: "translate",
@@ -9136,12 +9410,15 @@ var CODEX_RULES = {
 };
 var CLAUDE_CODE_HOOK_EVENTS = [
   "SessionStart",
+  "Setup",
   "PreToolUse",
   "PostToolUse",
   "UserPromptSubmit",
+  "UserPromptExpansion",
   "PermissionRequest",
   "PermissionDenied",
   "PostToolUseFailure",
+  "PostToolBatch",
   "Notification",
   "SubagentStart",
   "SubagentStop",
@@ -9162,7 +9439,7 @@ var CLAUDE_CODE_HOOK_EVENTS = [
   "ElicitationResult",
   "SessionEnd"
 ];
-var CLAUDE_CODE_HOOK_TYPES = ["command", "http", "prompt", "agent"];
+var CLAUDE_CODE_HOOK_TYPES = ["command", "http", "mcp_tool", "prompt", "agent"];
 var AGENT_FORBIDDEN_FRONTMATTER = ["hooks", "mcpServers", "permissionMode"];
 var SEMVER_REGEX = /^\d+\.\d+\.\d+$/;
 var PLUGIN_NAME_KEBAB = /^[a-z0-9]+(-[a-z0-9]+)*$/;
@@ -9585,8 +9862,8 @@ function getBundledRuntimePayloadDirs(rootDir, config) {
   ].filter((entry) => typeof entry === "string" && entry.length > 0).map((entry) => resolveBundledPassthroughDir(rootDir, entry)).filter((entry) => Boolean(entry));
 }
 function resolveBundledPassthroughDir(rootDir, entry) {
-  const resolvedPath = resolve11(rootDir, entry);
-  if (!existsSync18(resolvedPath)) return null;
+  const resolvedPath = resolve12(rootDir, entry);
+  if (!existsSync16(resolvedPath)) return null;
   try {
     const stats = lstatSync(resolvedPath);
     if (!stats.isDirectory()) return null;
@@ -9601,8 +9878,8 @@ function findLocalStdioRuntimePaths(rootDir, server) {
   const candidates = [server.command, ...server.args ?? []];
   for (const candidate of candidates) {
     if (!isLikelyLocalRuntimePath(candidate)) continue;
-    const resolvedPath = resolve11(rootDir, candidate);
-    if (!existsSync18(resolvedPath)) continue;
+    const resolvedPath = resolve12(rootDir, candidate);
+    if (!existsSync16(resolvedPath)) continue;
     try {
       const stats = lstatSync(resolvedPath);
       const runtimeDir = stats.isDirectory() ? resolvedPath : dirname3(resolvedPath);
@@ -9718,11 +9995,16 @@ function lintInstructionsFileLimits(config, dir, issues) {
   for (const target of config.targets) {
     const limits = PLATFORM_LIMITS[target];
     if (limits.instructionsMaxBytes === null) continue;
-    const instructionsFiles = ["AGENTS.md", "CLAUDE.md", "INSTRUCTIONS.md"];
+    const configuredInstructionsPath = resolveInstructionsPath(dir, config);
+    const instructionsFiles = /* @__PURE__ */ new Set(["AGENTS.md", "CLAUDE.md", "INSTRUCTIONS.md"]);
+    if (configuredInstructionsPath) {
+      instructionsFiles.add(relative7(dir, configuredInstructionsPath).replace(/\\/g, "/"));
+    }
     for (const file of instructionsFiles) {
-      const filePath = resolve11(dir, file);
-      if (!existsSync18(filePath)) continue;
-      const content = readFileSync7(filePath, "utf-8");
+      const filePath = resolve12(dir, file);
+      if (!existsSync16(filePath)) continue;
+      const content = file === relative7(dir, configuredInstructionsPath ?? "").replace(/\\/g, "/") ? readInstructionsContentSync(dir, config) : readFileSync8(filePath, "utf-8");
+      if (content === null) continue;
       const byteSize = Buffer.byteLength(content, "utf-8");
       if (byteSize > limits.instructionsMaxBytes) {
         pushIssue(issues, {
@@ -9742,9 +10024,9 @@ function lintRulesFileLimits(config, dir, issues) {
     if (limits.rulesMaxLines === null) continue;
     const rulesFiles = [".cursorrules", ".clinerules"];
     for (const file of rulesFiles) {
-      const filePath = resolve11(dir, file);
-      if (!existsSync18(filePath)) continue;
-      const content = readFileSync7(filePath, "utf-8");
+      const filePath = resolve12(dir, file);
+      if (!existsSync16(filePath)) continue;
+      const content = readFileSync8(filePath, "utf-8");
       const lineCount = content.split(/\r?\n/).length;
       if (lineCount > limits.rulesMaxLines) {
         pushIssue(issues, {
@@ -9763,8 +10045,8 @@ function lintPluginDirectoryPlacement(dir, issues) {
   const nestedParents = [".claude-plugin", ".plugin"];
   for (const parent of nestedParents) {
     for (const subDir of pluginSubDirs) {
-      const nestedPath = resolve11(dir, parent, subDir);
-      if (existsSync18(nestedPath)) {
+      const nestedPath = resolve12(dir, parent, subDir);
+      if (existsSync16(nestedPath)) {
         pushIssue(issues, {
           level: "error",
           code: "plugin-dir-nested",
@@ -9866,11 +10148,11 @@ function lintAgentFrontmatter(agentFiles, issues, frontmatterCache) {
   }
 }
 function collectMarkdownFiles(dir) {
-  if (!existsSync18(dir)) return [];
+  if (!existsSync16(dir)) return [];
   const files = [];
   const entries = readdirSync6(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = resolve11(dir, entry.name);
+    const fullPath = resolve12(dir, entry.name);
     if (entry.isDirectory()) {
       files.push(...collectMarkdownFiles(fullPath));
     } else if (entry.isFile() && entry.name.endsWith(".md")) {
@@ -9897,7 +10179,7 @@ function lintAgentIsolation(agentFiles, issues, frontmatterCache) {
 }
 function lintOpenCodeAgentFrontmatter(dir, config, issues) {
   if (!config.targets.includes("opencode") || !config.agents) return;
-  const agents = readCanonicalAgentFiles(resolve11(dir, config.agents));
+  const agents = readCanonicalAgentFiles(resolve12(dir, config.agents));
   for (const agent of agents) {
     if (!("tools" in agent.frontmatter)) continue;
     if (hasCanonicalAgentPermission(agent.frontmatter.permission)) continue;
@@ -9913,6 +10195,77 @@ function lintOpenCodeAgentFrontmatter(dir, config, issues) {
 function hasCanonicalAgentPermission(value) {
   return !!value && typeof value === "object" && !Array.isArray(value);
 }
+function lintAgentTranslationExplainability(dir, config, issues) {
+  if (!config.agents) return;
+  const agents = readCanonicalAgentFiles(resolve12(dir, config.agents));
+  for (const agent of agents) {
+    const metadata = getCanonicalAgentMetadata(agent);
+    const relativePath = relative7(dir, agent.filePath).replace(/\\/g, "/");
+    if (config.targets.includes("cursor")) {
+      const cursorDegradedFields = [];
+      if (metadata.hidden) cursorDegradedFields.push("hidden");
+      if (metadata.modelReasoningEffort) cursorDegradedFields.push("model_reasoning_effort");
+      if (metadata.sandboxMode) cursorDegradedFields.push("sandbox_mode");
+      if (metadata.permission) cursorDegradedFields.push("permission");
+      if (metadata.tools !== void 0) cursorDegradedFields.push("tools");
+      if (metadata.memory) cursorDegradedFields.push("memory");
+      if (typeof metadata.background === "boolean") cursorDegradedFields.push("background");
+      if (metadata.isolation) cursorDegradedFields.push("isolation");
+      if (cursorDegradedFields.length > 0) {
+        pushIssue(issues, {
+          level: "warning",
+          code: "cursor-agent-translation",
+          message: `Agent fields ${cursorDegradedFields.map((field) => `"${field}"`).join(", ")} are not preserved as first-class Cursor agent frontmatter today. Pluxx translates that intent through subagent framing and generated notes instead.`,
+          file: relativePath,
+          platform: "Cursor"
+        });
+      }
+    }
+    if (config.targets.includes("codex")) {
+      const codexDegradedFields = [];
+      if (metadata.hidden) codexDegradedFields.push("hidden");
+      if (metadata.permission) codexDegradedFields.push("permission");
+      if (metadata.tools !== void 0) codexDegradedFields.push("tools");
+      if (metadata.skills) codexDegradedFields.push("skills");
+      if (metadata.memory) codexDegradedFields.push("memory");
+      if (typeof metadata.background === "boolean") codexDegradedFields.push("background");
+      if (metadata.isolation) codexDegradedFields.push("isolation");
+      if (metadata.color) codexDegradedFields.push("color");
+      if (codexDegradedFields.length > 0) {
+        pushIssue(issues, {
+          level: "warning",
+          code: "codex-agent-translation",
+          message: `Agent fields ${codexDegradedFields.map((field) => `"${field}"`).join(", ")} are not native Codex TOML fields today. Pluxx keeps the specialist behavior, but translates that intent through developer instructions and companion surfaces instead.`,
+          file: relativePath,
+          platform: "Codex"
+        });
+      }
+    }
+  }
+}
+function lintCommandTranslationExplainability(dir, config, issues) {
+  if (!config.commands) return;
+  const commands = readCanonicalCommandFiles(resolve12(dir, config.commands));
+  for (const command2 of commands) {
+    const metadata = getCanonicalCommandMetadata(command2);
+    const relativePath = relative7(dir, command2.filePath).replace(/\\/g, "/");
+    if (config.targets.includes("codex")) {
+      const degradedFields = [];
+      if (metadata.agent) degradedFields.push("agent");
+      if (typeof metadata.subtask === "boolean") degradedFields.push("subtask");
+      if (metadata.model) degradedFields.push("model");
+      if (degradedFields.length > 0) {
+        pushIssue(issues, {
+          level: "warning",
+          code: "codex-command-translation",
+          message: `Command fields ${degradedFields.map((field) => `"${field}"`).join(", ")} are not native Codex plugin slash-command fields today. Pluxx keeps the workflow, but degrades those semantics into AGENTS.md routing guidance and \`.codex/commands.generated.json\`.`,
+          file: relativePath,
+          platform: "Codex"
+        });
+      }
+    }
+  }
+}
 function lintAbsolutePaths(config, issues) {
   const absolutePathPattern = /^\/[a-zA-Z]|^[A-Z]:\\/;
   if (config.hooks) {
@@ -9948,10 +10301,10 @@ function lintAbsolutePaths(config, issues) {
   }
 }
 function lintSettingsJson(dir, issues) {
-  const settingsPath = resolve11(dir, "settings.json");
-  if (!existsSync18(settingsPath)) return;
+  const settingsPath = resolve12(dir, "settings.json");
+  if (!existsSync16(settingsPath)) return;
   try {
-    const content = JSON.parse(readFileSync7(settingsPath, "utf-8"));
+    const content = JSON.parse(readFileSync8(settingsPath, "utf-8"));
     if (typeof content === "object" && content !== null) {
       const keys = Object.keys(content);
       for (const key of keys) {
@@ -10016,11 +10369,11 @@ function lintCodexHooksExternalConfig(config, issues) {
   const codexOverrides = asRecord2(config.platforms?.codex);
   const features = codexOverrides ? asRecord2(codexOverrides.features) : null;
   const hasPluxxCodexHooksFlag = features && features.codex_hooks === true;
-  const featureNote = hasPluxxCodexHooksFlag ? "Pluxx will generate `.codex/hooks.generated.json` as a mirror, but you still need to wire the hooks into Codex itself." : "Pluxx will generate `.codex/hooks.generated.json` as a mirror, but you still need to copy or adapt it into `~/.codex/hooks.json` or `<repo>/.codex/hooks.json` and enable `codex_hooks = true` in Codex itself.";
+  if (hasPluxxCodexHooksFlag) return;
   pushIssue(issues, {
     level: "warning",
     code: "codex-hooks-external-config",
-    message: `Codex plugin docs currently separate hook configuration from plugin packaging, so Pluxx emits hook guidance as external Codex config rather than as a plugin-bundled hook surface. ${featureNote}`,
+    message: "Pluxx now bundles Codex hooks at `hooks/hooks.json`, but Codex hook loading may still be guarded by `codex_hooks = true` in the host runtime. If bundled hooks do not activate, enable that feature flag and reload Codex.",
     file: "pluxx.config.ts",
     platform: "Codex"
   });
@@ -10084,6 +10437,15 @@ function lintCursorHooks(config, issues) {
     for (const entry of hookEntries) {
       if (!entry || typeof entry !== "object") continue;
       const rec = entry;
+      if (rec.type && rec.type !== "command" && rec.type !== "prompt") {
+        pushIssue(issues, {
+          level: "warning",
+          code: "cursor-hook-type-unsupported",
+          message: `Cursor does not document hook type "${String(rec.type)}". Pluxx currently preserves only command and prompt hooks on the Cursor hook surface.`,
+          file: "pluxx.config.ts",
+          platform: "Cursor"
+        });
+      }
       const cursorLoopLimitEvents = getHookFieldSupportedEvents("cursor", "loop_limit");
       if (rec.loop_limit !== void 0 && !cursorLoopLimitEvents.includes(hookEvent)) {
         pushIssue(issues, {
@@ -10111,19 +10473,46 @@ function lintCursorSkillFrontmatter(config, skillFiles, issues, frontmatterCache
     for (const [key] of parsed.frontmatterFields) {
       for (const [target, supported] of supportedByTarget.entries()) {
         if (supported.has(key)) continue;
-        const issue = target === "cursor" ? {
-          code: "cursor-skill-frontmatter-unsupported",
-          message: `Skill frontmatter field "${key}" is not supported by Cursor. Supported: ${[...supported].join(", ")}`,
-          platform: "Cursor"
-        } : target === "codex" ? {
-          code: "codex-skill-frontmatter-translation",
-          message: `Skill frontmatter field "${key}" is not part of documented Codex skill frontmatter. Pluxx may need to translate that intent through AGENTS.md, .codex/agents/*.toml, permissions companions, or runtime config instead of preserving it on SKILL.md.`,
-          platform: "Codex"
-        } : {
-          code: "opencode-skill-frontmatter-translation",
-          message: `Skill frontmatter field "${key}" is not part of documented OpenCode skill frontmatter. Pluxx may need to translate that intent through commands, agents, opencode.json, or plugin runtime code instead of preserving it on SKILL.md.`,
-          platform: "OpenCode"
-        };
+        let issue;
+        if (target === "cursor") {
+          issue = {
+            code: "cursor-skill-frontmatter-unsupported",
+            message: `Skill frontmatter field "${key}" is not supported by Cursor. Supported: ${[...supported].join(", ")}`,
+            platform: "Cursor"
+          };
+        } else if (target === "codex") {
+          const codexFieldTranslation = {
+            "argument-hint": "Pluxx currently translates `argument-hint` into Codex command or routing guidance rather than documented Codex skill frontmatter.",
+            arguments: "Pluxx currently translates skill `arguments` into Codex command or routing guidance rather than documented Codex skill frontmatter.",
+            "allowed-tools": "Pluxx currently translates `allowed-tools` into Codex permission companions or external config rather than documented Codex skill frontmatter.",
+            context: "Pluxx currently treats skill `context` as companion instruction intent because Codex does not document an equivalent skill frontmatter field.",
+            agent: "Pluxx currently translates skill `agent` intent through Codex custom agents or routing guidance rather than documented Codex skill frontmatter.",
+            hooks: "Pluxx currently translates skill-local `hooks` intent through bundled Codex hooks, where skill-local attachment is lost.",
+            paths: "Pluxx currently translates skill `paths` into surrounding instruction or routing context because Codex does not document an equivalent skill frontmatter field.",
+            shell: "Pluxx currently translates skill `shell` intent through command or runtime guidance because Codex does not document an equivalent skill frontmatter field."
+          };
+          issue = {
+            code: "codex-skill-frontmatter-translation",
+            message: codexFieldTranslation[key] ?? `Skill frontmatter field "${key}" is not part of documented Codex skill frontmatter. Pluxx may need to translate that intent through AGENTS.md, .codex/agents/*.toml, permissions companions, or runtime config instead of preserving it on SKILL.md.`,
+            platform: "Codex"
+          };
+        } else {
+          const opencodeFieldTranslation = {
+            "argument-hint": "Pluxx currently translates `argument-hint` into OpenCode commands or runtime command metadata rather than documented OpenCode skill frontmatter.",
+            arguments: "Pluxx currently translates skill `arguments` into OpenCode commands or runtime command metadata rather than documented OpenCode skill frontmatter.",
+            "allowed-tools": "Pluxx currently translates `allowed-tools` into OpenCode permission config rather than documented OpenCode skill frontmatter.",
+            context: "Pluxx currently translates skill `context` through runtime instruction injection or neighboring config because OpenCode does not document an equivalent skill frontmatter field.",
+            agent: "Pluxx currently translates skill `agent` intent through OpenCode agents or runtime routing rather than documented OpenCode skill frontmatter.",
+            hooks: "Pluxx currently translates skill-local `hooks` intent through OpenCode runtime event handlers, where skill-local attachment is lost.",
+            paths: "Pluxx currently translates skill `paths` into runtime or instruction context because OpenCode does not document an equivalent skill frontmatter field.",
+            shell: "Pluxx currently translates skill `shell` intent through runtime code or command execution guidance because OpenCode does not document an equivalent skill frontmatter field."
+          };
+          issue = {
+            code: "opencode-skill-frontmatter-translation",
+            message: opencodeFieldTranslation[key] ?? `Skill frontmatter field "${key}" is not part of documented OpenCode skill frontmatter. Pluxx may need to translate that intent through commands, agents, opencode.json, or plugin runtime code instead of preserving it on SKILL.md.`,
+            platform: "OpenCode"
+          };
+        }
         pushIssue(issues, {
           level: "warning",
           file: skillFile,
@@ -10307,6 +10696,20 @@ function lintPermissions(config, issues) {
       platform: "Codex"
     });
   }
+  if (config.targets.includes("cursor")) {
+    const cursorNuance = [];
+    if (rules.some((rule) => rule.kind === "Skill")) cursorNuance.push("Skill(...)");
+    if (rules.some((rule) => rule.kind === "MCP")) cursorNuance.push("MCP(...)");
+    if (cursorNuance.length > 0) {
+      pushIssue(issues, {
+        level: "warning",
+        code: "cursor-permissions-translation",
+        message: `Cursor permission intent is split across generated hooks, CLI permission config, and subagent/tool framing. ${cursorNuance.join(" and ")} selectors are especially important to verify because they do not map to one first-class native Cursor permission field.`,
+        file: "pluxx.config.ts",
+        platform: "Cursor"
+      });
+    }
+  }
   if (rules.some((rule) => rule.kind === "Skill")) {
     const limitedTargets = config.targets.filter((target) => !["claude-code", "codex", "opencode"].includes(target));
     if (limitedTargets.length > 0) {
@@ -10393,11 +10796,13 @@ async function lintProject(dir = process.cwd(), options = {}) {
   lintSettingsJson(dir, issues);
   lintLegacyCommandsDir(dir, lintConfig, issues);
   lintHookEvents(lintConfig, issues);
-  const agentsDir = resolve11(dir, lintConfig.agents ?? "agents");
-  const agentFiles = existsSync18(agentsDir) ? collectMarkdownFiles(agentsDir) : [];
+  const agentsDir = resolve12(dir, lintConfig.agents ?? "agents");
+  const agentFiles = existsSync16(agentsDir) ? collectMarkdownFiles(agentsDir) : [];
   lintAgentFrontmatter(agentFiles, issues, frontmatterCache);
   lintAgentIsolation(agentFiles, issues, frontmatterCache);
   lintOpenCodeAgentFrontmatter(dir, { ...lintConfig, agents: lintConfig.agents ?? "./agents/" }, issues);
+  lintAgentTranslationExplainability(dir, { ...lintConfig, agents: lintConfig.agents ?? "./agents/" }, issues);
+  lintCommandTranslationExplainability(dir, lintConfig, issues);
   lintMcpUrls(lintConfig, issues);
   lintMcpRuntimeState(dir, lintConfig, issues);
   lintInstallerOwnedRuntimeScripts(lintConfig, issues);
@@ -10414,9 +10819,9 @@ async function lintProject(dir = process.cwd(), options = {}) {
   lintCodexCommandGuidance(lintConfig, issues);
   lintCursorHooks(lintConfig, issues);
   lintCursorRuleContentLimits(lintConfig, issues);
-  const skillsDir = resolve11(dir, lintConfig.skills);
+  const skillsDir = resolve12(dir, lintConfig.skills);
   let skillFiles = [];
-  if (!existsSync18(skillsDir)) {
+  if (!existsSync16(skillsDir)) {
     pushIssue(issues, {
       level: "error",
       code: "skills-dir-missing",
@@ -10460,7 +10865,7 @@ function printLintResult(result, dir = process.cwd()) {
   for (const issue of visibleIssues) {
     const levelLabel = issue.level === "error" ? "ERROR" : "WARN ";
     const platformLabel = issue.platform ? `[${issue.platform}] ` : "";
-    const loc = issue.file ? `${relative7(dir, resolve11(dir, issue.file))}: ` : "";
+    const loc = issue.file ? `${relative7(dir, resolve12(dir, issue.file))}: ` : "";
     console.log(`${levelLabel} ${issue.code} ${platformLabel}${loc}${issue.message}`);
   }
   const primitiveLines = renderPrimitiveTranslationSummary(result.primitiveSummary);
@@ -10486,17 +10891,17 @@ async function runLint(dir = process.cwd()) {
 }
 
 // src/cli/test.ts
-import { existsSync as existsSync21 } from "fs";
-import { resolve as resolve14 } from "path";
+import { existsSync as existsSync19 } from "fs";
+import { resolve as resolve15 } from "path";
 
 // src/cli/eval.ts
-import { existsSync as existsSync20, readFileSync as readFileSync8 } from "fs";
-import { resolve as resolve13 } from "path";
+import { existsSync as existsSync18, readFileSync as readFileSync9 } from "fs";
+import { resolve as resolve14 } from "path";
 
 // src/cli/init-from-mcp.ts
-import { existsSync as existsSync19, lstatSync as lstatSync2 } from "fs";
+import { existsSync as existsSync17, lstatSync as lstatSync2 } from "fs";
 import { mkdir as mkdir2 } from "fs/promises";
-import { basename as basename5, dirname as dirname4, relative as relative8, resolve as resolve12 } from "path";
+import { basename as basename5, dirname as dirname4, relative as relative8, resolve as resolve13 } from "path";
 
 // src/user-config.ts
 var ENV_VAR_NAME = /^[A-Za-z_][A-Za-z0-9_]*$/;
@@ -10804,10 +11209,10 @@ async function writeMcpScaffold(options) {
 }
 async function applyMcpScaffoldPlan(rootDir, plan) {
   for (const file of plan.files) {
-    const filePath = resolve12(rootDir, file.relativePath);
+    const filePath = resolve13(rootDir, file.relativePath);
     const parentDir = file.relativePath.split("/").slice(0, -1).join("/");
     if (parentDir) {
-      await mkdir2(resolve12(rootDir, parentDir), { recursive: true });
+      await mkdir2(resolve13(rootDir, parentDir), { recursive: true });
     }
     await writeTextFile(filePath, file.content);
   }
@@ -10835,9 +11240,9 @@ async function planMcpScaffold(options) {
   const permissions = options.permissions ?? (options.approveMcpTools ? { allow: [`MCP(${serverName}.*)`] } : void 0);
   const passthroughPaths = inferLocalRuntimePassthroughPaths(options.rootDir, options.source);
   const runtimeAuthMode = options.runtimeAuthMode ?? (options.source.transport !== "stdio" && options.source.auth?.type === "platform" ? "platform" : "inline");
-  const instructionsPath = resolve12(options.rootDir, "INSTRUCTIONS.md");
-  const skillRoot = resolve12(options.rootDir, "skills");
-  const commandsRoot = resolve12(options.rootDir, "commands");
+  const instructionsPath = resolve13(options.rootDir, "INSTRUCTIONS.md");
+  const skillRoot = resolve13(options.rootDir, "skills");
+  const commandsRoot = resolve13(options.rootDir, "commands");
   const userConfigSource = {
     targets: options.targets,
     mcp: {
@@ -10857,7 +11262,7 @@ async function planMcpScaffold(options) {
   const taxonomyPath = MCP_TAXONOMY_PATH;
   const files = [];
   const addPlannedFile = async (relativePath, content) => {
-    const filePath = resolve12(options.rootDir, relativePath);
+    const filePath = resolve13(options.rootDir, relativePath);
     const action = await planTextFileAction(filePath, content);
     files.push({ relativePath, content, action });
   };
@@ -10907,7 +11312,7 @@ async function planMcpScaffold(options) {
   );
   for (const skill of plannedSkills) {
     const relativeSkillPath = `skills/${skill.dirName}`;
-    const skillPath = resolve12(skillRoot, skill.dirName, "SKILL.md");
+    const skillPath = resolve13(skillRoot, skill.dirName, "SKILL.md");
     await addPlannedFile(
       `${relativeSkillPath}/SKILL.md`,
       wrapManagedMarkdown(
@@ -10924,7 +11329,7 @@ async function planMcpScaffold(options) {
   }
   for (const skill of plannedCommands) {
     const relativeCommandPath = `commands/${skill.dirName}.md`;
-    const commandPath = resolve12(commandsRoot, `${skill.dirName}.md`);
+    const commandPath = resolve13(commandsRoot, `${skill.dirName}.md`);
     await addPlannedFile(
       relativeCommandPath,
       buildCommandContent(
@@ -11348,8 +11753,8 @@ function inferLocalRuntimePassthroughPaths(rootDir, source) {
   const candidates = [source.command, ...source.args ?? []];
   for (const candidate of candidates) {
     if (!isLikelyLocalRuntimePath2(candidate)) continue;
-    const resolvedPath = resolve12(rootDir, candidate);
-    if (!existsSync19(resolvedPath)) continue;
+    const resolvedPath = resolve13(rootDir, candidate);
+    if (!existsSync17(resolvedPath)) continue;
     const stats = lstatSync2(resolvedPath);
     const runtimeDir = stats.isDirectory() ? resolvedPath : dirname4(resolvedPath);
     const normalized = normalizePassthroughDir(rootDir, runtimeDir);
@@ -11401,6 +11806,16 @@ function serializeHooks(hooks) {
         entry.command ? `command: ${JSON.stringify(entry.command)}` : null,
         entry.prompt ? `prompt: ${JSON.stringify(entry.prompt)}` : null,
         entry.model ? `model: ${JSON.stringify(entry.model)}` : null,
+        entry.url ? `url: ${JSON.stringify(entry.url)}` : null,
+        entry.headers ? `headers: ${JSON.stringify(entry.headers)}` : null,
+        entry.allowedEnvVars ? `allowedEnvVars: ${JSON.stringify(entry.allowedEnvVars)}` : null,
+        entry.server ? `server: ${JSON.stringify(entry.server)}` : null,
+        entry.tool ? `tool: ${JSON.stringify(entry.tool)}` : null,
+        entry.input ? `input: ${JSON.stringify(entry.input)}` : null,
+        entry.if ? `if: ${JSON.stringify(entry.if)}` : null,
+        entry.async !== void 0 ? `async: ${entry.async}` : null,
+        entry.asyncRewake !== void 0 ? `asyncRewake: ${entry.asyncRewake}` : null,
+        entry.shell ? `shell: ${JSON.stringify(entry.shell)}` : null,
         entry.timeout !== void 0 ? `timeout: ${entry.timeout}` : null,
         entry.matcher ? `matcher: ${JSON.stringify(entry.matcher)}` : null,
         entry.failClosed !== void 0 ? `failClosed: ${entry.failClosed}` : null,
@@ -12403,11 +12818,11 @@ function summarizeChecks(checks) {
   };
 }
 async function loadMcpScaffoldMetadata(rootDir) {
-  const metadataPath = resolve13(rootDir, MCP_SCAFFOLD_METADATA_PATH);
-  if (!existsSync20(metadataPath)) {
+  const metadataPath = resolve14(rootDir, MCP_SCAFFOLD_METADATA_PATH);
+  if (!existsSync18(metadataPath)) {
     return null;
   }
-  const parsed = JSON.parse(readFileSync8(metadataPath, "utf-8"));
+  const parsed = JSON.parse(readFileSync9(metadataPath, "utf-8"));
   return parsed;
 }
 function hasRelatedDiscovery(metadata) {
@@ -12434,8 +12849,8 @@ function collectSkillPromptLabels(skill) {
 }
 function evaluateInstructions(rootDir, metadata, checks) {
   const relativePath = "INSTRUCTIONS.md";
-  const filePath = resolve13(rootDir, relativePath);
-  if (!existsSync20(filePath)) {
+  const filePath = resolve14(rootDir, relativePath);
+  if (!existsSync18(filePath)) {
     addCheck(checks, {
       level: "error",
       code: "instructions-missing",
@@ -12446,7 +12861,7 @@ function evaluateInstructions(rootDir, metadata, checks) {
     });
     return;
   }
-  const content = readFileSync8(filePath, "utf-8");
+  const content = readFileSync9(filePath, "utf-8");
   const missing = [];
   if (!content.includes("## Workflow Guidance")) missing.push("`## Workflow Guidance`");
   if (!content.includes("## Tool Routing")) missing.push("`## Tool Routing`");
@@ -12480,12 +12895,12 @@ function evaluateSkills(rootDir, metadata, checks) {
   const failures = [];
   for (const skill of metadata.skills) {
     const relativePath = `skills/${skill.dirName}/SKILL.md`;
-    const filePath = resolve13(rootDir, relativePath);
-    if (!existsSync20(filePath)) {
+    const filePath = resolve14(rootDir, relativePath);
+    if (!existsSync18(filePath)) {
       failures.push({ path: relativePath, missing: ["skill file"] });
       continue;
     }
-    const content = readFileSync8(filePath, "utf-8");
+    const content = readFileSync9(filePath, "utf-8");
     const missing = [];
     if (!content.includes("## Example Requests")) {
       missing.push("`## Example Requests`");
@@ -12544,12 +12959,12 @@ function evaluateCommands(rootDir, metadata, checks) {
   const commandSkillNames = managedCommandSkillNames(metadata);
   for (const skill of metadata.skills.filter((entry) => commandSkillNames.has(entry.dirName))) {
     const relativePath = `commands/${skill.dirName}.md`;
-    const filePath = resolve13(rootDir, relativePath);
-    if (!existsSync20(filePath)) {
+    const filePath = resolve14(rootDir, relativePath);
+    if (!existsSync18(filePath)) {
       failures.push({ path: relativePath, missing: ["command file"] });
       continue;
     }
-    const content = readFileSync8(filePath, "utf-8");
+    const content = readFileSync9(filePath, "utf-8");
     const missing = [];
     if (!content.includes("argument-hint:")) missing.push("`argument-hint` frontmatter");
     if (!content.includes("Primary tools:")) missing.push("`Primary tools:` block");
@@ -12824,7 +13239,7 @@ async function runTestSuite(options = {}) {
     const evalReport = await runEvalSuite({ rootDir });
     const checks = targets.map((platform) => {
       const requiredPath = SMOKE_PATHS[platform];
-      const ok = existsSync21(resolve14(rootDir, config.outDir, platform, requiredPath));
+      const ok = existsSync19(resolve15(rootDir, config.outDir, platform, requiredPath));
       return { platform, requiredPath, ok };
     });
     return {
@@ -12881,8 +13296,8 @@ function printTestResult(result) {
 }
 
 // src/cli/sync-from-mcp.ts
-import { cpSync as cpSync2, existsSync as existsSync22, mkdtempSync, readFileSync as readFileSync9, rmSync as rmSync2, readdirSync as readdirSync7, rmdirSync, writeFileSync as writeFileSync3 } from "fs";
-import { dirname as dirname5, isAbsolute, relative as relative9, resolve as resolve15 } from "path";
+import { cpSync as cpSync2, existsSync as existsSync20, mkdtempSync, readFileSync as readFileSync10, rmSync as rmSync2, readdirSync as readdirSync7, rmdirSync, writeFileSync as writeFileSync3 } from "fs";
+import { dirname as dirname5, isAbsolute, relative as relative9, resolve as resolve16 } from "path";
 import { tmpdir } from "os";
 
 // src/mcp/introspect.ts
@@ -13164,10 +13579,10 @@ async function createSseClient(server) {
   let resolveEndpoint;
   let rejectEndpoint;
   let endpointSettled = false;
-  const endpointReady = new Promise((resolve27, reject) => {
+  const endpointReady = new Promise((resolve28, reject) => {
     resolveEndpoint = (value) => {
       endpointSettled = true;
-      resolve27(value);
+      resolve28(value);
     };
     rejectEndpoint = (error) => {
       endpointSettled = true;
@@ -13304,7 +13719,7 @@ async function createSseClient(server) {
     async request(method, params) {
       const requestId = nextRequestId();
       const endpoint = endpointUrl ?? await endpointReady;
-      const resultPromise = new Promise((resolve27, reject) => {
+      const resultPromise = new Promise((resolve28, reject) => {
         const timeout = setTimeout(() => {
           pending.delete(requestId);
           reject(new McpIntrospectionError(`Timed out waiting for MCP SSE response to ${method}.`));
@@ -13312,7 +13727,7 @@ async function createSseClient(server) {
         pending.set(requestId, {
           resolve: (value) => {
             clearTimeout(timeout);
-            resolve27(value);
+            resolve28(value);
           },
           reject: (error) => {
             clearTimeout(timeout);
@@ -13465,7 +13880,7 @@ async function createStdioClient(server) {
         method,
         ...params ? { params } : {}
       });
-      return new Promise((resolve27, reject) => {
+      return new Promise((resolve28, reject) => {
         const timeout = setTimeout(() => {
           pending.delete(id);
           reject(new McpIntrospectionError(`Timed out waiting for MCP stdio response to ${method}.`));
@@ -13473,7 +13888,7 @@ async function createStdioClient(server) {
         pending.set(id, {
           resolve: (value) => {
             clearTimeout(timeout);
-            resolve27(value);
+            resolve28(value);
           },
           reject: (error) => {
             clearTimeout(timeout);
@@ -13651,12 +14066,12 @@ function nextRequestId() {
 // src/cli/sync-from-mcp.ts
 async function readMcpScaffoldMetadata(rootDir) {
   const filepath = resolveWithinRoot(rootDir, MCP_SCAFFOLD_METADATA_PATH);
-  if (!existsSync22(filepath)) {
+  if (!existsSync20(filepath)) {
     throw new Error(
       `No MCP scaffold metadata found at ${MCP_SCAFFOLD_METADATA_PATH}. Run "pluxx init --from-mcp" first.`
     );
   }
-  return JSON.parse(readFileSync9(filepath, "utf-8"));
+  return JSON.parse(readFileSync10(filepath, "utf-8"));
 }
 async function syncFromMcp(options) {
   const metadata = await readMcpScaffoldMetadata(options.rootDir);
@@ -13682,19 +14097,19 @@ async function syncFromMcp(options) {
     toolRenames
   });
   const newMetadataPath = resolveWithinRoot(options.rootDir, MCP_SCAFFOLD_METADATA_PATH);
-  const newMetadata = JSON.parse(readFileSync9(newMetadataPath, "utf-8"));
+  const newMetadata = JSON.parse(readFileSync10(newMetadataPath, "utf-8"));
   const skillRenames = detectSkillRenames(metadata.skills, newMetadata.skills, toolRenames);
   for (const [oldSkillDir, newSkillDir] of skillRenames) {
     const oldSkillPath = resolveWithinRoot(options.rootDir, `skills/${oldSkillDir}/SKILL.md`);
-    if (!existsSync22(oldSkillPath)) continue;
-    const oldContent = readFileSync9(oldSkillPath, "utf-8");
+    if (!existsSync20(oldSkillPath)) continue;
+    const oldContent = readFileSync10(oldSkillPath, "utf-8");
     const extracted = extractMixedMarkdownContent(oldContent, "");
     if (!hasMeaningfulCustomContent(oldContent)) continue;
     const newSkill = newMetadata.skills.find((s) => s.dirName === newSkillDir);
     if (!newSkill) continue;
     const newSkillPath = resolveWithinRoot(options.rootDir, `skills/${newSkill.dirName}/SKILL.md`);
-    if (!existsSync22(newSkillPath)) continue;
-    const currentContent = readFileSync9(newSkillPath, "utf-8");
+    if (!existsSync20(newSkillPath)) continue;
+    const currentContent = readFileSync10(newSkillPath, "utf-8");
     const updatedContent = injectCustomContent(currentContent, extracted.customContent);
     writeFileSync3(newSkillPath, updatedContent, "utf-8");
   }
@@ -13736,8 +14151,8 @@ async function syncFromMcp(options) {
     if (!beforeManaged.has(file)) return false;
     const before = beforeContents.get(file);
     const currentPath = resolveWithinRoot(options.rootDir, file);
-    if (!existsSync22(currentPath)) return false;
-    const after = readFileSync9(currentPath, "utf-8");
+    if (!existsSync20(currentPath)) return false;
+    const after = readFileSync10(currentPath, "utf-8");
     return before !== after;
   });
   const scaffoldChanged = addedFiles.length > 0 || updatedFiles.length > 0 || removedFiles.length > 0 || renamedFiles.length > 0;
@@ -13783,7 +14198,7 @@ async function applyPersistedTaxonomy(rootDir) {
     writeFileSync3(resolveWithinRoot(rootDir, instructionsPath), previousInstructions, "utf-8");
   }
   const newMetadataPath = resolveWithinRoot(rootDir, MCP_SCAFFOLD_METADATA_PATH);
-  const newMetadata = JSON.parse(readFileSync9(newMetadataPath, "utf-8"));
+  const newMetadata = JSON.parse(readFileSync10(newMetadataPath, "utf-8"));
   const skillRenames = detectSkillRenames(metadata.skills, newMetadata.skills, /* @__PURE__ */ new Map());
   preserveCustomContentForRenames(rootDir, skillRenames, (dirName) => `skills/${dirName}/SKILL.md`);
   preserveCustomContentForRenames(rootDir, skillRenames, (dirName) => `commands/${dirName}.md`);
@@ -13811,8 +14226,8 @@ async function applyPersistedTaxonomy(rootDir) {
   invalidateSavedAgentPack(rootDir);
 }
 async function planSyncFromMcp(options) {
-  const tempRoot = mkdtempSync(resolve15(tmpdir(), "pluxx-sync-dry-run-"));
-  const projectDir = resolve15(tempRoot, "project");
+  const tempRoot = mkdtempSync(resolve16(tmpdir(), "pluxx-sync-dry-run-"));
+  const projectDir = resolve16(tempRoot, "project");
   try {
     cpSync2(options.rootDir, projectDir, { recursive: true });
     return await syncFromMcp({
@@ -13825,8 +14240,8 @@ async function planSyncFromMcp(options) {
 }
 function readPersistedSkills(rootDir, metadata) {
   const taxonomyPath = resolveWithinRoot(rootDir, MCP_TAXONOMY_PATH);
-  if (existsSync22(taxonomyPath)) {
-    return JSON.parse(readFileSync9(taxonomyPath, "utf-8"));
+  if (existsSync20(taxonomyPath)) {
+    return JSON.parse(readFileSync10(taxonomyPath, "utf-8"));
   }
   return metadata.skills.map((skill) => ({
     dirName: skill.dirName,
@@ -13838,13 +14253,13 @@ function readPersistedSkills(rootDir, metadata) {
 function preserveCustomContentForRenames(rootDir, renames, pathForName) {
   for (const [oldName, newName] of renames) {
     const oldPath = resolveWithinRoot(rootDir, pathForName(oldName));
-    if (!existsSync22(oldPath)) continue;
-    const oldContent = readFileSync9(oldPath, "utf-8");
+    if (!existsSync20(oldPath)) continue;
+    const oldContent = readFileSync10(oldPath, "utf-8");
     const extracted = extractMixedMarkdownContent(oldContent, "");
     if (!hasMeaningfulCustomContent(oldContent)) continue;
     const newPath = resolveWithinRoot(rootDir, pathForName(newName));
-    if (!existsSync22(newPath)) continue;
-    const currentContent = readFileSync9(newPath, "utf-8");
+    if (!existsSync20(newPath)) continue;
+    const currentContent = readFileSync10(newPath, "utf-8");
     const updatedContent = injectCustomContent(currentContent, extracted.customContent);
     writeFileSync3(newPath, updatedContent, "utf-8");
   }
@@ -13853,26 +14268,26 @@ function snapshotManagedFiles(rootDir, files) {
   const contents = /* @__PURE__ */ new Map();
   for (const file of files) {
     const filepath = resolveWithinRoot(rootDir, file);
-    if (!existsSync22(filepath)) continue;
-    contents.set(file, readFileSync9(filepath, "utf-8"));
+    if (!existsSync20(filepath)) continue;
+    contents.set(file, readFileSync10(filepath, "utf-8"));
   }
   return contents;
 }
 function removeManagedFile(rootDir, relativePath) {
   const filepath = resolveWithinRoot(rootDir, relativePath);
-  if (!existsSync22(filepath)) return;
+  if (!existsSync20(filepath)) return;
   rmSync2(filepath, { force: true });
   pruneEmptyDirectories(rootDir, dirname5(filepath));
 }
 function shouldPreserveManagedFile(rootDir, relativePath) {
   if (!relativePath.endsWith(".md")) return false;
   const filepath = resolveWithinRoot(rootDir, relativePath);
-  if (!existsSync22(filepath)) return false;
-  return hasMeaningfulCustomContent(readFileSync9(filepath, "utf-8"));
+  if (!existsSync20(filepath)) return false;
+  return hasMeaningfulCustomContent(readFileSync10(filepath, "utf-8"));
 }
 function pruneEmptyDirectories(rootDir, startDir) {
   let current = startDir;
-  const stopDir = resolve15(rootDir);
+  const stopDir = resolve16(rootDir);
   while (current.startsWith(stopDir) && current !== stopDir) {
     const entries = readdirSync7(current);
     if (entries.length > 0) return;
@@ -14039,8 +14454,8 @@ function computeSkillRenameScore(oldSkill, newSkill, toolRenames) {
   return score;
 }
 function resolveWithinRoot(rootDir, relativePath) {
-  const rootPath = resolve15(rootDir);
-  const filepath = resolve15(rootPath, relativePath);
+  const rootPath = resolve16(rootDir);
+  const filepath = resolve16(rootPath, relativePath);
   const relativePathFromRoot = relative9(rootPath, filepath);
   if (relativePathFromRoot === "" || !relativePathFromRoot.startsWith("..") && !isAbsolute(relativePathFromRoot)) {
     return filepath;
@@ -14057,13 +14472,13 @@ function formatSyncSummary(result, rootDir) {
     result.renamedFiles.forEach((rename) => lines.push(`  \u2192 ${rename.from} \u2192 ${rename.to}`));
   }
   lines.push(`Added: ${result.addedFiles.length}`);
-  result.addedFiles.forEach((file) => lines.push(`  + ${relative9(rootDir, resolve15(rootDir, file))}`));
+  result.addedFiles.forEach((file) => lines.push(`  + ${relative9(rootDir, resolve16(rootDir, file))}`));
   lines.push(`Updated: ${result.updatedFiles.length}`);
-  result.updatedFiles.forEach((file) => lines.push(`  ~ ${relative9(rootDir, resolve15(rootDir, file))}`));
+  result.updatedFiles.forEach((file) => lines.push(`  ~ ${relative9(rootDir, resolve16(rootDir, file))}`));
   lines.push(`Removed: ${result.removedFiles.length}`);
-  result.removedFiles.forEach((file) => lines.push(`  - ${relative9(rootDir, resolve15(rootDir, file))}`));
+  result.removedFiles.forEach((file) => lines.push(`  - ${relative9(rootDir, resolve16(rootDir, file))}`));
   lines.push(`Preserved: ${result.preservedFiles.length}`);
-  result.preservedFiles.forEach((file) => lines.push(`  ! ${relative9(rootDir, resolve15(rootDir, file))}`));
+  result.preservedFiles.forEach((file) => lines.push(`  ! ${relative9(rootDir, resolve16(rootDir, file))}`));
   return lines;
 }
 
@@ -14139,10 +14554,10 @@ async function planAgentPrepare(rootDir = process.cwd(), options = {}) {
 }
 async function applyAgentPreparePlan(rootDir, plan) {
   for (const file of plan.files) {
-    const filePath = resolve16(rootDir, file.relativePath);
+    const filePath = resolve17(rootDir, file.relativePath);
     const parentDir = file.relativePath.split("/").slice(0, -1).join("/");
     if (parentDir) {
-      await mkdir3(resolve16(rootDir, parentDir), { recursive: true });
+      await mkdir3(resolve17(rootDir, parentDir), { recursive: true });
     }
     await writeTextFile(filePath, file.content);
   }
@@ -14151,8 +14566,8 @@ async function planAgentPrompt(rootDir, kind, options = {}) {
   const config = await loadConfig(rootDir);
   const project = await loadAgentProjectModel(rootDir, config);
   const overrides = await loadAgentOverrides(rootDir);
-  const contextPath = resolve16(rootDir, AGENT_CONTEXT_PATH);
-  if (!options.allowMissingContext && !existsSync23(contextPath)) {
+  const contextPath = resolve17(rootDir, AGENT_CONTEXT_PATH);
+  if (!options.allowMissingContext && !existsSync21(contextPath)) {
     throw new Error(`No agent context found at ${AGENT_CONTEXT_PATH}. Run "pluxx agent prepare" first.`);
   }
   if (project.sourceKind !== "mcp-derived" && kind !== "review") {
@@ -14164,7 +14579,7 @@ async function planAgentPrompt(rootDir, kind, options = {}) {
     displayName: project.displayName,
     skillPaths: project.skills.map((skill) => skill.path),
     commandPaths: project.commands.map((command2) => command2.path),
-    extraContextPaths: [AGENT_SOURCES_PATH, AGENT_DOCS_CONTEXT_PATH].filter((path) => existsSync23(resolve16(rootDir, path))),
+    extraContextPaths: [AGENT_SOURCES_PATH, AGENT_DOCS_CONTEXT_PATH].filter((path) => existsSync21(resolve17(rootDir, path))),
     sourceKind: project.sourceKind,
     taxonomyPath: project.taxonomyPath,
     overrides
@@ -14181,10 +14596,10 @@ async function planAgentPrompt(rootDir, kind, options = {}) {
 }
 async function applyAgentPromptPlan(rootDir, plan) {
   for (const file of plan.files) {
-    const filePath = resolve16(rootDir, file.relativePath);
+    const filePath = resolve17(rootDir, file.relativePath);
     const parentDir = file.relativePath.split("/").slice(0, -1).join("/");
     if (parentDir) {
-      await mkdir3(resolve16(rootDir, parentDir), { recursive: true });
+      await mkdir3(resolve17(rootDir, parentDir), { recursive: true });
     }
     await writeTextFile(filePath, file.content);
   }
@@ -14281,10 +14696,10 @@ async function refreshAgentPack(rootDir, prepareOptions) {
 }
 async function writePlannedFiles(rootDir, files) {
   for (const file of files) {
-    const filePath = resolve16(rootDir, file.relativePath);
+    const filePath = resolve17(rootDir, file.relativePath);
     const parentDir = file.relativePath.split("/").slice(0, -1).join("/");
     if (parentDir) {
-      await mkdir3(resolve16(rootDir, parentDir), { recursive: true });
+      await mkdir3(resolve17(rootDir, parentDir), { recursive: true });
     }
     await writeTextFile(filePath, file.content);
   }
@@ -14331,8 +14746,8 @@ function buildProtectedFiles() {
   ];
 }
 async function loadMcpScaffoldMetadata2(rootDir) {
-  const metadataPath = resolve16(rootDir, MCP_SCAFFOLD_METADATA_PATH);
-  if (!existsSync23(metadataPath)) {
+  const metadataPath = resolve17(rootDir, MCP_SCAFFOLD_METADATA_PATH);
+  if (!existsSync21(metadataPath)) {
     throw new Error(`No MCP scaffold metadata found at ${MCP_SCAFFOLD_METADATA_PATH}. Run "pluxx init --from-mcp" first.`);
   }
   try {
@@ -14345,8 +14760,8 @@ async function loadMcpScaffoldMetadata2(rootDir) {
   }
 }
 async function loadAgentProjectModel(rootDir, config) {
-  const metadataPath = resolve16(rootDir, MCP_SCAFFOLD_METADATA_PATH);
-  if (existsSync23(metadataPath)) {
+  const metadataPath = resolve17(rootDir, MCP_SCAFFOLD_METADATA_PATH);
+  if (existsSync21(metadataPath)) {
     const metadata = await loadMcpScaffoldMetadata2(rootDir);
     const serverEntry = Object.entries(config.mcp ?? {})[0];
     const [serverName, server] = serverEntry ?? ["unknown", metadata.source];
@@ -14380,8 +14795,8 @@ async function loadAgentProjectModel(rootDir, config) {
 }
 function loadManualAgentProjectModel(rootDir, config) {
   const displayName = config.brand?.displayName ?? config.name;
-  const skillsDir = config.skills ? resolve16(rootDir, config.skills) : void 0;
-  const commandsDir = config.commands ? resolve16(rootDir, config.commands) : void 0;
+  const skillsDir = config.skills ? resolve17(rootDir, config.skills) : void 0;
+  const commandsDir = config.commands ? resolve17(rootDir, config.commands) : void 0;
   const skills = readCanonicalSkillFiles2(rootDir, skillsDir);
   const commands = readCanonicalCommandFiles(commandsDir).map((command2) => ({
     path: normalizeRelativePath(relative10(rootDir, command2.filePath)),
@@ -14407,7 +14822,7 @@ function loadManualAgentProjectModel(rootDir, config) {
   };
 }
 async function planFile(rootDir, relativePath, content) {
-  const filePath = resolve16(rootDir, relativePath);
+  const filePath = resolve17(rootDir, relativePath);
   const action = await planTextFileAction(filePath, content);
   return { relativePath, content, action };
 }
@@ -14715,8 +15130,8 @@ async function collectAgentContextPackInternal(rootDir, options, overrides) {
   for (const relativePath of contextPaths) {
     if (seenFilePaths.has(relativePath)) continue;
     seenFilePaths.add(relativePath);
-    const filePath = resolve16(rootDir, relativePath);
-    if (!existsSync23(filePath)) {
+    const filePath = resolve17(rootDir, relativePath);
+    if (!existsSync21(filePath)) {
       const source2 = {
         label: relativePath,
         kind: "file",
@@ -16004,12 +16419,12 @@ async function resolveAgentRunnerModel(runner, explicitModel) {
   };
 }
 async function readCodexDefaultModel() {
-  const codexHome = process.env.CODEX_HOME?.trim() || resolve16(homedir(), ".codex");
-  return await readTomlStringValue(resolve16(codexHome, "config.toml"), "model");
+  const codexHome = process.env.CODEX_HOME?.trim() || resolve17(homedir(), ".codex");
+  return await readTomlStringValue(resolve17(codexHome, "config.toml"), "model");
 }
 async function readOpenCodeDefaultModel() {
-  const configHome = process.env.XDG_CONFIG_HOME?.trim() || resolve16(homedir(), ".config");
-  const configPath = resolve16(configHome, "opencode", "opencode.json");
+  const configHome = process.env.XDG_CONFIG_HOME?.trim() || resolve17(homedir(), ".config");
+  const configPath = resolve17(configHome, "opencode", "opencode.json");
   const parsed = await readJsonFile(configPath);
   if (!parsed || typeof parsed !== "object") {
     return void 0;
@@ -16027,9 +16442,9 @@ async function readOpenCodeDefaultModel() {
 }
 async function readClaudeDefaultModel() {
   for (const candidate of [
-    resolve16(homedir(), ".claude", "settings.json"),
-    resolve16(homedir(), ".claude", "settings.local.json"),
-    resolve16(homedir(), ".claude.json")
+    resolve17(homedir(), ".claude", "settings.json"),
+    resolve17(homedir(), ".claude", "settings.local.json"),
+    resolve17(homedir(), ".claude.json")
   ]) {
     const parsed = await readJsonFile(candidate);
     if (!parsed || typeof parsed !== "object") continue;
@@ -16113,8 +16528,8 @@ async function executeCommand(command2, cwd, options = {}) {
   let codexLastMessagePath = null;
   const isClaudeStreamJson = runtimeCommand[0] === "claude" && runtimeCommand.includes("--output-format") && runtimeCommand.includes("stream-json");
   if (runtimeCommand[0] === "codex" && runtimeCommand[1] === "exec") {
-    codexOutputDir = await mkdtemp(resolve16(tmpdir2(), "pluxx-codex-output-"));
-    codexLastMessagePath = resolve16(codexOutputDir, "last-message.txt");
+    codexOutputDir = await mkdtemp(resolve17(tmpdir2(), "pluxx-codex-output-"));
+    codexLastMessagePath = resolve17(codexOutputDir, "last-message.txt");
     runtimeCommand.splice(2, 0, "--json", "--output-last-message", codexLastMessagePath);
   }
   return await new Promise((resolvePromise, reject) => {
@@ -16134,7 +16549,7 @@ async function executeCommand(command2, cwd, options = {}) {
     let claudeTurnCompleted = false;
     let claudeTurnFailed = false;
     const sentinelInterval = codexLastMessagePath || isClaudeStreamJson ? setInterval(() => {
-      const sawCompletionSignal = codexTurnCompleted || codexTurnFailed || claudeTurnCompleted || claudeTurnFailed || (codexLastMessagePath ? existsSync23(codexLastMessagePath) : false);
+      const sawCompletionSignal = codexTurnCompleted || codexTurnFailed || claudeTurnCompleted || claudeTurnFailed || (codexLastMessagePath ? existsSync21(codexLastMessagePath) : false);
       if (!sawCompletionSignal) return;
       if (sawFinalMessageAt == null) {
         sawFinalMessageAt = Date.now();
@@ -16233,8 +16648,8 @@ async function prepareRunnerExecution(runner) {
     if (!cursorBinary || cursorBinary === AGENT_RUNNER_BINARIES.cursor) {
       return { env: process.env };
     }
-    const shimDir = await mkdtemp(resolve16(tmpdir2(), "pluxx-cursor-bin-"));
-    const shimPath = resolve16(shimDir, AGENT_RUNNER_BINARIES.cursor);
+    const shimDir = await mkdtemp(resolve17(tmpdir2(), "pluxx-cursor-bin-"));
+    const shimPath = resolve17(shimDir, AGENT_RUNNER_BINARIES.cursor);
     await writeTextFile(
       shimPath,
       `#!/bin/sh
@@ -16255,21 +16670,21 @@ exec ${shellQuote(cursorBinary)} "$@"
   if (runner !== "codex") {
     return { env: process.env };
   }
-  const currentCodexHome = process.env.CODEX_HOME?.trim() || resolve16(homedir(), ".codex");
-  const isolatedCodexHome = await mkdtemp(resolve16(tmpdir2(), "pluxx-codex-home-"));
-  await mkdir3(resolve16(isolatedCodexHome, "memories"), { recursive: true });
+  const currentCodexHome = process.env.CODEX_HOME?.trim() || resolve17(homedir(), ".codex");
+  const isolatedCodexHome = await mkdtemp(resolve17(tmpdir2(), "pluxx-codex-home-"));
+  await mkdir3(resolve17(isolatedCodexHome, "memories"), { recursive: true });
   for (const relativePath of ["auth.json", "config.toml", "hooks.json", "installation_id"]) {
-    const sourcePath = resolve16(currentCodexHome, relativePath);
-    if (!existsSync23(sourcePath)) continue;
-    await copyFile(sourcePath, resolve16(isolatedCodexHome, relativePath));
+    const sourcePath = resolve17(currentCodexHome, relativePath);
+    if (!existsSync21(sourcePath)) continue;
+    await copyFile(sourcePath, resolve17(isolatedCodexHome, relativePath));
   }
-  const rulesSourceDir = resolve16(currentCodexHome, "rules");
-  if (existsSync23(rulesSourceDir)) {
-    const rulesTargetDir = resolve16(isolatedCodexHome, "rules");
+  const rulesSourceDir = resolve17(currentCodexHome, "rules");
+  if (existsSync21(rulesSourceDir)) {
+    const rulesTargetDir = resolve17(isolatedCodexHome, "rules");
     await mkdir3(rulesTargetDir, { recursive: true });
-    const defaultRulesPath = resolve16(rulesSourceDir, "default.rules");
-    if (existsSync23(defaultRulesPath)) {
-      await copyFile(defaultRulesPath, resolve16(rulesTargetDir, "default.rules"));
+    const defaultRulesPath = resolve17(rulesSourceDir, "default.rules");
+    if (existsSync21(defaultRulesPath)) {
+      await copyFile(defaultRulesPath, resolve17(rulesTargetDir, "default.rules"));
     }
   }
   return {
@@ -16305,8 +16720,8 @@ function titleCase(value) {
   return value.charAt(0).toUpperCase() + value.slice(1);
 }
 async function loadAgentOverrides(rootDir) {
-  const overridesPath = resolve16(rootDir, AGENT_OVERRIDES_PATH);
-  if (!existsSync23(overridesPath)) {
+  const overridesPath = resolve17(rootDir, AGENT_OVERRIDES_PATH);
+  if (!existsSync21(overridesPath)) {
     return null;
   }
   const content = await readTextFile(overridesPath);
@@ -16409,14 +16824,45 @@ ${additions.map((block) => `- ${block.replace(/\n/g, "\n  ")}`).join("\n")}
 
 // src/cli/doctor.ts
 import { spawn as spawn3 } from "child_process";
-import { accessSync, constants, existsSync as existsSync25, lstatSync as lstatSync3, readFileSync as readFileSync12, readdirSync as readdirSync10 } from "fs";
-import { basename as basename6, dirname as dirname7, resolve as resolve18 } from "path";
+import { accessSync, constants, existsSync as existsSync23, lstatSync as lstatSync3, readFileSync as readFileSync13, readdirSync as readdirSync10 } from "fs";
+import { basename as basename6, dirname as dirname7, resolve as resolve19 } from "path";
 
 // src/cli/install.ts
-import { resolve as resolve17, dirname as dirname6 } from "path";
-import { existsSync as existsSync24, symlinkSync, mkdirSync as mkdirSync4, rmSync as rmSync3, readFileSync as readFileSync11, writeFileSync as writeFileSync4, cpSync as cpSync3, readdirSync as readdirSync9 } from "fs";
+import { resolve as resolve18, dirname as dirname6 } from "path";
+import { existsSync as existsSync22, symlinkSync, mkdirSync as mkdirSync4, rmSync as rmSync3, readFileSync as readFileSync12, writeFileSync as writeFileSync4, cpSync as cpSync3, readdirSync as readdirSync9 } from "fs";
 import { spawnSync } from "child_process";
 import * as readline2 from "readline";
+
+// src/distribution-lifecycle.ts
+var INSTALL_FOLLOWUP_NOTES = {
+  "claude-code": "Claude Code note: if Claude is already open, run /reload-plugins in the session to pick up the new install.",
+  cursor: "Cursor note: if Cursor is already open, use Developer: Reload Window or restart Cursor to pick up the new install.",
+  codex: "Codex note: if Codex is already open, use Plugins > Refresh if that action is available in your current UI, or restart Codex to pick up the new install. Plugin-bundled MCP servers may appear on the plugin detail page without appearing in the global MCP servers settings page.",
+  opencode: "OpenCode note: if OpenCode is already open, restart or reload it so the plugin is picked up."
+};
+var VERIFY_STALE_ACTIONS = {
+  codex: "in Codex, use Plugins > Refresh if available, or restart Codex so the plugin cache reloads"
+};
+var PUBLISH_RELOAD_INSTRUCTIONS = {
+  "claude-code": "If Claude is already open, run /reload-plugins in the active session.",
+  cursor: "If Cursor is already open, use Developer: Reload Window or restart Cursor so the plugin is picked up.",
+  codex: "If Codex is already open, use Plugins > Refresh if that action is available in your current UI, or restart Codex so the plugin is picked up.",
+  opencode: "If OpenCode is already open, restart or reload it so the plugin is picked up."
+};
+function getInstallFollowupNote(target) {
+  return INSTALL_FOLLOWUP_NOTES[target];
+}
+function getInstallFollowupNotes(targets) {
+  return targets.map((target) => getInstallFollowupNote(target)).filter((note) => Boolean(note));
+}
+function getVerifyInstallStaleAction(target) {
+  return VERIFY_STALE_ACTIONS[target];
+}
+function getPublishReloadInstruction(target) {
+  return PUBLISH_RELOAD_INSTRUCTIONS[target];
+}
+
+// src/cli/install.ts
 function listHookCommands(hooks) {
   if (!hooks) return [];
   const commands = [];
@@ -16568,57 +17014,57 @@ function getInstallTargets(pluginName) {
   return [
     {
       platform: "claude-code",
-      pluginDir: resolve17(home, ".claude/plugins", pluginName),
+      pluginDir: resolve18(home, ".claude/plugins", pluginName),
       description: `claude plugin install ${pluginName}@${getClaudeMarketplaceName(pluginName)}`
     },
     {
       platform: "cursor",
-      pluginDir: resolve17(home, ".cursor/plugins/local", pluginName),
+      pluginDir: resolve18(home, ".cursor/plugins/local", pluginName),
       description: `~/.cursor/plugins/local/${pluginName}`
     },
     {
       platform: "codex",
-      pluginDir: resolve17(home, ".codex/plugins", pluginName),
+      pluginDir: resolve18(home, ".codex/plugins", pluginName),
       description: `~/.codex/plugins/${pluginName} (via ~/.agents/plugins/marketplace.json)`
     },
     {
       platform: "opencode",
-      pluginDir: resolve17(home, ".config/opencode/plugins", pluginName),
+      pluginDir: resolve18(home, ".config/opencode/plugins", pluginName),
       description: `~/.config/opencode/plugins/${pluginName}.ts + ~/.config/opencode/plugins/${pluginName}/`
     },
     {
       platform: "github-copilot",
-      pluginDir: resolve17(home, ".github-copilot/plugins", pluginName),
+      pluginDir: resolve18(home, ".github-copilot/plugins", pluginName),
       description: `~/.github-copilot/plugins/${pluginName}`
     },
     {
       platform: "openhands",
-      pluginDir: resolve17(home, ".openhands/plugins", pluginName),
+      pluginDir: resolve18(home, ".openhands/plugins", pluginName),
       description: `~/.openhands/plugins/${pluginName}`
     },
     {
       platform: "warp",
-      pluginDir: resolve17(home, ".warp/plugins", pluginName),
+      pluginDir: resolve18(home, ".warp/plugins", pluginName),
       description: `~/.warp/plugins/${pluginName}`
     },
     {
       platform: "gemini-cli",
-      pluginDir: resolve17(home, ".gemini/extensions", pluginName),
+      pluginDir: resolve18(home, ".gemini/extensions", pluginName),
       description: `~/.gemini/extensions/${pluginName}`
     },
     {
       platform: "roo-code",
-      pluginDir: resolve17(home, ".roo/plugins", pluginName),
+      pluginDir: resolve18(home, ".roo/plugins", pluginName),
       description: `~/.roo/plugins/${pluginName}`
     },
     {
       platform: "cline",
-      pluginDir: resolve17(home, ".cline/plugins", pluginName),
+      pluginDir: resolve18(home, ".cline/plugins", pluginName),
       description: `~/.cline/plugins/${pluginName}`
     },
     {
       platform: "amp",
-      pluginDir: resolve17(home, ".amp/plugins", pluginName),
+      pluginDir: resolve18(home, ".amp/plugins", pluginName),
       description: `~/.amp/plugins/${pluginName}`
     }
   ];
@@ -16659,10 +17105,10 @@ function writeOpenCodeEntryFile(pluginDir, pluginName) {
 }
 function getOpenCodeSkillRoot() {
   const home = process.env.HOME ?? "~";
-  return resolve17(home, ".config/opencode/skills");
+  return resolve18(home, ".config/opencode/skills");
 }
 function getOpenCodeInstalledSkillDir(pluginName, skillName) {
-  return resolve17(getOpenCodeSkillRoot(), `${pluginName}-${skillName}`);
+  return resolve18(getOpenCodeSkillRoot(), `${pluginName}-${skillName}`);
 }
 function namespaceOpenCodeSkill(content, pluginName, fallbackName) {
   const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---\n?/);
@@ -16686,29 +17132,29 @@ ${nextFrontmatter}
 ${content.slice(frontmatterMatch[0].length)}`;
 }
 function syncOpenCodeSkills(pluginDir, pluginName) {
-  const sourceSkillsDir = resolve17(pluginDir, "skills");
-  if (!existsSync24(sourceSkillsDir)) return;
+  const sourceSkillsDir = resolve18(pluginDir, "skills");
+  if (!existsSync22(sourceSkillsDir)) return;
   mkdirSync4(getOpenCodeSkillRoot(), { recursive: true });
   for (const entry of readdirSync9(sourceSkillsDir, { withFileTypes: true })) {
     if (!entry.isDirectory()) continue;
-    const skillSourceDir = resolve17(sourceSkillsDir, entry.name);
-    if (!existsSync24(resolve17(skillSourceDir, "SKILL.md"))) continue;
+    const skillSourceDir = resolve18(sourceSkillsDir, entry.name);
+    if (!existsSync22(resolve18(skillSourceDir, "SKILL.md"))) continue;
     const installedSkillDir = getOpenCodeInstalledSkillDir(pluginName, entry.name);
     rmSync3(installedSkillDir, { recursive: true, force: true });
     cpSync3(skillSourceDir, installedSkillDir, { recursive: true });
-    const skillPath = resolve17(installedSkillDir, "SKILL.md");
+    const skillPath = resolve18(installedSkillDir, "SKILL.md");
     writeFileSync4(
       skillPath,
-      namespaceOpenCodeSkill(readFileSync11(skillPath, "utf-8"), pluginName, entry.name)
+      namespaceOpenCodeSkill(readFileSync12(skillPath, "utf-8"), pluginName, entry.name)
     );
   }
 }
 function verifyOpenCodeInstall(pluginDir, pluginName) {
   const entryPath = getOpenCodeEntryPath(pluginDir);
-  if (!existsSync24(entryPath)) {
+  if (!existsSync22(entryPath)) {
     throw new Error(`OpenCode install is incomplete: missing host entry file at ${entryPath}`);
   }
-  const entryContent = readFileSync11(entryPath, "utf-8");
+  const entryContent = readFileSync12(entryPath, "utf-8");
   const expectedImport = `import * as PluginModule from "./${pluginName}/index.ts"`;
   if (!entryContent.includes(expectedImport)) {
     throw new Error(`OpenCode install is incomplete: ${entryPath} does not import ./${pluginName}/index.ts`);
@@ -16717,17 +17163,17 @@ function verifyOpenCodeInstall(pluginDir, pluginName) {
   if (!entryContent.includes(expectedDirectoryBridge)) {
     throw new Error(`OpenCode install is incomplete: ${entryPath} does not preserve the plugin root bridge`);
   }
-  const sourceSkillsDir = resolve17(pluginDir, "skills");
-  if (!existsSync24(sourceSkillsDir)) return;
+  const sourceSkillsDir = resolve18(pluginDir, "skills");
+  if (!existsSync22(sourceSkillsDir)) return;
   for (const entry of readdirSync9(sourceSkillsDir, { withFileTypes: true })) {
     if (!entry.isDirectory()) continue;
-    const sourceSkillPath = resolve17(sourceSkillsDir, entry.name, "SKILL.md");
-    if (!existsSync24(sourceSkillPath)) continue;
-    const installedSkillPath = resolve17(getOpenCodeInstalledSkillDir(pluginName, entry.name), "SKILL.md");
-    if (!existsSync24(installedSkillPath)) {
+    const sourceSkillPath = resolve18(sourceSkillsDir, entry.name, "SKILL.md");
+    if (!existsSync22(sourceSkillPath)) continue;
+    const installedSkillPath = resolve18(getOpenCodeInstalledSkillDir(pluginName, entry.name), "SKILL.md");
+    if (!existsSync22(installedSkillPath)) {
       throw new Error(`OpenCode install is incomplete: missing synced skill at ${installedSkillPath}`);
     }
-    const installedSkillContent = readFileSync11(installedSkillPath, "utf-8");
+    const installedSkillContent = readFileSync12(installedSkillPath, "utf-8");
     if (!installedSkillContent.includes(`${pluginName}/`)) {
       throw new Error(`OpenCode install is incomplete: ${installedSkillPath} is missing the expected ${pluginName}/ skill namespace`);
     }
@@ -16735,30 +17181,17 @@ function verifyOpenCodeInstall(pluginDir, pluginName) {
 }
 function removeOpenCodeSkills(pluginName) {
   const root = getOpenCodeSkillRoot();
-  if (!existsSync24(root)) return false;
+  if (!existsSync22(root)) return false;
   let removed = false;
   for (const entry of readdirSync9(root, { withFileTypes: true })) {
     if (!entry.name.startsWith(`${pluginName}-`)) continue;
-    rmSync3(resolve17(root, entry.name), { recursive: true, force: true });
+    rmSync3(resolve18(root, entry.name), { recursive: true, force: true });
     removed = true;
   }
   return removed;
 }
-function getInstallFollowupNotes(platforms) {
-  const notes = [];
-  if (platforms.includes("claude-code")) {
-    notes.push("Claude Code note: if Claude is already open, run /reload-plugins in the session to pick up the new install.");
-  }
-  if (platforms.includes("cursor")) {
-    notes.push("Cursor note: if Cursor is already open, use Developer: Reload Window or restart Cursor to pick up the new install.");
-  }
-  if (platforms.includes("codex")) {
-    notes.push("Codex note: if Codex is already open, use Plugins > Refresh if that action is available in your current UI, or restart Codex to pick up the new install. Plugin-bundled MCP servers may appear on the plugin detail page without appearing in the global MCP servers settings page.");
-  }
-  if (platforms.includes("opencode")) {
-    notes.push("OpenCode note: if OpenCode is already open, restart or reload it so the plugin is picked up.");
-  }
-  return notes;
+function getInstallFollowupNotes2(platforms) {
+  return getInstallFollowupNotes(platforms);
 }
 function runCommandDefault(command2, args2) {
   const result = spawnSync(command2, args2, { encoding: "utf-8" });
@@ -16769,9 +17202,9 @@ function runCommandDefault(command2, args2) {
   };
 }
 function createSymlinkInstall(target) {
-  const parentDir = resolve17(target.pluginDir, "..");
+  const parentDir = resolve18(target.pluginDir, "..");
   mkdirSync4(parentDir, { recursive: true });
-  if (existsSync24(target.pluginDir)) {
+  if (existsSync22(target.pluginDir)) {
     rmSync3(target.pluginDir, { recursive: true, force: true });
   }
   symlinkSync(target.sourceDir, target.pluginDir);
@@ -16783,13 +17216,13 @@ function createOpenCodeSymlinkInstall(target, pluginName) {
 }
 function getCodexMarketplacePath() {
   const home = process.env.HOME ?? "~";
-  return resolve17(home, ".agents/plugins/marketplace.json");
+  return resolve18(home, ".agents/plugins/marketplace.json");
 }
 function getCodexMarketplacePluginPath(pluginName) {
   return `./.codex/plugins/${pluginName}`;
 }
 function readCodexMarketplace(filepath) {
-  if (!existsSync24(filepath)) {
+  if (!existsSync22(filepath)) {
     return {
       name: "pluxx-local",
       interface: {
@@ -16798,7 +17231,7 @@ function readCodexMarketplace(filepath) {
       plugins: []
     };
   }
-  const raw = readFileSync11(filepath, "utf-8");
+  const raw = readFileSync12(filepath, "utf-8");
   const parsed = JSON.parse(raw);
   return {
     name: parsed.name ?? "pluxx-local",
@@ -16834,7 +17267,7 @@ function ensureCodexMarketplace(pluginName) {
 }
 function removeCodexMarketplacePlugin(pluginName) {
   const filepath = getCodexMarketplacePath();
-  if (!existsSync24(filepath)) return;
+  if (!existsSync22(filepath)) return;
   const marketplace = readCodexMarketplace(filepath);
   const nextPlugins = (marketplace.plugins ?? []).filter((plugin) => plugin.name !== pluginName);
   if (nextPlugins.length === (marketplace.plugins ?? []).length) {
@@ -16854,9 +17287,9 @@ function removeCodexMarketplacePlugin(pluginName) {
   );
 }
 function createCopiedInstall(target) {
-  const parentDir = resolve17(target.pluginDir, "..");
+  const parentDir = resolve18(target.pluginDir, "..");
   mkdirSync4(parentDir, { recursive: true });
-  if (existsSync24(target.pluginDir)) {
+  if (existsSync22(target.pluginDir)) {
     rmSync3(target.pluginDir, { recursive: true, force: true });
   }
   cpSync3(target.sourceDir, target.pluginDir, { recursive: true });
@@ -16880,8 +17313,8 @@ function patchInstalledMcpConfig(pluginDir, platform, config, entries) {
   if (!config.mcp) return;
   const env = buildUserConfigEnvMap(entries);
   if (platform === "claude-code" || platform === "cursor") {
-    const filepath = resolve17(pluginDir, platform === "claude-code" ? ".mcp.json" : "mcp.json");
-    if (!existsSync24(filepath)) return;
+    const filepath = resolve18(pluginDir, platform === "claude-code" ? ".mcp.json" : "mcp.json");
+    if (!existsSync22(filepath)) return;
     const mcpServers = {};
     const usesPlatformManagedAuth = platform === "claude-code" ? config.platforms?.["claude-code"]?.mcpAuth === "platform" : config.platforms?.cursor?.mcpAuth === "platform";
     for (const [name, server] of Object.entries(config.mcp)) {
@@ -16912,8 +17345,8 @@ function patchInstalledMcpConfig(pluginDir, platform, config, entries) {
     return;
   }
   if (platform === "codex") {
-    const filepath = resolve17(pluginDir, ".mcp.json");
-    if (!existsSync24(filepath)) return;
+    const filepath = resolve18(pluginDir, ".mcp.json");
+    if (!existsSync22(filepath)) return;
     const mcpServers = {};
     for (const [name, server] of Object.entries(config.mcp)) {
       if (server.transport === "stdio") {
@@ -16943,7 +17376,7 @@ function patchInstalledMcpConfig(pluginDir, platform, config, entries) {
 }
 function writeInstalledUserConfig(pluginDir, entries) {
   if (entries.length === 0) return;
-  const filepath = resolve17(pluginDir, ".pluxx-user.json");
+  const filepath = resolve18(pluginDir, ".pluxx-user.json");
   const payload = {
     values: buildUserConfigValueMap(entries),
     env: buildUserConfigEnvMap(entries)
@@ -16952,8 +17385,8 @@ function writeInstalledUserConfig(pluginDir, entries) {
 }
 function disableInstalledEnvValidation(pluginDir, entries) {
   if (entries.length === 0) return;
-  const filepath = resolve17(pluginDir, "scripts/check-env.sh");
-  if (!existsSync24(filepath)) return;
+  const filepath = resolve18(pluginDir, "scripts/check-env.sh");
+  if (!existsSync22(filepath)) return;
   writeFileSync4(
     filepath,
     "#!/usr/bin/env bash\nset -euo pipefail\n# pluxx install materialized required config for this local plugin install.\nexit 0\n"
@@ -16981,15 +17414,15 @@ function getClaudeMarketplaceName(pluginName) {
 }
 function getClaudeMarketplaceRoot(pluginName) {
   const home = process.env.HOME ?? "~";
-  return resolve17(home, ".claude/plugins/data", getClaudeMarketplaceName(pluginName));
+  return resolve18(home, ".claude/plugins/data", getClaudeMarketplaceName(pluginName));
 }
 function readBundleManifestVersion(rootDir, platform) {
   const manifestPath = manifestPathForPlatform(platform);
   if (!manifestPath) return void 0;
-  const filepath = resolve17(rootDir, manifestPath);
-  if (!existsSync24(filepath)) return void 0;
+  const filepath = resolve18(rootDir, manifestPath);
+  if (!existsSync22(filepath)) return void 0;
   try {
-    const manifest = JSON.parse(readFileSync11(filepath, "utf-8"));
+    const manifest = JSON.parse(readFileSync12(filepath, "utf-8"));
     return typeof manifest.version === "string" ? manifest.version : void 0;
   } catch {
     return void 0;
@@ -16998,7 +17431,7 @@ function readBundleManifestVersion(rootDir, platform) {
 function resolveClaudeInstalledCachePath(pluginName, version) {
   if (!version) return void 0;
   const home = process.env.HOME ?? "~";
-  return resolve17(home, ".claude/plugins/cache", getClaudeMarketplaceName(pluginName), pluginName, version);
+  return resolve18(home, ".claude/plugins/cache", getClaudeMarketplaceName(pluginName), pluginName, version);
 }
 function resolveExpectedInstalledConsumerPath(target, pluginName) {
   if (target.platform === "claude-code" && pluginName !== "") {
@@ -17013,8 +17446,8 @@ function resolveExpectedInstalledConsumerPath(target, pluginName) {
 function resolveInstalledConsumerPath(target, pluginName) {
   if (target.platform === "claude-code" && pluginName !== "") {
     const expectedPath = resolveExpectedInstalledConsumerPath(target, pluginName);
-    if (existsSync24(expectedPath)) return expectedPath;
-    if (existsSync24(target.pluginDir)) return target.pluginDir;
+    if (existsSync22(expectedPath)) return expectedPath;
+    if (existsSync22(target.pluginDir)) return target.pluginDir;
     return expectedPath;
   }
   return target.pluginDir;
@@ -17038,11 +17471,11 @@ function isRelativeBundlePath(value) {
 }
 function resolveBundleReference(rootDir, value) {
   if (isRelativeBundlePath(value)) {
-    return resolve17(rootDir, value);
+    return resolve18(rootDir, value);
   }
   const pluginRootMatch = value.match(/^\$\{(?:CLAUDE_PLUGIN_ROOT|CURSOR_PLUGIN_ROOT|PLUGIN_ROOT)\}[\\/](.+)$/);
   if (pluginRootMatch) {
-    return resolve17(rootDir, pluginRootMatch[1]);
+    return resolve18(rootDir, pluginRootMatch[1]);
   }
   return void 0;
 }
@@ -17095,8 +17528,8 @@ function findInstalledBundleIntegrityIssues(rootDir, platform) {
       invalidRuntimeScripts: []
     };
   }
-  const manifestFile = resolve17(rootDir, manifestPath);
-  if (!existsSync24(manifestFile)) {
+  const manifestFile = resolve18(rootDir, manifestPath);
+  if (!existsSync22(manifestFile)) {
     return {
       manifestIssue: `missing plugin manifest at ${manifestPath}`,
       missingManifestPaths: [],
@@ -17106,7 +17539,7 @@ function findInstalledBundleIntegrityIssues(rootDir, platform) {
   }
   let manifest;
   try {
-    manifest = JSON.parse(readFileSync11(manifestFile, "utf-8"));
+    manifest = JSON.parse(readFileSync12(manifestFile, "utf-8"));
   } catch (error) {
     return {
       manifestIssue: `plugin manifest at ${manifestPath} is not parseable: ${error instanceof Error ? error.message : String(error)}`,
@@ -17117,7 +17550,7 @@ function findInstalledBundleIntegrityIssues(rootDir, platform) {
   }
   const missingManifestPaths = readBundleManifestReferences(manifest).filter((value) => {
     const resolved = resolveBundleReference(rootDir, value);
-    return resolved !== void 0 && !existsSync24(resolved);
+    return resolved !== void 0 && !existsSync22(resolved);
   }).sort();
   const hooksReference = typeof manifest.hooks === "string" ? manifest.hooks : void 0;
   if (!hooksReference) {
@@ -17128,7 +17561,7 @@ function findInstalledBundleIntegrityIssues(rootDir, platform) {
     };
   }
   const hooksPath = resolveBundleReference(rootDir, hooksReference);
-  if (!hooksPath || !existsSync24(hooksPath)) {
+  if (!hooksPath || !existsSync22(hooksPath)) {
     return {
       missingManifestPaths,
       missingHookTargets: [],
@@ -17136,13 +17569,13 @@ function findInstalledBundleIntegrityIssues(rootDir, platform) {
     };
   }
   try {
-    const hooks = JSON.parse(readFileSync11(hooksPath, "utf-8"));
+    const hooks = JSON.parse(readFileSync12(hooksPath, "utf-8"));
     const commands = [];
     collectHookCommandStrings(hooks, commands);
     const missingHookTargets = [...new Set(
       commands.flatMap(extractBundleCommandTargets).filter((value) => {
         const resolved = resolveBundleReference(rootDir, value);
-        return resolved !== void 0 && !existsSync24(resolved);
+        return resolved !== void 0 && !existsSync22(resolved);
       })
     )].sort();
     return {
@@ -17162,9 +17595,9 @@ function findInstalledRuntimeScriptIssues(rootDir, manifest) {
   const mcpReference = typeof manifest.mcpServers === "string" ? manifest.mcpServers : void 0;
   if (!mcpReference) return [];
   const mcpPath = resolveBundleReference(rootDir, mcpReference);
-  if (!mcpPath || !existsSync24(mcpPath)) return [];
+  if (!mcpPath || !existsSync22(mcpPath)) return [];
   try {
-    const parsed = JSON.parse(readFileSync11(mcpPath, "utf-8"));
+    const parsed = JSON.parse(readFileSync12(mcpPath, "utf-8"));
     const issues = /* @__PURE__ */ new Set();
     for (const [serverName, server] of Object.entries(parsed.mcpServers ?? {})) {
       if (!server || typeof server !== "object") continue;
@@ -17176,8 +17609,8 @@ function findInstalledRuntimeScriptIssues(rootDir, manifest) {
       ].flatMap(extractBundleCommandTargets);
       for (const target of commandTargets) {
         const resolved = resolveBundleReference(rootDir, target);
-        if (!resolved || !existsSync24(resolved) || !resolved.endsWith(".sh")) continue;
-        const content = readFileSync11(resolved, "utf-8");
+        if (!resolved || !existsSync22(resolved) || !resolved.endsWith(".sh")) continue;
+        const content = readFileSync12(resolved, "utf-8");
         if (!content.includes("check-env.sh")) continue;
         const relativePath = resolved.startsWith(`${rootDir}/`) ? resolved.slice(rootDir.length + 1) : resolved;
         issues.add(`runtime script ${relativePath} for MCP server "${serverName}" still references installer-owned scripts/check-env.sh`);
@@ -17210,20 +17643,20 @@ function assertInstalledBundleIntegrity(rootDir, platform, label) {
 function ensureClaudeMarketplace(pluginName, sourceDir, materialized) {
   const marketplaceName = getClaudeMarketplaceName(pluginName);
   const marketplaceRoot = getClaudeMarketplaceRoot(pluginName);
-  const marketplaceManifestDir = resolve17(marketplaceRoot, ".claude-plugin");
-  const marketplacePluginDir = resolve17(marketplaceRoot, "plugins", pluginName);
-  const pluginManifestPath = resolve17(sourceDir, ".claude-plugin/plugin.json");
-  const pluginManifest = JSON.parse(readFileSync11(pluginManifestPath, "utf-8"));
+  const marketplaceManifestDir = resolve18(marketplaceRoot, ".claude-plugin");
+  const marketplacePluginDir = resolve18(marketplaceRoot, "plugins", pluginName);
+  const pluginManifestPath = resolve18(sourceDir, ".claude-plugin/plugin.json");
+  const pluginManifest = JSON.parse(readFileSync12(pluginManifestPath, "utf-8"));
   rmSync3(marketplaceRoot, { recursive: true, force: true });
   mkdirSync4(marketplaceManifestDir, { recursive: true });
-  mkdirSync4(resolve17(marketplaceRoot, "plugins"), { recursive: true });
+  mkdirSync4(resolve18(marketplaceRoot, "plugins"), { recursive: true });
   cpSync3(sourceDir, marketplacePluginDir, { recursive: true });
   if (materialized && materialized.entries.length > 0) {
     materializeInstalledPlugin(marketplacePluginDir, "claude-code", materialized.config, materialized.entries);
   }
   assertInstalledBundleIntegrity(marketplacePluginDir, "claude-code", "Claude marketplace bundle");
   writeFileSync4(
-    resolve17(marketplaceManifestDir, "marketplace.json"),
+    resolve18(marketplaceManifestDir, "marketplace.json"),
     JSON.stringify({
       name: marketplaceName,
       owner: {
@@ -17263,7 +17696,7 @@ function ensureClaudeMarketplaceRegistered(pluginName, sourceDir, runCommand, ma
 }
 function installClaudePlugin(target, pluginName, runCommand, materialized) {
   const marketplaceName = ensureClaudeMarketplaceRegistered(pluginName, target.sourceDir, runCommand, materialized);
-  if (existsSync24(target.pluginDir)) {
+  if (existsSync22(target.pluginDir)) {
     rmSync3(target.pluginDir, { recursive: true, force: true });
   }
   runCommand("claude", ["plugin", "uninstall", `${pluginName}@${marketplaceName}`]);
@@ -17287,9 +17720,9 @@ function uninstallClaudePlugin(target, pluginName, runCommand, options = {}) {
     }
   }
   const marketplaceRoot = getClaudeMarketplaceRoot(pluginName);
-  const hadMarketplaceRoot = existsSync24(marketplaceRoot);
+  const hadMarketplaceRoot = existsSync22(marketplaceRoot);
   rmSync3(marketplaceRoot, { recursive: true, force: true });
-  const hadLegacyPluginDir = existsSync24(target.pluginDir);
+  const hadLegacyPluginDir = existsSync22(target.pluginDir);
   if (hadLegacyPluginDir) {
     rmSync3(target.pluginDir, { recursive: true, force: true });
   }
@@ -17299,12 +17732,12 @@ function planInstallPlugin(distDir, pluginName, platforms) {
   const targets = getInstallTargets(pluginName);
   const filtered = platforms ? targets.filter((t2) => platforms.includes(t2.platform)) : targets;
   return filtered.map((target) => {
-    const sourceDir = resolve17(distDir, target.platform);
+    const sourceDir = resolve18(distDir, target.platform);
     return {
       ...target,
       sourceDir,
-      built: existsSync24(sourceDir),
-      existing: existsSync24(target.pluginDir)
+      built: existsSync22(sourceDir),
+      existing: existsSync22(target.pluginDir)
     };
   });
 }
@@ -17347,7 +17780,7 @@ async function installPlugin(distDir, pluginName, platforms, options = {}) {
       createSymlinkInstall(target);
     }
     const manifestPath = manifestPathForPlatform(target.platform);
-    if (manifestPath && existsSync24(resolve17(target.pluginDir, manifestPath))) {
+    if (manifestPath && existsSync22(resolve18(target.pluginDir, manifestPath))) {
       assertInstalledBundleIntegrity(target.pluginDir, target.platform, `Installed ${target.platform} plugin bundle`);
     }
     if (target.platform === "codex") {
@@ -17367,7 +17800,7 @@ Installed ${installed} plugin(s).`);
     console.log(`  1. Run: pluxx verify-install --target ${filtered.map((target) => target.platform).join(",")}`);
     console.log("  2. Open the host plugin screen and confirm the plugin appears there.");
     console.log("  3. Reload or restart the host if it was already open.");
-    for (const note of getInstallFollowupNotes(filtered.map((target) => target.platform))) {
+    for (const note of getInstallFollowupNotes2(filtered.map((target) => target.platform))) {
       console.log(note);
     }
   }
@@ -17389,13 +17822,13 @@ async function uninstallPlugin(pluginName, platforms, options = {}) {
       continue;
     }
     let removedTarget = false;
-    if (existsSync24(target.pluginDir)) {
+    if (existsSync22(target.pluginDir)) {
       rmSync3(target.pluginDir, { recursive: true, force: true });
       removedTarget = true;
     }
     if (target.platform === "opencode") {
       const entryPath = getOpenCodeEntryPath(target.pluginDir);
-      if (existsSync24(entryPath)) {
+      if (existsSync22(entryPath)) {
         rmSync3(entryPath, { force: true });
         removedTarget = true;
       }
@@ -17508,8 +17941,8 @@ function checkReadablePath(checks, rootDir, label, configuredPath, required) {
     }
     return;
   }
-  const resolvedPath = resolve18(rootDir, configuredPath);
-  if (!existsSync25(resolvedPath)) {
+  const resolvedPath = resolve19(rootDir, configuredPath);
+  if (!existsSync23(resolvedPath)) {
     addCheck2(checks, {
       level: "error",
       code: "path-not-found",
@@ -17919,8 +18352,8 @@ function checkCompilerIntent(checks, rootDir) {
   }
 }
 function checkScaffoldMetadata(checks, rootDir, config) {
-  const metadataPath = resolve18(rootDir, MCP_SCAFFOLD_METADATA_PATH);
-  if (!existsSync25(metadataPath)) {
+  const metadataPath = resolve19(rootDir, MCP_SCAFFOLD_METADATA_PATH);
+  if (!existsSync23(metadataPath)) {
     addCheck2(checks, {
       level: "info",
       code: "mcp-metadata-missing",
@@ -17932,7 +18365,7 @@ function checkScaffoldMetadata(checks, rootDir, config) {
     return;
   }
   try {
-    const metadata = JSON.parse(readFileSync12(metadataPath, "utf-8"));
+    const metadata = JSON.parse(readFileSync13(metadataPath, "utf-8"));
     const invalidManaged = metadata.managedFiles.filter((path) => !isSafeManagedPath(path));
     if (metadata.version !== 1) {
       addCheck2(checks, {
@@ -17985,7 +18418,7 @@ function checkScaffoldMetadata(checks, rootDir, config) {
   }
 }
 function detectConsumerLayout(rootDir) {
-  if (existsSync25(resolve18(rootDir, ".claude-plugin/plugin.json"))) {
+  if (existsSync23(resolve19(rootDir, ".claude-plugin/plugin.json"))) {
     return {
       kind: "installed-platform",
       platform: "claude-code",
@@ -17993,7 +18426,7 @@ function detectConsumerLayout(rootDir) {
       mcpConfigPath: ".mcp.json"
     };
   }
-  if (existsSync25(resolve18(rootDir, ".cursor-plugin/plugin.json"))) {
+  if (existsSync23(resolve19(rootDir, ".cursor-plugin/plugin.json"))) {
     return {
       kind: "installed-platform",
       platform: "cursor",
@@ -18001,7 +18434,7 @@ function detectConsumerLayout(rootDir) {
       mcpConfigPath: "mcp.json"
     };
   }
-  if (existsSync25(resolve18(rootDir, ".codex-plugin/plugin.json"))) {
+  if (existsSync23(resolve19(rootDir, ".codex-plugin/plugin.json"))) {
     return {
       kind: "installed-platform",
       platform: "codex",
@@ -18009,11 +18442,11 @@ function detectConsumerLayout(rootDir) {
       mcpConfigPath: ".mcp.json"
     };
   }
-  const packagePath = resolve18(rootDir, "package.json");
-  const indexPath = resolve18(rootDir, "index.ts");
-  if (existsSync25(packagePath) && existsSync25(indexPath)) {
+  const packagePath = resolve19(rootDir, "package.json");
+  const indexPath = resolve19(rootDir, "index.ts");
+  if (existsSync23(packagePath) && existsSync23(indexPath)) {
     try {
-      const pkg = JSON.parse(readFileSync12(packagePath, "utf-8"));
+      const pkg = JSON.parse(readFileSync13(packagePath, "utf-8"));
       if (pkg.peerDependencies?.["@opencode-ai/plugin"] || pkg.keywords?.includes("opencode-plugin")) {
         return {
           kind: "installed-platform",
@@ -18029,16 +18462,16 @@ function detectConsumerLayout(rootDir) {
       };
     }
   }
-  if (CONFIG_FILES.some((filename) => existsSync25(resolve18(rootDir, filename)))) {
+  if (CONFIG_FILES.some((filename) => existsSync23(resolve19(rootDir, filename)))) {
     return { kind: "source-project" };
   }
-  if (["claude-code", "cursor", "codex", "opencode"].some((dir) => existsSync25(resolve18(rootDir, dir)))) {
+  if (["claude-code", "cursor", "codex", "opencode"].some((dir) => existsSync23(resolve19(rootDir, dir)))) {
     return { kind: "multi-target-dist" };
   }
   return { kind: "unknown" };
 }
 function readJsonFile2(rootDir, relativePath) {
-  return JSON.parse(readFileSync12(resolve18(rootDir, relativePath), "utf-8"));
+  return JSON.parse(readFileSync13(resolve19(rootDir, relativePath), "utf-8"));
 }
 function checkConsumerBundlePath(checks, rootDir) {
   try {
@@ -18089,8 +18522,8 @@ function checkConsumerManifest(checks, rootDir, layout) {
 }
 function checkInstalledUserConfig(checks, rootDir) {
   const userConfigPath = ".pluxx-user.json";
-  const resolvedPath = resolve18(rootDir, userConfigPath);
-  if (!existsSync25(resolvedPath)) {
+  const resolvedPath = resolve19(rootDir, userConfigPath);
+  if (!existsSync23(resolvedPath)) {
     addCheck2(checks, {
       level: "info",
       code: "consumer-user-config-missing",
@@ -18102,7 +18535,7 @@ function checkInstalledUserConfig(checks, rootDir) {
     return;
   }
   try {
-    const payload = JSON.parse(readFileSync12(resolvedPath, "utf-8"));
+    const payload = JSON.parse(readFileSync13(resolvedPath, "utf-8"));
     const valueCount = Object.keys(payload.values ?? {}).length;
     const envCount = Object.keys(payload.env ?? {}).length;
     const placeholderKeys = [
@@ -18140,8 +18573,8 @@ function checkInstalledUserConfig(checks, rootDir) {
 }
 function checkInstalledEnvValidation(checks, rootDir) {
   const envScriptPath = INSTALLER_OWNED_CHECK_ENV_PATH;
-  const resolvedPath = resolve18(rootDir, envScriptPath);
-  if (!existsSync25(resolvedPath)) {
+  const resolvedPath = resolve19(rootDir, envScriptPath);
+  if (!existsSync23(resolvedPath)) {
     addCheck2(checks, {
       level: "info",
       code: "consumer-env-script-missing",
@@ -18152,7 +18585,7 @@ function checkInstalledEnvValidation(checks, rootDir) {
     });
     return;
   }
-  const content = readFileSync12(resolvedPath, "utf-8");
+  const content = readFileSync13(resolvedPath, "utf-8");
   if (content.includes(MATERIALIZED_ENV_MARKER)) {
     addCheck2(checks, {
       level: "success",
@@ -18180,7 +18613,7 @@ function checkInstalledRuntimeScriptRoles(checks, rootDir) {
     "scripts/bootstrap-runtime.sh",
     "scripts/start-mcp.sh"
   ];
-  const presentRoles = roleFiles.filter((relativePath) => existsSync25(resolve18(rootDir, relativePath))).map((relativePath) => getRuntimeScriptRoleForPath(relativePath)).filter((role) => role !== null);
+  const presentRoles = roleFiles.filter((relativePath) => existsSync23(resolve19(rootDir, relativePath))).map((relativePath) => getRuntimeScriptRoleForPath(relativePath)).filter((role) => role !== null);
   if (presentRoles.length === 0) return;
   addCheck2(checks, {
     level: "info",
@@ -18203,8 +18636,8 @@ async function checkInstalledMcpConfig(checks, rootDir, layout) {
     });
     return;
   }
-  const resolvedPath = resolve18(rootDir, layout.mcpConfigPath);
-  if (!existsSync25(resolvedPath)) {
+  const resolvedPath = resolve19(rootDir, layout.mcpConfigPath);
+  if (!existsSync23(resolvedPath)) {
     addCheck2(checks, {
       level: "info",
       code: "consumer-mcp-config-missing",
@@ -18375,8 +18808,8 @@ function findMissingInstalledStdioRuntimePaths(rootDir, stdioEntries) {
     const args2 = Array.isArray(server.args) ? server.args.filter((value) => typeof value === "string") : [];
     for (const candidate of [command2, ...args2]) {
       if (!candidate || !isLikelyLocalRuntimePath3(candidate)) continue;
-      const resolvedPath = resolve18(rootDir, candidate);
-      if (!existsSync25(resolvedPath)) {
+      const resolvedPath = resolve19(rootDir, candidate);
+      if (!existsSync23(resolvedPath)) {
         missing.add(candidate);
       }
     }
@@ -18487,7 +18920,7 @@ function checkInstalledOpenCodeHostBridge(checks, rootDir) {
   const pluginName = basename6(rootDir);
   const entryPath = `${rootDir}.ts`;
   const entryRelativePath = `${pluginName}.ts`;
-  if (!existsSync25(entryPath)) {
+  if (!existsSync23(entryPath)) {
     addCheck2(checks, {
       level: "error",
       code: "consumer-opencode-entry-missing",
@@ -18498,7 +18931,7 @@ function checkInstalledOpenCodeHostBridge(checks, rootDir) {
     });
     return;
   }
-  const entryContent = readFileSync12(entryPath, "utf-8");
+  const entryContent = readFileSync13(entryPath, "utf-8");
   const expectedImport = `import * as PluginModule from "./${pluginName}/index.ts"`;
   const expectedBridge = `directory: join(context.directory, "${pluginName}")`;
   if (!entryContent.includes(expectedImport) || !entryContent.includes(expectedBridge)) {
@@ -18526,8 +18959,8 @@ function checkInstalledOpenCodeSkills(checks, rootDir) {
     return;
   }
   const pluginName = basename6(rootDir);
-  const sourceSkillsDir = resolve18(rootDir, "skills");
-  if (!existsSync25(sourceSkillsDir)) {
+  const sourceSkillsDir = resolve19(rootDir, "skills");
+  if (!existsSync23(sourceSkillsDir)) {
     addCheck2(checks, {
       level: "info",
       code: "consumer-opencode-skill-sync-not-applicable",
@@ -18538,21 +18971,21 @@ function checkInstalledOpenCodeSkills(checks, rootDir) {
     });
     return;
   }
-  const skillRoot = resolve18(dirname7(dirname7(rootDir)), "skills");
+  const skillRoot = resolve19(dirname7(dirname7(rootDir)), "skills");
   const missingSkills = [];
   const malformedSkills = [];
   let expectedSkillCount = 0;
   for (const entry of readdirSync10(sourceSkillsDir, { withFileTypes: true })) {
     if (!entry.isDirectory()) continue;
-    const sourceSkillPath = resolve18(sourceSkillsDir, entry.name, "SKILL.md");
-    if (!existsSync25(sourceSkillPath)) continue;
+    const sourceSkillPath = resolve19(sourceSkillsDir, entry.name, "SKILL.md");
+    if (!existsSync23(sourceSkillPath)) continue;
     expectedSkillCount++;
-    const installedSkillPath = resolve18(skillRoot, `${pluginName}-${entry.name}`, "SKILL.md");
-    if (!existsSync25(installedSkillPath)) {
+    const installedSkillPath = resolve19(skillRoot, `${pluginName}-${entry.name}`, "SKILL.md");
+    if (!existsSync23(installedSkillPath)) {
       missingSkills.push(`${pluginName}-${entry.name}`);
       continue;
     }
-    const installedContent = readFileSync12(installedSkillPath, "utf-8");
+    const installedContent = readFileSync13(installedSkillPath, "utf-8");
     if (!installedContent.includes(`${pluginName}/`)) {
       malformedSkills.push(`${pluginName}-${entry.name}`);
     }
@@ -18647,7 +19080,7 @@ async function doctorConsumer(rootDir = process.cwd()) {
 }
 async function doctorProject(rootDir = process.cwd()) {
   const checks = [];
-  const configPath = CONFIG_FILES.find((filename) => existsSync25(resolve18(rootDir, filename)));
+  const configPath = CONFIG_FILES.find((filename) => existsSync23(resolve19(rootDir, filename)));
   addRuntimeChecks(checks, "project");
   if (!configPath) {
     addCheck2(checks, {
@@ -18748,7 +19181,7 @@ function printDoctorReport(report) {
 
 // src/cli/dev.ts
 import { watch } from "fs";
-import { relative as relative11, resolve as resolve19 } from "path";
+import { relative as relative11, resolve as resolve20 } from "path";
 var WATCH_PATTERNS = [
   /^pluxx\.config\.(ts|js|json)$/,
   /^skills\//,
@@ -18774,7 +19207,7 @@ async function runDev(args2) {
   let pendingFile = null;
   const watcher = watch(rootDir, { recursive: true }, (_event, filename) => {
     if (!filename) return;
-    const rel = relative11(rootDir, resolve19(rootDir, filename));
+    const rel = relative11(rootDir, resolve20(rootDir, filename));
     if (rel.startsWith("dist/") || rel.startsWith(".") || rel.includes("node_modules")) {
       return;
     }
@@ -18829,8 +19262,8 @@ async function runBuild(rootDir, targets) {
 }
 
 // src/cli/migrate.ts
-import { basename as basename7, relative as relative12, resolve as resolve20 } from "path";
-import { existsSync as existsSync26, readdirSync as readdirSync11, mkdirSync as mkdirSync5, cpSync as cpSync4, readFileSync as readFileSync13, writeFileSync as writeFileSync5 } from "fs";
+import { basename as basename7, relative as relative12, resolve as resolve21 } from "path";
+import { existsSync as existsSync24, readdirSync as readdirSync11, mkdirSync as mkdirSync5, cpSync as cpSync4, readFileSync as readFileSync14, writeFileSync as writeFileSync5 } from "fs";
 function detectPlatform(pluginDir) {
   const checks = [
     { dir: ".claude-plugin", platform: "claude-code" },
@@ -18838,15 +19271,15 @@ function detectPlatform(pluginDir) {
     { dir: ".codex-plugin", platform: "codex" }
   ];
   for (const check of checks) {
-    const manifestPath = resolve20(pluginDir, check.dir, "plugin.json");
-    if (existsSync26(manifestPath)) {
+    const manifestPath = resolve21(pluginDir, check.dir, "plugin.json");
+    if (existsSync24(manifestPath)) {
       return { platform: check.platform, manifestPath };
     }
   }
-  const pkgPath = resolve20(pluginDir, "package.json");
-  if (existsSync26(pkgPath)) {
+  const pkgPath = resolve21(pluginDir, "package.json");
+  if (existsSync24(pkgPath)) {
     try {
-      const pkg = JSON.parse(readFileSync13(pkgPath, "utf-8"));
+      const pkg = JSON.parse(readFileSync14(pkgPath, "utf-8"));
       const deps = {
         ...pkg.dependencies,
         ...pkg.devDependencies,
@@ -18861,7 +19294,7 @@ function detectPlatform(pluginDir) {
   return null;
 }
 function parseManifest(detection) {
-  const raw = JSON.parse(readFileSync13(detection.manifestPath, "utf-8"));
+  const raw = JSON.parse(readFileSync14(detection.manifestPath, "utf-8"));
   const result = {};
   if (raw.name) result.name = raw.name;
   if (raw.version) result.version = raw.version;
@@ -18886,20 +19319,20 @@ function parseManifest(detection) {
 }
 function parseMcp(pluginDir, detection) {
   const mcpPaths = [
-    resolve20(pluginDir, ".mcp.json"),
-    resolve20(pluginDir, "mcp.json")
+    resolve21(pluginDir, ".mcp.json"),
+    resolve21(pluginDir, "mcp.json")
   ];
   try {
-    const manifest = JSON.parse(readFileSync13(detection.manifestPath, "utf-8"));
+    const manifest = JSON.parse(readFileSync14(detection.manifestPath, "utf-8"));
     if (manifest.mcpServers && typeof manifest.mcpServers === "string") {
-      mcpPaths.unshift(resolve20(pluginDir, manifest.mcpServers));
+      mcpPaths.unshift(resolve21(pluginDir, manifest.mcpServers));
     }
   } catch {
   }
   for (const mcpPath of mcpPaths) {
-    if (!existsSync26(mcpPath)) continue;
+    if (!existsSync24(mcpPath)) continue;
     try {
-      const raw = JSON.parse(readFileSync13(mcpPath, "utf-8"));
+      const raw = JSON.parse(readFileSync14(mcpPath, "utf-8"));
       const servers = raw.mcpServers ?? raw;
       if (!servers || typeof servers !== "object") continue;
       const result = {};
@@ -18979,21 +19412,21 @@ var HOOK_EVENT_MAP = {
 };
 function parseHooks(pluginDir, detection) {
   const hooksPaths = [
-    resolve20(pluginDir, ".codex", "hooks.json"),
-    resolve20(pluginDir, "hooks.json"),
-    resolve20(pluginDir, "hooks", "hooks.json")
+    resolve21(pluginDir, ".codex", "hooks.json"),
+    resolve21(pluginDir, "hooks.json"),
+    resolve21(pluginDir, "hooks", "hooks.json")
   ];
   try {
-    const manifest = JSON.parse(readFileSync13(detection.manifestPath, "utf-8"));
+    const manifest = JSON.parse(readFileSync14(detection.manifestPath, "utf-8"));
     if (manifest.hooks && typeof manifest.hooks === "string") {
-      hooksPaths.unshift(resolve20(pluginDir, manifest.hooks));
+      hooksPaths.unshift(resolve21(pluginDir, manifest.hooks));
     }
   } catch {
   }
   for (const hooksPath of hooksPaths) {
-    if (!existsSync26(hooksPath)) continue;
+    if (!existsSync24(hooksPath)) continue;
     try {
-      const raw = JSON.parse(readFileSync13(hooksPath, "utf-8"));
+      const raw = JSON.parse(readFileSync14(hooksPath, "utf-8"));
       const hooksObj = raw.hooks ?? raw;
       if (!hooksObj || typeof hooksObj !== "object") continue;
       const result = {};
@@ -19039,8 +19472,8 @@ function findInstructions(pluginDir) {
     "README.md"
   ];
   for (const candidate of candidates) {
-    const filePath = resolve20(pluginDir, candidate);
-    if (existsSync26(filePath)) {
+    const filePath = resolve21(pluginDir, candidate);
+    if (existsSync24(filePath)) {
       return `./${candidate}`;
     }
   }
@@ -19065,7 +19498,7 @@ function detectCanonicalSourcePaths(pluginDir) {
   for (const bucket of Object.keys(CANONICAL_SOURCE_CANDIDATES)) {
     for (const candidate of CANONICAL_SOURCE_CANDIDATES[bucket]) {
       const normalized = stripRelativePrefix(candidate);
-      if (!existsSync26(resolve20(pluginDir, normalized))) continue;
+      if (!existsSync24(resolve21(pluginDir, normalized))) continue;
       result[bucket] = normalizeRelativeDir(normalized);
       break;
     }
@@ -19080,8 +19513,8 @@ function detectPassthroughDirs(pluginDir, mcp) {
       const match = part.match(/\$\{[A-Z_]*PLUGIN_ROOT\}\/([^/]+)/);
       if (!match?.[1]) continue;
       const dirName = match[1];
-      const dirPath = resolve20(pluginDir, dirName);
-      if (existsSync26(dirPath)) {
+      const dirPath = resolve21(pluginDir, dirName);
+      if (existsSync24(dirPath)) {
         passthrough.add(`./${dirName}/`);
       }
     }
@@ -19116,7 +19549,7 @@ function inferPermissionsFromMigratedSkills(pluginDir, sourcePaths) {
   if (!sourcePaths.skills) {
     return { notes: [], skillPolicies: [] };
   }
-  const skillsDir = resolve20(pluginDir, stripRelativePrefix(sourcePaths.skills));
+  const skillsDir = resolve21(pluginDir, stripRelativePrefix(sourcePaths.skills));
   const entries = readdirSync11(skillsDir, { withFileTypes: true });
   const allow = /* @__PURE__ */ new Set();
   const notes = [];
@@ -19124,19 +19557,33 @@ function inferPermissionsFromMigratedSkills(pluginDir, sourcePaths) {
   let sawAllowedTools = false;
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
-    const skillPath = resolve20(skillsDir, entry.name, "SKILL.md");
-    if (!existsSync26(skillPath)) continue;
-    const skill = parseSkillMarkdown(readFileSync13(skillPath, "utf-8"));
+    const skillPath = resolve21(skillsDir, entry.name, "SKILL.md");
+    if (!existsSync24(skillPath)) continue;
+    const skill = parseSkillMarkdown(readFileSync14(skillPath, "utf-8"));
     const inferredRules = skill.allowedTools.map(normalizeMigratedAllowedTool).filter((rule) => Boolean(rule));
     if (inferredRules.length === 0) continue;
     sawAllowedTools = true;
     for (const rule of inferredRules) {
       allow.add(rule);
     }
+    const sourceFrontmatter = {};
+    if (skill.whenToUse) sourceFrontmatter.when_to_use = skill.whenToUse;
+    if (skill.argumentHint) sourceFrontmatter["argument-hint"] = skill.argumentHint;
+    if (skill.arguments.length > 0) sourceFrontmatter.arguments = skill.arguments;
+    if (typeof skill.disableModelInvocation === "boolean") sourceFrontmatter["disable-model-invocation"] = skill.disableModelInvocation;
+    if (typeof skill.userInvocable === "boolean") sourceFrontmatter["user-invocable"] = skill.userInvocable;
+    if (skill.model) sourceFrontmatter.model = skill.model;
+    if (skill.effort) sourceFrontmatter.effort = skill.effort;
+    if (skill.context) sourceFrontmatter.context = skill.context;
+    if (skill.agent) sourceFrontmatter.agent = skill.agent;
+    if (skill.hooks !== void 0) sourceFrontmatter.hooks = skill.hooks;
+    if (skill.paths.length > 0) sourceFrontmatter.paths = skill.paths;
+    if (skill.shell) sourceFrontmatter.shell = skill.shell;
     skillPolicies.push({
       skillDir: entry.name,
       title: skill.name ?? skill.firstHeading ?? titleCaseFromDirName(entry.name),
       description: skill.description,
+      ...Object.keys(sourceFrontmatter).length > 0 ? { sourceFrontmatter } : {},
       source: {
         kind: "claude-allowed-tools",
         platform: "claude-code"
@@ -19151,6 +19598,7 @@ function inferPermissionsFromMigratedSkills(pluginDir, sourcePaths) {
   }
   notes.push("Inferred from Claude-style allowed-tools frontmatter.");
   notes.push(`Preserved skill-scoped tool access in ${PLUXX_COMPILER_INTENT_PATH} and flattened it into plugin-level canonical permissions as a fallback.`);
+  notes.push(`Preserved richer Claude skill frontmatter in ${PLUXX_COMPILER_INTENT_PATH} so migrate does not collapse author intent back into opaque markdown.`);
   return {
     permissions: {
       allow: [...allow].sort()
@@ -19162,7 +19610,7 @@ function inferPermissionsFromMigratedSkills(pluginDir, sourcePaths) {
 function readMigratedSkills(pluginDir, sourcePaths) {
   const skills = [];
   if (sourcePaths.skills) {
-    const skillsDir = resolve20(pluginDir, stripRelativePrefix(sourcePaths.skills));
+    const skillsDir = resolve21(pluginDir, stripRelativePrefix(sourcePaths.skills));
     for (const skill of readCanonicalSkillFiles(skillsDir)) {
       skills.push({
         dirName: skill.dirName,
@@ -19173,12 +19621,12 @@ function readMigratedSkills(pluginDir, sourcePaths) {
     }
   }
   if (skills.length === 0 && sourcePaths.commands) {
-    const commandsDir = resolve20(pluginDir, stripRelativePrefix(sourcePaths.commands));
+    const commandsDir = resolve21(pluginDir, stripRelativePrefix(sourcePaths.commands));
     const entries = readdirSync11(commandsDir, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
       const dirName = toKebabCase2(entry.name.replace(/\.md$/, "")) || "command";
-      const content = readFileSync13(resolve20(commandsDir, entry.name), "utf-8");
+      const content = readFileSync14(resolve21(commandsDir, entry.name), "utf-8");
       const parsed = parseSkillMarkdown(content);
       skills.push({
         dirName,
@@ -19194,14 +19642,14 @@ var HOST_NATIVE_SKILL_FRONTMATTER_KEYS = /* @__PURE__ */ new Set([
   "allowed-tools"
 ]);
 function sanitizeMigratedSkillFrontmatter(outputDir) {
-  if (!existsSync26(resolve20(outputDir, "skills"))) return;
-  const skillsDir = resolve20(outputDir, "skills");
+  if (!existsSync24(resolve21(outputDir, "skills"))) return;
+  const skillsDir = resolve21(outputDir, "skills");
   const entries = readdirSync11(skillsDir, { withFileTypes: true });
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
-    const skillPath = resolve20(skillsDir, entry.name, "SKILL.md");
-    if (!existsSync26(skillPath)) continue;
-    const parsed = parseSkillMarkdown(readFileSync13(skillPath, "utf-8"));
+    const skillPath = resolve21(skillsDir, entry.name, "SKILL.md");
+    if (!existsSync24(skillPath)) continue;
+    const parsed = parseSkillMarkdown(readFileSync14(skillPath, "utf-8"));
     if (!parsed.hasValidFrontmatter) continue;
     const sanitized = parsed.frontmatterLines.filter((line) => {
       const match = /^([A-Za-z0-9_-]+)\s*:/.exec(line.trim());
@@ -19293,7 +19741,7 @@ function hasTopLevelFrontmatterKey(frontmatterLines, key) {
   });
 }
 function normalizeMigratedOpenCodeAgentFile(agentPath) {
-  const original = readFileSync13(agentPath, "utf-8");
+  const original = readFileSync14(agentPath, "utf-8");
   const parsed = splitMarkdownFrontmatter5(original);
   const fileStem = toKebabCase2(basename7(agentPath, ".md")) || "agent";
   const fallbackDescription = buildFallbackAgentDescription(fileStem);
@@ -19335,7 +19783,7 @@ function walkMarkdownFiles3(dir) {
   const entries = readdirSync11(dir, { withFileTypes: true });
   const files = [];
   for (const entry of entries) {
-    const fullPath = resolve20(dir, entry.name);
+    const fullPath = resolve21(dir, entry.name);
     if (entry.isDirectory()) {
       files.push(...walkMarkdownFiles3(fullPath));
       continue;
@@ -19347,7 +19795,7 @@ function walkMarkdownFiles3(dir) {
   return files;
 }
 function normalizeMigratedOpenCodeAgents(destDir) {
-  if (!existsSync26(destDir)) return [];
+  if (!existsSync24(destDir)) return [];
   const normalized = [];
   for (const filePath of walkMarkdownFiles3(destDir)) {
     if (normalizeMigratedOpenCodeAgentFile(filePath)) {
@@ -19362,11 +19810,11 @@ function copyCodexAgents(sourceDir, destDir) {
   if (tomlEntries.length === 0) return false;
   mkdirSync5(destDir, { recursive: true });
   for (const entry of tomlEntries) {
-    const sourcePath = resolve20(sourceDir, entry.name);
-    const parsed = parseCodexAgentToml(readFileSync13(sourcePath, "utf-8"));
+    const sourcePath = resolve21(sourceDir, entry.name);
+    const parsed = parseCodexAgentToml(readFileSync14(sourcePath, "utf-8"));
     const fallbackName = entry.name.replace(/\.toml$/, "");
     const fileName = `${toKebabCase2(parsed.name ?? fallbackName) || "agent"}.md`;
-    writeFileSync5(resolve20(destDir, fileName), renderMigratedAgentMarkdown(fallbackName, parsed), "utf-8");
+    writeFileSync5(resolve21(destDir, fileName), renderMigratedAgentMarkdown(fallbackName, parsed), "utf-8");
   }
   return true;
 }
@@ -19435,13 +19883,13 @@ function buildMigratedScaffoldMetadata(result, outputDir) {
     ...["skills", "commands", "agents", "scripts", "assets"].flatMap((dir) => {
       if (!result.sourcePaths[dir]) return [];
       const baseDir = dir;
-      const dirPath = resolve20(outputDir, baseDir);
-      if (!existsSync26(dirPath)) return [];
+      const dirPath = resolve21(outputDir, baseDir);
+      if (!existsSync24(dirPath)) return [];
       const entries = readdirSync11(dirPath, { withFileTypes: true });
       const files = [];
       for (const entry of entries) {
         if (entry.isDirectory()) {
-          const nestedDir = resolve20(dirPath, entry.name);
+          const nestedDir = resolve21(dirPath, entry.name);
           for (const nested of readdirSync11(nestedDir, { withFileTypes: true })) {
             if (nested.isFile()) {
               files.push(`${baseDir}/${entry.name}/${nested.name}`);
@@ -19501,9 +19949,9 @@ function copyDirectories(pluginDir, outputDir, sourcePaths, passthrough) {
     const sourcePath = sourcePaths[dir];
     if (!sourcePath) continue;
     const normalizedSource = stripRelativePrefix(sourcePath);
-    const src = resolve20(pluginDir, normalizedSource);
-    const dest = resolve20(outputDir, dir);
-    if (existsSync26(dest)) {
+    const src = resolve21(pluginDir, normalizedSource);
+    const dest = resolve21(outputDir, dir);
+    if (existsSync24(dest)) {
       console.log(`  skip ./${dir}/ (already exists)`);
       continue;
     }
@@ -19518,9 +19966,9 @@ function copyDirectories(pluginDir, outputDir, sourcePaths, passthrough) {
   }
   for (const entry of passthrough) {
     const normalized = entry.replace(/^\.\//, "").replace(/\/$/, "");
-    const src = resolve20(pluginDir, normalized);
-    const dest = resolve20(outputDir, normalized);
-    if (existsSync26(dest)) {
+    const src = resolve21(pluginDir, normalized);
+    const dest = resolve21(outputDir, normalized);
+    if (existsSync24(dest)) {
       console.log(`  skip ./${normalized}/ (already exists)`);
       continue;
     }
@@ -19664,9 +20112,9 @@ function quote(s) {
   return `'${s.replace(/'/g, "\\'")}'`;
 }
 async function migrate(inputPath) {
-  const pluginDir = resolve20(inputPath);
+  const pluginDir = resolve21(inputPath);
   const outputDir = process.cwd();
-  if (!existsSync26(pluginDir)) {
+  if (!existsSync24(pluginDir)) {
     console.error(`Error: Path does not exist: ${pluginDir}`);
     process.exit(1);
   }
@@ -19732,8 +20180,8 @@ async function migrate(inputPath) {
     } : {}
   };
   const configContent = generateConfigTs(result);
-  const configPath = resolve20(outputDir, "pluxx.config.ts");
-  if (existsSync26(configPath)) {
+  const configPath = resolve21(outputDir, "pluxx.config.ts");
+  if (existsSync24(configPath)) {
     console.error(`
 Error: pluxx.config.ts already exists in ${outputDir}`);
     console.error("Remove it first or run from a different directory.");
@@ -19748,22 +20196,22 @@ Generated pluxx.config.ts`);
   }
   sanitizeMigratedSkillFrontmatter(outputDir);
   if (instructions) {
-    const srcInstr = resolve20(pluginDir, instructions);
-    const destInstr = resolve20(outputDir, instructions);
-    if (!existsSync26(destInstr)) {
-      const content = readFileSync13(srcInstr, "utf-8");
+    const srcInstr = resolve21(pluginDir, instructions);
+    const destInstr = resolve21(outputDir, instructions);
+    if (!existsSync24(destInstr)) {
+      const content = readFileSync14(srcInstr, "utf-8");
       await writeTextFile(destInstr, content);
       console.log(`Copied: ${instructions}`);
     }
   }
-  const taxonomyPath = resolve20(outputDir, MCP_TAXONOMY_PATH);
-  const metadataPath = resolve20(outputDir, MCP_SCAFFOLD_METADATA_PATH);
-  mkdirSync5(resolve20(outputDir, ".pluxx"), { recursive: true });
+  const taxonomyPath = resolve21(outputDir, MCP_TAXONOMY_PATH);
+  const metadataPath = resolve21(outputDir, MCP_SCAFFOLD_METADATA_PATH);
+  mkdirSync5(resolve21(outputDir, ".pluxx"), { recursive: true });
   await writeTextFile(taxonomyPath, `${JSON.stringify(result.persistedSkills, null, 2)}
 `);
   if (result.compilerIntent) {
     await writeTextFile(
-      resolve20(outputDir, PLUXX_COMPILER_INTENT_PATH),
+      resolve21(outputDir, PLUXX_COMPILER_INTENT_PATH),
       `${JSON.stringify(result.compilerIntent, null, 2)}
 `
     );
@@ -19785,8 +20233,8 @@ Generated pluxx.config.ts`);
 }
 
 // src/cli/mcp-proxy.ts
-import { mkdirSync as mkdirSync6, readFileSync as readFileSync14 } from "fs";
-import { dirname as dirname8, resolve as resolve21 } from "path";
+import { mkdirSync as mkdirSync6, readFileSync as readFileSync15 } from "fs";
+import { dirname as dirname8, resolve as resolve22 } from "path";
 import * as readline3 from "readline";
 function usage() {
   return [
@@ -19854,15 +20302,15 @@ function sendError(output, id, code, message) {
   });
 }
 async function loadReplayTape(filepath) {
-  const absolutePath = resolve21(process.cwd(), filepath);
-  const tape = JSON.parse(readFileSync14(absolutePath, "utf-8"));
+  const absolutePath = resolve22(process.cwd(), filepath);
+  const tape = JSON.parse(readFileSync15(absolutePath, "utf-8"));
   if (tape.version !== 1 || !Array.isArray(tape.interactions)) {
     throw new Error(`Replay tape is not a valid pluxx MCP tape: ${filepath}`);
   }
   return tape;
 }
 async function writeTape(filepath, tape) {
-  const absolutePath = resolve21(process.cwd(), filepath);
+  const absolutePath = resolve22(process.cwd(), filepath);
   mkdirSync6(dirname8(absolutePath), { recursive: true });
   await writeTextFile(absolutePath, `${JSON.stringify(tape, null, 2)}
 `);
@@ -20034,7 +20482,7 @@ var PromptCancelledError = class extends Error {
   }
 };
 function ask(question) {
-  return new Promise((resolve27, reject) => {
+  return new Promise((resolve28, reject) => {
     const rl = readline4.createInterface({
       input: process.stdin,
       output: process.stdout
@@ -20062,7 +20510,7 @@ function ask(question) {
     rl.once("close", onClose);
     rl.question(question, (answer) => {
       settle(() => {
-        resolve27(answer);
+        resolve28(answer);
         rl.close();
       });
     });
@@ -21037,15 +21485,15 @@ ${c2}
 } }).prompt();
 
 // src/cli/index.ts
-import { basename as basename8, resolve as resolve26 } from "path";
+import { basename as basename8, resolve as resolve27 } from "path";
 import { mkdir as mkdir4, mkdtemp as mkdtemp3, rm as rm4 } from "fs/promises";
 import { tmpdir as tmpdir5 } from "os";
 import { spawn as spawn5, spawnSync as spawnSync3 } from "child_process";
 
 // src/cli/publish.ts
-import { chmodSync, existsSync as existsSync27, mkdtempSync as mkdtempSync2, readFileSync as readFileSync15, rmSync as rmSync4, writeFileSync as writeFileSync6 } from "fs";
+import { chmodSync, existsSync as existsSync25, mkdtempSync as mkdtempSync2, readFileSync as readFileSync16, rmSync as rmSync4, writeFileSync as writeFileSync6 } from "fs";
 import { createHash } from "crypto";
-import { resolve as resolve22 } from "path";
+import { resolve as resolve23 } from "path";
 import { spawnSync as spawnSync2 } from "child_process";
 import { tmpdir as tmpdir3 } from "os";
 var INSTALLER_TARGETS = ["claude-code", "cursor", "codex", "opencode"];
@@ -21078,7 +21526,7 @@ function resolveRequestedChannels(options) {
 }
 function getBuiltTargets(rootDir, config) {
   return config.targets.filter(
-    (platform) => existsSync27(resolve22(rootDir, config.outDir, platform))
+    (platform) => existsSync25(resolve23(rootDir, config.outDir, platform))
   );
 }
 function getArchiveAssetName(pluginName, platform, version, variant) {
@@ -21090,7 +21538,7 @@ function getInstallerScriptName(platform) {
 function buildReleaseAssets(rootDir, config, version, targets) {
   const assets = [];
   for (const platform of targets) {
-    const bundlePath = resolve22(rootDir, config.outDir, platform);
+    const bundlePath = resolve23(rootDir, config.outDir, platform);
     assets.push({
       kind: "archive",
       platform,
@@ -21135,13 +21583,13 @@ function buildReleaseAssets(rootDir, config, version, targets) {
   return assets;
 }
 function readNpmPackageName(rootDir, config) {
-  const packageDir = resolve22(rootDir, config.outDir, "opencode");
-  const packageJsonPath = resolve22(packageDir, "package.json");
-  if (!existsSync27(packageJsonPath)) {
+  const packageDir = resolve23(rootDir, config.outDir, "opencode");
+  const packageJsonPath = resolve23(packageDir, "package.json");
+  if (!existsSync25(packageJsonPath)) {
     return {};
   }
   try {
-    const pkg = JSON.parse(readFileSync15(packageJsonPath, "utf-8"));
+    const pkg = JSON.parse(readFileSync16(packageJsonPath, "utf-8"));
     return {
       packageName: pkg.name,
       packageDir
@@ -21190,7 +21638,7 @@ function collectChecks(args2) {
   if (args2.npmEnabled) {
     checks.push({
       name: "npm-package-ready",
-      ok: Boolean(args2.packageDir && existsSync27(resolve22(args2.packageDir, "package.json")) && args2.packageName),
+      ok: Boolean(args2.packageDir && existsSync25(resolve23(args2.packageDir, "package.json")) && args2.packageName),
       code: "npm-package-ready",
       detail: args2.packageDir ? `OpenCode package dir: ${args2.packageDir}` : "No npm-backed target package found."
     });
@@ -21689,7 +22137,7 @@ claude plugin install "\${PLUGIN_NAME}@\${MARKETPLACE_NAME}" --scope user
 
 echo
 echo "Installed \${PLUGIN_NAME}@\${MARKETPLACE_NAME} into Claude Code user scope."
-echo "If Claude is already open, run /reload-plugins in the active session."
+echo "${getPublishReloadInstruction("claude-code")}"
 `;
 }
 function renderInstallCursorScript(config) {
@@ -21746,7 +22194,7 @@ ${renderInstallerMcpPathMaterializationSnippet("cursor", "$INSTALL_DIR")}
 ${renderInstallerRuntimeBootstrapSnippet("$INSTALL_DIR")}
 
 echo "Installed $PLUGIN_NAME to $INSTALL_DIR"
-echo "If Cursor is already open, use Developer: Reload Window or restart Cursor so the plugin is picked up."
+echo "${getPublishReloadInstruction("cursor")}"
 `;
 }
 function renderInstallCodexScript(config) {
@@ -21863,7 +22311,7 @@ NODE
 
 echo "Installed $PLUGIN_NAME to $INSTALL_DIR"
 echo "Updated Codex marketplace catalog at $MARKETPLACE_PATH"
-echo "If Codex is already open, use Plugins > Refresh if that action is available in your current UI, or restart Codex so the plugin is picked up."
+echo "${getPublishReloadInstruction("codex")}"
 `;
 }
 function renderInstallOpenCodeScript(config) {
@@ -22010,7 +22458,7 @@ fi
 echo "Installed $PLUGIN_NAME plugin code to $INSTALL_DIR"
 echo "Installed OpenCode wrapper at $ENTRY_PATH"
 echo "Synced namespaced skills into $SKILLS_ROOT"
-echo "If OpenCode is already open, restart or reload it so the plugin is picked up."
+echo "${getPublishReloadInstruction("opencode")}"
 `;
 }
 function replaceInstallerPlaceholders(script, config, context) {
@@ -22035,9 +22483,9 @@ function renderInstallerScript(asset, config, context) {
   throw new Error(`No installer template for asset ${asset.name}`);
 }
 function writeChecksumFile(tempRoot, files) {
-  const checksumPath = resolve22(tempRoot, "SHA256SUMS.txt");
+  const checksumPath = resolve23(tempRoot, "SHA256SUMS.txt");
   const lines = files.map((filePath) => {
-    const digest = createHash("sha256").update(readFileSync15(filePath)).digest("hex");
+    const digest = createHash("sha256").update(readFileSync16(filePath)).digest("hex");
     const name = filePath.split("/").pop();
     return `${digest}  ${name}`;
   }).join("\n");
@@ -22046,7 +22494,7 @@ function writeChecksumFile(tempRoot, files) {
   return checksumPath;
 }
 function createReleaseArtifacts(rootDir, config, plan, runCommand) {
-  const tempRoot = mkdtempSync2(resolve22(tmpdir3(), "pluxx-publish-"));
+  const tempRoot = mkdtempSync2(resolve23(tmpdir3(), "pluxx-publish-"));
   const created = [];
   const githubRelease = plan.channels.githubRelease;
   if (!githubRelease.repo || !githubRelease.releaseTag) {
@@ -22066,10 +22514,10 @@ function createReleaseArtifacts(rootDir, config, plan, runCommand) {
   try {
     for (const asset of githubRelease.assets) {
       if (asset.kind !== "archive") continue;
-      const archivePath = resolve22(tempRoot, asset.name);
+      const archivePath = resolve23(tempRoot, asset.name);
       const result = runCommand(
         "tar",
-        ["-czf", archivePath, "-C", resolve22(rootDir, config.outDir), asset.platform],
+        ["-czf", archivePath, "-C", resolve23(rootDir, config.outDir), asset.platform],
         { cwd: rootDir }
       );
       if (result.status !== 0) {
@@ -22079,21 +22527,21 @@ function createReleaseArtifacts(rootDir, config, plan, runCommand) {
     }
     for (const asset of githubRelease.assets) {
       if (asset.kind !== "installer") continue;
-      const installerPath = resolve22(tempRoot, asset.name);
+      const installerPath = resolve23(tempRoot, asset.name);
       writeFileSync6(installerPath, renderInstallerScript(asset, config, context));
       chmodSync(installerPath, 493);
       created.push(installerPath);
     }
     const manifestAsset = githubRelease.assets.find((asset) => asset.kind === "manifest");
     if (manifestAsset) {
-      const manifestPath = resolve22(tempRoot, manifestAsset.name);
+      const manifestPath = resolve23(tempRoot, manifestAsset.name);
       writeFileSync6(manifestPath, buildReleaseManifest(config, context));
       created.push(manifestPath);
     }
     const checksumAsset = githubRelease.assets.find((asset) => asset.kind === "checksum");
     if (checksumAsset) {
       const checksumPath = writeChecksumFile(tempRoot, created);
-      if (checksumPath !== resolve22(tempRoot, checksumAsset.name)) {
+      if (checksumPath !== resolve23(tempRoot, checksumAsset.name)) {
         throw new Error(`Checksum output path mismatch for ${checksumAsset.name}`);
       }
       created.push(checksumPath);
@@ -22248,18 +22696,18 @@ function printJson(value) {
 }
 
 // src/cli/verify-install.ts
-import { existsSync as existsSync28, lstatSync as lstatSync4, readdirSync as readdirSync12, readFileSync as readFileSync16, readlinkSync, realpathSync, statSync as statSync5 } from "fs";
-import { resolve as resolve23 } from "path";
+import { existsSync as existsSync26, lstatSync as lstatSync4, readdirSync as readdirSync12, readFileSync as readFileSync17, readlinkSync, realpathSync, statSync as statSync5 } from "fs";
+import { resolve as resolve24 } from "path";
 function buildCheckFromReport(target, pluginName, report) {
   const consumerPath = resolveInstalledConsumerPath(target, pluginName);
-  const staleReason = target.built && existsSync28(consumerPath) ? detectStaleInstall(target, pluginName, consumerPath) : void 0;
+  const staleReason = target.built && existsSync26(consumerPath) ? detectStaleInstall(target, pluginName, consumerPath) : void 0;
   const stale = staleReason !== void 0;
   return {
     platform: target.platform,
     installPath: consumerPath,
     consumerPath,
     built: target.built,
-    installed: existsSync28(consumerPath),
+    installed: existsSync26(consumerPath),
     stale,
     ...staleReason ? { staleReason } : {},
     ok: report.errors === 0 && !stale,
@@ -22285,10 +22733,10 @@ function manifestPathForPlatform2(platform) {
 function readInstalledManifestVersion(rootDir, platform) {
   const manifestPath = manifestPathForPlatform2(platform);
   if (!manifestPath) return void 0;
-  const filepath = resolve23(rootDir, manifestPath);
-  if (!existsSync28(filepath)) return void 0;
+  const filepath = resolve24(rootDir, manifestPath);
+  if (!existsSync26(filepath)) return void 0;
   try {
-    const manifest = JSON.parse(readFileSync16(filepath, "utf-8"));
+    const manifest = JSON.parse(readFileSync17(filepath, "utf-8"));
     return typeof manifest.version === "string" ? manifest.version : void 0;
   } catch {
     return void 0;
@@ -22296,14 +22744,14 @@ function readInstalledManifestVersion(rootDir, platform) {
 }
 function findCodexCacheCandidates(pluginName) {
   const home = process.env.HOME ?? "~";
-  const cacheRoot = resolve23(home, ".codex/plugins/cache");
-  if (!existsSync28(cacheRoot)) return [];
+  const cacheRoot = resolve24(home, ".codex/plugins/cache");
+  if (!existsSync26(cacheRoot)) return [];
   const candidates = [];
   for (const marketplace of readdirSync12(cacheRoot)) {
-    const pluginRoot = resolve23(cacheRoot, marketplace, pluginName);
-    if (!existsSync28(pluginRoot)) continue;
+    const pluginRoot = resolve24(cacheRoot, marketplace, pluginName);
+    if (!existsSync26(pluginRoot)) continue;
     for (const versionDir of readdirSync12(pluginRoot)) {
-      const candidatePath = resolve23(pluginRoot, versionDir);
+      const candidatePath = resolve24(pluginRoot, versionDir);
       try {
         const stats = statSync5(candidatePath);
         if (!stats.isDirectory()) continue;
@@ -22351,7 +22799,7 @@ function detectStaleInstall(target, pluginName, consumerPath) {
 }
 async function verifyInstall(config, options = {}) {
   const rootDir = options.rootDir ?? process.cwd();
-  const distDir = resolve23(rootDir, config.outDir);
+  const distDir = resolve24(rootDir, config.outDir);
   const targets = options.targets ?? config.targets;
   const installPlan = planInstallPlugin(distDir, config.name, targets);
   const filteredPlan = options.builtOnly ? installPlan.filter((target) => target.built) : installPlan;
@@ -22397,9 +22845,8 @@ function getVerifyInstallRecoveryActions(check) {
   }
   if (check.stale) {
     actions.push(`rerun pluxx install --target ${check.platform} to replace the stale local install`);
-    if (check.platform === "codex") {
-      actions.push("in Codex, use Plugins > Refresh if available, or restart Codex so the plugin cache reloads");
-    }
+    const staleAction = getVerifyInstallStaleAction(check.platform);
+    if (staleAction) actions.push(staleAction);
   }
   if (check.errors > 0 && actions.length === 0) {
     actions.push(`run pluxx doctor --consumer "${check.consumerPath}" for the detailed host-specific failure`);
@@ -22408,10 +22855,10 @@ function getVerifyInstallRecoveryActions(check) {
 }
 
 // src/cli/behavioral.ts
-import { existsSync as existsSync29, readFileSync as readFileSync17 } from "fs";
+import { existsSync as existsSync27, readFileSync as readFileSync18 } from "fs";
 import { mkdtemp as mkdtemp2, rm as rm3 } from "fs/promises";
 import { tmpdir as tmpdir4 } from "os";
-import { resolve as resolve24 } from "path";
+import { resolve as resolve25 } from "path";
 import { spawn as spawn4 } from "child_process";
 var BEHAVIORAL_CONFIG_PATH = ".pluxx/behavioral-smoke.json";
 var CURSOR_RUNNER_BINARIES2 = ["agent", "cursor-agent"];
@@ -22444,13 +22891,13 @@ function loadBehavioralCases(rootDir, targets, promptOverride) {
       )
     }];
   }
-  const filePath = resolve24(rootDir, BEHAVIORAL_CONFIG_PATH);
-  if (!existsSync29(filePath)) {
+  const filePath = resolve25(rootDir, BEHAVIORAL_CONFIG_PATH);
+  if (!existsSync27(filePath)) {
     throw new Error(
       `No behavioral smoke config found at ${BEHAVIORAL_CONFIG_PATH}. Add that file or pass --behavioral-prompt to define a real example query.`
     );
   }
-  const parsed = JSON.parse(readFileSync17(filePath, "utf-8"));
+  const parsed = JSON.parse(readFileSync18(filePath, "utf-8"));
   if (!parsed || typeof parsed !== "object" || !Array.isArray(parsed.cases) || parsed.cases.length === 0) {
     throw new Error(`${BEHAVIORAL_CONFIG_PATH} must contain a non-empty "cases" array.`);
   }
@@ -22541,8 +22988,8 @@ async function executeBehavioralCommand(platform, command2, cwd) {
   let codexLastMessagePath = null;
   const runtimeCommand = [...command2];
   if (platform === "codex") {
-    codexOutputDir = await mkdtemp2(resolve24(tmpdir4(), "pluxx-codex-behavioral-"));
-    codexLastMessagePath = resolve24(codexOutputDir, "last-message.txt");
+    codexOutputDir = await mkdtemp2(resolve25(tmpdir4(), "pluxx-codex-behavioral-"));
+    codexLastMessagePath = resolve25(codexOutputDir, "last-message.txt");
     runtimeCommand.splice(2, 0, "--output-last-message", codexLastMessagePath);
   }
   try {
@@ -22560,7 +23007,7 @@ async function executeBehavioralCommand(platform, command2, cwd) {
       child.on("close", (code) => {
         const stdout = Buffer.concat(stdoutChunks).toString("utf-8");
         const stderr = Buffer.concat(stderrChunks).toString("utf-8");
-        const codexMessage = codexLastMessagePath && existsSync29(codexLastMessagePath) ? readFileSync17(codexLastMessagePath, "utf-8") : "";
+        const codexMessage = codexLastMessagePath && existsSync27(codexLastMessagePath) ? readFileSync18(codexLastMessagePath, "utf-8") : "";
         resolvePromise({
           exitCode: code ?? 1,
           response: codexMessage.trim() || stdout.trim() || stderr.trim()
@@ -22623,9 +23070,9 @@ function shellQuote2(value) {
 }
 
 // src/cli/discover-installed-mcp.ts
-import { existsSync as existsSync30, readFileSync as readFileSync18 } from "fs";
+import { existsSync as existsSync28, readFileSync as readFileSync19 } from "fs";
 import { homedir as homedir2 } from "os";
-import { resolve as resolve25 } from "path";
+import { resolve as resolve26 } from "path";
 var INSTALLED_MCP_HOSTS = ["claude-code", "cursor", "codex", "opencode"];
 function discoverInstalledMcpServers(options = {}) {
   const rootDir = options.rootDir ?? process.cwd();
@@ -22634,7 +23081,7 @@ function discoverInstalledMcpServers(options = {}) {
   const results = [];
   const seen = /* @__PURE__ */ new Set();
   for (const candidate of installedMcpFileCandidates(rootDir, homeDir)) {
-    if (!hostSet.has(candidate.host) || !existsSync30(candidate.path)) continue;
+    if (!hostSet.has(candidate.host) || !existsSync28(candidate.path)) continue;
     const parsed = candidate.parser === "json" ? parseJsonMcpFile(candidate.path, candidate.host) : parseCodexTomlMcpFile(candidate.path);
     for (const discovered of parsed) {
       const key = `${discovered.host}:${discovered.serverName}:${discovered.sourcePath}`;
@@ -22697,27 +23144,27 @@ function formatInstalledMcpSource(discovered) {
 }
 function installedMcpFileCandidates(rootDir, homeDir) {
   return [
-    { host: "claude-code", path: resolve25(rootDir, ".mcp.json"), parser: "json" },
-    { host: "claude-code", path: resolve25(rootDir, ".claude-plugin/plugin.json"), parser: "json" },
-    { host: "claude-code", path: resolve25(rootDir, ".claude/settings.json"), parser: "json" },
-    { host: "claude-code", path: resolve25(rootDir, ".claude/settings.local.json"), parser: "json" },
-    { host: "claude-code", path: resolve25(homeDir, ".claude/settings.json"), parser: "json" },
-    { host: "claude-code", path: resolve25(homeDir, ".claude/settings.local.json"), parser: "json" },
-    { host: "claude-code", path: resolve25(homeDir, ".claude.json"), parser: "json" },
-    { host: "cursor", path: resolve25(rootDir, "mcp.json"), parser: "json" },
-    { host: "cursor", path: resolve25(rootDir, ".cursor/mcp.json"), parser: "json" },
-    { host: "cursor", path: resolve25(homeDir, ".cursor/mcp.json"), parser: "json" },
-    { host: "codex", path: resolve25(rootDir, ".mcp.json"), parser: "json" },
-    { host: "codex", path: resolve25(rootDir, ".codex/config.toml"), parser: "toml" },
-    { host: "codex", path: resolve25(homeDir, ".codex/config.toml"), parser: "toml" },
-    { host: "opencode", path: resolve25(rootDir, "opencode.json"), parser: "json" },
-    { host: "opencode", path: resolve25(rootDir, ".opencode.json"), parser: "json" },
-    { host: "opencode", path: resolve25(homeDir, ".config/opencode/opencode.json"), parser: "json" }
+    { host: "claude-code", path: resolve26(rootDir, ".mcp.json"), parser: "json" },
+    { host: "claude-code", path: resolve26(rootDir, ".claude-plugin/plugin.json"), parser: "json" },
+    { host: "claude-code", path: resolve26(rootDir, ".claude/settings.json"), parser: "json" },
+    { host: "claude-code", path: resolve26(rootDir, ".claude/settings.local.json"), parser: "json" },
+    { host: "claude-code", path: resolve26(homeDir, ".claude/settings.json"), parser: "json" },
+    { host: "claude-code", path: resolve26(homeDir, ".claude/settings.local.json"), parser: "json" },
+    { host: "claude-code", path: resolve26(homeDir, ".claude.json"), parser: "json" },
+    { host: "cursor", path: resolve26(rootDir, "mcp.json"), parser: "json" },
+    { host: "cursor", path: resolve26(rootDir, ".cursor/mcp.json"), parser: "json" },
+    { host: "cursor", path: resolve26(homeDir, ".cursor/mcp.json"), parser: "json" },
+    { host: "codex", path: resolve26(rootDir, ".mcp.json"), parser: "json" },
+    { host: "codex", path: resolve26(rootDir, ".codex/config.toml"), parser: "toml" },
+    { host: "codex", path: resolve26(homeDir, ".codex/config.toml"), parser: "toml" },
+    { host: "opencode", path: resolve26(rootDir, "opencode.json"), parser: "json" },
+    { host: "opencode", path: resolve26(rootDir, ".opencode.json"), parser: "json" },
+    { host: "opencode", path: resolve26(homeDir, ".config/opencode/opencode.json"), parser: "json" }
   ];
 }
 function parseJsonMcpFile(path, host) {
   try {
-    const raw = JSON.parse(readFileSync18(path, "utf-8"));
+    const raw = JSON.parse(readFileSync19(path, "utf-8"));
     const servers = extractJsonMcpServers(raw, path, host);
     return Object.entries(servers).flatMap(([serverName, config]) => {
       const normalized = normalizeCommonMcpServer(config, host);
@@ -22752,7 +23199,7 @@ function extractJsonMcpServers(raw, path, host) {
   return {};
 }
 function parseCodexTomlMcpFile(path) {
-  const text = readFileSync18(path, "utf-8");
+  const text = readFileSync19(path, "utf-8");
   const servers = {};
   let currentServer;
   let currentSubtable;
@@ -23125,7 +23572,7 @@ function isHelpRequested(input) {
 }
 function getCliPackageVersion() {
   const packageJsonPath = new URL("../../package.json", import.meta.url);
-  const raw = JSON.parse(readFileSync19(packageJsonPath, "utf-8"));
+  const raw = JSON.parse(readFileSync20(packageJsonPath, "utf-8"));
   if (typeof raw.version !== "string" || raw.version.trim() === "") {
     throw new Error("Unable to determine the installed pluxx version from package.json.");
   }
@@ -23303,7 +23750,7 @@ async function maybeInstallBuiltOutputs(config, platforms, options = {}) {
   return {
     enabled: true,
     platforms,
-    notes: getInstallFollowupNotes(platforms),
+    notes: getInstallFollowupNotes2(platforms),
     installTargets: installPlan.map((target) => ({
       platform: target.platform,
       pluginDir: target.description,
@@ -23796,7 +24243,7 @@ async function planInitContextArtifactFiles(rootDir, contextPack) {
   return plannedFiles;
 }
 async function planAuxiliaryFile(rootDir, relativePath, content) {
-  const filePath = resolve26(rootDir, relativePath);
+  const filePath = resolve27(rootDir, relativePath);
   const action = await planTextFileAction(filePath, content);
   return {
     relativePath,
@@ -23981,7 +24428,7 @@ ${mcpBlock}${brandBlock}
   targets: [${targetsList}],
 })
 `;
-    await writeTextFile(resolve26(process.cwd(), "pluxx.config.ts"), template);
+    await writeTextFile(resolve27(process.cwd(), "pluxx.config.ts"), template);
     const skillDir = `skills/${skillName}`;
     await mkdir4(skillDir, { recursive: true });
     const skillContent = `---
@@ -24003,7 +24450,7 @@ Describe how agents should use this skill.
 Example prompt or command here
 \`\`\`
 `;
-    await writeTextFile(resolve26(process.cwd(), `${skillDir}/SKILL.md`), skillContent);
+    await writeTextFile(resolve27(process.cwd(), `${skillDir}/SKILL.md`), skillContent);
     console.log("");
     console.log("  Created:");
     console.log("    pluxx.config.ts");
@@ -24249,7 +24696,7 @@ ${formatAuthRequiredMessage("init", retryError, source)}`);
     if (!runtime.dryRun) {
       await applyMcpScaffoldPlan(process.cwd(), plan);
       for (const file of contextArtifactFiles) {
-        await writeTextFile(resolve26(process.cwd(), file.relativePath), file.content);
+        await writeTextFile(resolve27(process.cwd(), file.relativePath), file.content);
       }
     }
     const lintResult = runtime.dryRun ? { errors: 0, warnings: 0, issues: [] } : await lintProject(process.cwd());
@@ -24417,7 +24864,7 @@ async function runSync() {
 async function runDoctor() {
   const consumerMode = readFlag(args, "--consumer");
   const doctorPath = args.slice(1).find((value) => !value.startsWith("-"));
-  const rootDir = doctorPath ? resolve26(process.cwd(), doctorPath) : process.cwd();
+  const rootDir = doctorPath ? resolve27(process.cwd(), doctorPath) : process.cwd();
   const report = consumerMode ? await doctorConsumer(rootDir) : await doctorProject(rootDir);
   if (runtime.jsonOutput) {
     printJson(report);
@@ -24918,7 +25365,7 @@ ${formatAuthRequiredMessage("autopilot", retryError, source)}`);
         install: installRequested ? {
           enabled: true,
           platforms: installTargets,
-          notes: getInstallFollowupNotes(installTargets),
+          notes: getInstallFollowupNotes2(installTargets),
           installTargets: []
         } : void 0,
         steps: totalSteps,
@@ -25312,7 +25759,7 @@ async function runInstall() {
       dryRun: true,
       pluginName: config.name,
       platforms,
-      notes: getInstallFollowupNotes(platforms),
+      notes: getInstallFollowupNotes2(platforms),
       trustRequired: hookCommands.length > 0,
       userConfig: plannedUserConfig.map((entry) => ({
         key: entry.field.key,
@@ -25346,7 +25793,7 @@ async function runInstall() {
       if (listHookCommands(config.hooks).length > 0) {
         console.log("  trust reminder: this plugin defines local hook commands; install requires review or --trust");
       }
-      for (const note of getInstallFollowupNotes(platforms)) {
+      for (const note of getInstallFollowupNotes2(platforms)) {
         console.log(`  note: ${note}`);
       }
     }
@@ -25425,7 +25872,7 @@ async function runVerifyInstall() {
   const targets = parseTargetFlagValues(args);
   const config = await loadConfig();
   if (runtime.dryRun) {
-    const distDir = resolve26(process.cwd(), config.outDir);
+    const distDir = resolve27(process.cwd(), config.outDir);
     const plan = planInstallPlugin(distDir, config.name, targets ?? config.targets);
     const summary = {
       dryRun: true,