@orchid-labs/pluxx 0.1.14 → 0.1.15

package/dist/cli/index.js

@@ -5055,6 +5055,262 @@ function parsePluginRootReference(value) {
   };
 }
 
+// src/user-config.ts
+var ENV_VAR_NAME = /^[A-Za-z_][A-Za-z0-9_]*$/;
+var PLACEHOLDER_SECRET_PATTERNS = [
+  /\bdummy\b/i,
+  /\bplaceholder\b/i,
+  /\bexample\b/i,
+  /\bchangeme\b/i,
+  /\breplace[_ -]?me\b/i,
+  /\byour[_ -]?(api[_ -]?)?key\b/i,
+  /\bapi[_ -]?key[_ -]?here\b/i,
+  /\btoken[_ -]?here\b/i
+];
+function normalizeUserConfigKey(value) {
+  return value.replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1-$2").replace(/[._/\s]+/g, "-").toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "");
+}
+function humanizeUserConfigLabel(value) {
+  return value.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").replace(/[._/]+/g, " ").replace(/-/g, " ").split(/\s+/).filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1).toLowerCase()).join(" ");
+}
+function defaultUserConfigEnvVar(key) {
+  return key.replace(/[^A-Za-z0-9]+/g, "_").replace(/_+/g, "_").replace(/^_+|_+$/g, "").toUpperCase();
+}
+function extractEnvReference(value) {
+  if (!value) return void 0;
+  const match = value.match(/^\$\{([A-Za-z_][A-Za-z0-9_]*)\}$/);
+  return match?.[1];
+}
+function isPlaceholderSecretValue(value) {
+  if (typeof value !== "string") return false;
+  const normalized = value.trim();
+  if (normalized === "") return false;
+  return PLACEHOLDER_SECRET_PATTERNS.some((pattern) => pattern.test(normalized));
+}
+function isRuntimePlatformManaged(config, target, server) {
+  if (server.transport === "stdio") return false;
+  if (server.auth?.type === "platform") {
+    return true;
+  }
+  if (target === "claude-code") {
+    return config.platforms?.["claude-code"]?.mcpAuth === "platform";
+  }
+  if (target === "cursor") {
+    return config.platforms?.cursor?.mcpAuth === "platform";
+  }
+  return false;
+}
+function targetApplies(entry, target) {
+  return !entry.targets || entry.targets.includes(target);
+}
+function dedupeUserConfigEntries(entries) {
+  const deduped = [];
+  const seenKeys = /* @__PURE__ */ new Set();
+  const seenEnvVars = /* @__PURE__ */ new Set();
+  for (const entry of entries) {
+    const envVar = entry.envVar?.trim();
+    if (seenKeys.has(entry.key)) continue;
+    if (envVar && seenEnvVars.has(envVar)) continue;
+    deduped.push(entry);
+    seenKeys.add(entry.key);
+    if (envVar) seenEnvVars.add(envVar);
+  }
+  return deduped;
+}
+function collectUserConfigEntries(config, platforms = config.targets) {
+  const explicitEntries = (config.userConfig ?? []).filter((entry) => !entry.targets || entry.targets.some((target) => platforms.includes(target))).map((entry) => ({ ...entry, source: "explicit" }));
+  const derivedEntries = [];
+  for (const [serverName, server] of Object.entries(config.mcp ?? {})) {
+    const applicableTargets = platforms.filter((target) => !isRuntimePlatformManaged(config, target, server));
+    if (server.auth?.type && server.auth.type !== "none" && server.auth.type !== "platform" && ENV_VAR_NAME.test(server.auth.envVar) && applicableTargets.length > 0) {
+      derivedEntries.push({
+        key: normalizeUserConfigKey(server.auth.envVar),
+        title: humanizeUserConfigLabel(server.auth.envVar),
+        description: `Authentication credential for the ${serverName} MCP server.`,
+        type: "secret",
+        required: true,
+        envVar: server.auth.envVar,
+        targets: applicableTargets,
+        source: "mcp-auth"
+      });
+    }
+    if (server.transport === "stdio") {
+      for (const [key, rawValue] of Object.entries(server.env ?? {})) {
+        const envVar = extractEnvReference(rawValue) ?? (ENV_VAR_NAME.test(key) ? key : void 0);
+        if (!envVar || !ENV_VAR_NAME.test(envVar)) continue;
+        if (extractEnvReference(rawValue) === void 0 && rawValue !== "") {
+          continue;
+        }
+        derivedEntries.push({
+          key: normalizeUserConfigKey(envVar),
+          title: humanizeUserConfigLabel(envVar),
+          description: `Environment value required to launch the ${serverName} stdio MCP server.`,
+          type: "secret",
+          required: true,
+          envVar,
+          targets: applicableTargets.length > 0 ? applicableTargets : platforms,
+          source: "mcp-env"
+        });
+      }
+    }
+  }
+  return dedupeUserConfigEntries([
+    ...explicitEntries,
+    ...derivedEntries
+  ]);
+}
+function resolveUserConfigEntriesForTarget(entries, target) {
+  return entries.filter(({ field }) => targetApplies(field, target));
+}
+function buildUserConfigEnvMap(entries) {
+  const env = {};
+  for (const entry of entries) {
+    if (!entry.envVar) continue;
+    env[entry.envVar] = String(entry.value);
+  }
+  return env;
+}
+function buildUserConfigValueMap(entries) {
+  const values = {};
+  for (const entry of entries) {
+    values[entry.field.key] = entry.value;
+  }
+  return values;
+}
+
+// src/mcp-native-overrides.ts
+function asRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  return value;
+}
+function cloneRecord(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+function firstString(...values) {
+  for (const value of values) {
+    if (typeof value === "string" && value.trim()) return value.trim();
+  }
+  return void 0;
+}
+function readStringRecord(value) {
+  const record = asRecord(value);
+  if (!record) return void 0;
+  const stringRecord = Object.fromEntries(
+    Object.entries(record).filter(([, entryValue]) => typeof entryValue === "string")
+  );
+  return Object.keys(stringRecord).length > 0 ? stringRecord : void 0;
+}
+function extractNativeMcpAuthConfig(cfg) {
+  const preserved = {};
+  const auth = asRecord(cfg.auth);
+  if (auth) preserved.auth = cloneRecord(auth);
+  const bearerTokenEnv = firstString(cfg.bearer_token_env_var, cfg.bearerTokenEnvVar);
+  if (typeof cfg.bearer_token_env_var === "string") {
+    preserved.bearer_token_env_var = cfg.bearer_token_env_var;
+  } else if (typeof cfg.bearerTokenEnvVar === "string" && bearerTokenEnv) {
+    preserved.bearerTokenEnvVar = bearerTokenEnv;
+  }
+  for (const key of ["env_http_headers", "envHttpHeaders", "headers", "http_headers", "httpHeaders"]) {
+    const value = asRecord(cfg[key]);
+    if (value) {
+      preserved[key] = cloneRecord(value);
+    }
+  }
+  return Object.keys(preserved).length > 0 ? preserved : void 0;
+}
+function buildNativeMcpPlatformOverrides(platform, servers) {
+  const preservedServers = {};
+  for (const [serverName, rawConfig] of Object.entries(servers)) {
+    const cfg = asRecord(rawConfig);
+    if (!cfg) continue;
+    const nativeAuth = extractNativeMcpAuthConfig(cfg);
+    if (!nativeAuth) continue;
+    preservedServers[serverName] = nativeAuth;
+  }
+  if (Object.keys(preservedServers).length === 0) return void 0;
+  return {
+    [platform]: {
+      mcpServers: preservedServers
+    }
+  };
+}
+function extractEnvVar(value) {
+  const match = value.match(/\$\{(?:env:)?([A-Za-z_][A-Za-z0-9_]*)\}|\$([A-Za-z_][A-Za-z0-9_]*)/);
+  return match?.[1] ?? match?.[2];
+}
+function envVarToKey(envVar) {
+  return envVar.toLowerCase().replace(/_/g, "-");
+}
+function getNativeMcpServerOverride(config, platform, serverName) {
+  const platformConfig = asRecord(config.platforms?.[platform]);
+  const mcpServers = asRecord(platformConfig?.mcpServers);
+  const serverOverride = asRecord(mcpServers?.[serverName]);
+  return serverOverride ? cloneRecord(serverOverride) : void 0;
+}
+function getNativeJsonHeadersOverride(config, platform, serverName) {
+  const override = getNativeMcpServerOverride(config, platform, serverName);
+  return readStringRecord(override?.headers);
+}
+function getNativeCodexMcpEntryOverride(config, serverName) {
+  const override = getNativeMcpServerOverride(config, "codex", serverName);
+  if (!override) return void 0;
+  const entry = {};
+  const bearerTokenEnv = firstString(override.bearer_token_env_var, override.bearerTokenEnvVar);
+  if (bearerTokenEnv) entry.bearer_token_env_var = bearerTokenEnv;
+  const envHttpHeaders = readStringRecord(override.env_http_headers ?? override.envHttpHeaders);
+  if (envHttpHeaders) entry.env_http_headers = envHttpHeaders;
+  const httpHeaders = readStringRecord(override.http_headers ?? override.httpHeaders);
+  if (httpHeaders) entry.http_headers = httpHeaders;
+  const auth = asRecord(override.auth);
+  if (auth) entry.auth = cloneRecord(auth);
+  return Object.keys(entry).length > 0 ? entry : void 0;
+}
+function collectNativeMcpAuthUserConfigEntries(config, platforms, existingFields) {
+  const next = [];
+  const seenKeys = new Set(existingFields.map((field) => field.key));
+  const seenEnvVars = new Set(
+    existingFields.map((field) => field.envVar ?? defaultUserConfigEnvVar(field.key))
+  );
+  const pushDerived = (envVar, platform, serverName) => {
+    if (!envVar || seenEnvVars.has(envVar)) return;
+    const key = envVarToKey(envVar);
+    if (seenKeys.has(key)) return;
+    seenEnvVars.add(envVar);
+    seenKeys.add(key);
+    next.push({
+      key,
+      title: envVar,
+      description: `Derived from native ${platform} MCP auth for ${serverName}.`,
+      type: "secret",
+      required: true,
+      envVar,
+      targets: [platform]
+    });
+  };
+  for (const platform of platforms) {
+    const platformConfig = asRecord(config.platforms?.[platform]);
+    const mcpServers = asRecord(platformConfig?.mcpServers);
+    if (!mcpServers) continue;
+    for (const [serverName, rawOverride] of Object.entries(mcpServers)) {
+      const override = asRecord(rawOverride);
+      if (!override) continue;
+      const bearerTokenEnv = firstString(override.bearer_token_env_var, override.bearerTokenEnvVar);
+      if (bearerTokenEnv) pushDerived(bearerTokenEnv, platform, serverName);
+      for (const record of [
+        readStringRecord(override.env_http_headers ?? override.envHttpHeaders),
+        readStringRecord(override.headers),
+        readStringRecord(override.http_headers ?? override.httpHeaders)
+      ]) {
+        for (const value of Object.values(record ?? {})) {
+          const envVar = extractEnvVar(value) ?? value;
+          pushDerived(envVar, platform, serverName);
+        }
+      }
+    }
+  }
+  return next;
+}
+
 // src/generators/base.ts
 var Generator = class {
   constructor(config, rootDir) {
@@ -5162,6 +5418,10 @@ var Generator = class {
           entry.headers = headers;
         }
       }
+      const nativeHeaders = getNativeJsonHeadersOverride(this.config, this.platform, name);
+      if (nativeHeaders && this.getMcpAuthMode() !== "platform" && remoteServer.auth?.type !== "platform") {
+        entry.headers = nativeHeaders;
+      }
       if (transformRemoteEntry) {
         entry = transformRemoteEntry({ name, server: remoteServer, entry });
       }
@@ -5211,9 +5471,40 @@ var Generator = class {
 // src/generators/shared/claude-family.ts
 import { resolve as resolve7 } from "path";
 
+// src/hook-events.ts
+var CURSOR_SUPPORTED_HOOK_EVENTS = [
+  "sessionStart",
+  "sessionEnd",
+  "preToolUse",
+  "postToolUse",
+  "postToolUseFailure",
+  "subagentStart",
+  "subagentStop",
+  "beforeShellExecution",
+  "afterShellExecution",
+  "beforeMCPExecution",
+  "afterMCPExecution",
+  "beforeReadFile",
+  "afterFileEdit",
+  "beforeSubmitPrompt",
+  "preCompact",
+  "stop",
+  "afterAgentResponse",
+  "afterAgentThought",
+  "beforeTabFileRead",
+  "afterTabFileEdit"
+];
+var PASCAL_CASE_HOOK_ALIASES = {
+  beforeSubmitPrompt: "UserPromptSubmit"
+};
+function mapHookEventToPascalCase(event) {
+  return PASCAL_CASE_HOOK_ALIASES[event] ?? event.charAt(0).toUpperCase() + event.slice(1);
+}
+
 // src/hook-translation-registry.ts
 var HOOK_PLATFORM_REGISTRY = {
   "claude-code": {
+    supportedTypes: ["command", "http", "mcp_tool", "prompt", "agent"],
     fields: {
       prompt: {
         mode: "preserve",
@@ -5237,6 +5528,9 @@ var HOOK_PLATFORM_REGISTRY = {
     }
   },
   cursor: {
+    supportedTypes: ["command", "prompt"],
+    supportedEvents: CURSOR_SUPPORTED_HOOK_EVENTS,
+    unsupportedEventReason: `Cursor currently documents only ${CURSOR_SUPPORTED_HOOK_EVENTS.join(", ")} for hook configuration.`,
     fields: {
       prompt: { mode: "preserve" },
       matcher: { mode: "preserve" },
@@ -5245,6 +5539,7 @@ var HOOK_PLATFORM_REGISTRY = {
     }
   },
   codex: {
+    supportedTypes: ["command"],
     supportedEvents: ["SessionStart", "PreToolUse", "PermissionRequest", "PostToolUse", "UserPromptSubmit", "Stop"],
     unsupportedEventReason: "Codex currently documents only SessionStart, PreToolUse, PermissionRequest, PostToolUse, UserPromptSubmit, and Stop for hook configuration.",
     fields: {
@@ -5255,6 +5550,7 @@ var HOOK_PLATFORM_REGISTRY = {
     }
   },
   opencode: {
+    supportedTypes: ["command"],
     fields: {
       prompt: { mode: "drop" },
       matcher: { mode: "preserve" },
@@ -5322,6 +5618,9 @@ var HOOK_PLATFORM_REGISTRY = {
 function getSupportedHookEvents(platform) {
   return HOOK_PLATFORM_REGISTRY[platform]?.supportedEvents ?? [];
 }
+function getSupportedHookTypes(platform) {
+  return HOOK_PLATFORM_REGISTRY[platform]?.supportedTypes ?? [];
+}
 function getUnsupportedHookEventReason(platform) {
   return HOOK_PLATFORM_REGISTRY[platform]?.unsupportedEventReason ?? null;
 }
@@ -5330,6 +5629,11 @@ function isHookEventSupported(platform, event) {
   if (supportedEvents.length === 0) return true;
   return supportedEvents.includes(event);
 }
+function isHookTypeSupported(platform, type) {
+  const supportedTypes = getSupportedHookTypes(platform);
+  if (supportedTypes.length === 0) return true;
+  return supportedTypes.includes(type);
+}
 function getHookFieldCapability(platform, field) {
   return HOOK_PLATFORM_REGISTRY[platform]?.fields[field] ?? { mode: "drop" };
 }
@@ -5345,6 +5649,77 @@ function isHookFieldPreserved(platform, field, event) {
 function getHookFieldSupportedEvents(platform, field) {
   return getHookFieldCapability(platform, field).supportedEvents ?? [];
 }
+function getHookTypeTranslationIssue(platform, type) {
+  if (platform === "cursor") {
+    return {
+      code: "cursor-hook-type-unsupported",
+      message: `Cursor does not document hook type "${type}". Pluxx currently preserves only command and prompt hooks on the Cursor hook surface.`
+    };
+  }
+  if (platform === "codex") {
+    return {
+      code: "codex-hook-type-drop",
+      message: `Codex currently bundles only command-hook entries from Pluxx. ${type} hooks will be dropped from the generated Codex bundle.`
+    };
+  }
+  if (platform === "opencode") {
+    return {
+      code: "opencode-hook-type-drop",
+      message: `The current OpenCode runtime wrapper only emits command hooks. ${type} hooks will be dropped from the generated OpenCode plugin.`
+    };
+  }
+  return null;
+}
+function getPromptHookTranslationIssue(platform, event) {
+  if (platform === "claude-code") {
+    if (event && isHookFieldPreserved(platform, "prompt", event)) return null;
+    const supportedEvents = getHookFieldSupportedEvents(platform, "prompt");
+    return {
+      code: "claude-prompt-hook-degrade",
+      message: `Claude currently preserves prompt hooks only on ${supportedEvents.join(", ")}. Prompt hooks on ${event ?? "other events"} will be dropped from generated Claude output.`
+    };
+  }
+  if (platform === "codex") {
+    return {
+      code: "codex-prompt-hook-drop",
+      message: "Codex currently receives only command-hook entries from Pluxx. Prompt hooks will be dropped from the generated Codex bundle."
+    };
+  }
+  if (platform === "opencode") {
+    return {
+      code: "opencode-prompt-hook-drop",
+      message: "The current OpenCode runtime wrapper only emits command hooks. Prompt hooks will be dropped from the generated OpenCode plugin."
+    };
+  }
+  return null;
+}
+function getHookFieldTranslationIssue(platform, field) {
+  if (platform === "claude-code" && field === "failClosed") {
+    return {
+      code: "claude-hook-failclosed-degrade",
+      message: "Claude hook entries currently drop `failClosed` in generated output. Keep this behavior host-specific or verify the generated hook bundle carefully."
+    };
+  }
+  if (platform === "claude-code" && field === "loop_limit") {
+    return {
+      code: "claude-hook-loop-limit-degrade",
+      message: "Claude outputs currently drop `loop_limit`. Recursive hook protection is not preserved there today."
+    };
+  }
+  if (platform === "codex" && field === "loop_limit") {
+    return {
+      code: "codex-hook-loop-limit-drop",
+      message: "Codex hook companions currently drop `loop_limit`. Only command, matcher, timeout, and failClosed survive there today."
+    };
+  }
+  if (platform === "opencode" && field === "loop_limit") {
+    return {
+      code: "opencode-hook-loop-limit-drop",
+      message: "OpenCode runtime hooks currently drop `loop_limit`. Recursive hook protection is still Cursor-first in Pluxx."
+    };
+  }
+  return null;
+}
 
 // src/generators/hooks-warning.ts
 function warnDroppedHookFields(platform, event, entries) {
@@ -5374,36 +5749,6 @@ function warnDroppedHookFields(platform, event, entries) {
   }
 }
 
-// src/hook-events.ts
-var CURSOR_SUPPORTED_HOOK_EVENTS = [
-  "sessionStart",
-  "sessionEnd",
-  "preToolUse",
-  "postToolUse",
-  "postToolUseFailure",
-  "subagentStart",
-  "subagentStop",
-  "beforeShellExecution",
-  "afterShellExecution",
-  "beforeMCPExecution",
-  "afterMCPExecution",
-  "beforeReadFile",
-  "afterFileEdit",
-  "beforeSubmitPrompt",
-  "preCompact",
-  "stop",
-  "afterAgentResponse",
-  "afterAgentThought",
-  "beforeTabFileRead",
-  "afterTabFileEdit"
-];
-var PASCAL_CASE_HOOK_ALIASES = {
-  beforeSubmitPrompt: "UserPromptSubmit"
-};
-function mapHookEventToPascalCase(event) {
-  return PASCAL_CASE_HOOK_ALIASES[event] ?? event.charAt(0).toUpperCase() + event.slice(1);
-}
-
 // src/readiness.ts
 function getRuntimeReadinessPlan(readiness) {
   if (!readiness || readiness.dependencies.length === 0 && readiness.gates.length === 0) {
@@ -6144,7 +6489,10 @@ async function writeMcpConfig(config, platform, writeJson) {
         mcpServers[name] = entry;
         continue;
       }
-      if (server.auth?.type === "bearer" && server.auth.envVar) {
+      const nativeHeaders = getNativeJsonHeadersOverride(config, platform, name);
+      if (nativeHeaders) {
+        entry.headers = nativeHeaders;
+      } else if (server.auth?.type === "bearer" && server.auth.envVar) {
         entry.headers = {
           Authorization: `Bearer \${${server.auth.envVar}}`
         };
@@ -6338,7 +6686,7 @@ function defaultMapEventName(event) {
 }
 
 // src/generators/claude-code/index.ts
-import { existsSync as existsSync8, mkdirSync as mkdirSync2, readFileSync as readFileSync5, readdirSync as readdirSync3, writeFileSync } from "fs";
+import { existsSync as existsSync9, mkdirSync as mkdirSync2, readFileSync as readFileSync6, readdirSync as readdirSync4, writeFileSync } from "fs";
 import { basename as basename2, join as join2 } from "path";
 
 // src/delegation.ts
@@ -6380,10 +6728,204 @@ function asMap2(value) {
   return value;
 }
 
-// src/skills.ts
+// src/commands.ts
 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 && (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'"))) {
+    return { value: trimmed.slice(1, -1), quoted: true };
+  }
+  return { value: trimmed, quoted: false };
+}
+function firstHeading2(content) {
+  const lines = content.split(/\r?\n/);
+  for (const line of lines) {
+    const match = line.match(/^#\s+(.*)$/);
+    if (match?.[1]?.trim()) return match[1].trim();
+  }
+  return void 0;
+}
+function splitMarkdownFrontmatter2(content) {
+  const lines = content.split(/\r?\n/);
+  if (lines[0]?.trim() !== "---") {
+    return {
+      frontmatterLines: [],
+      body: content
+    };
+  }
+  let endIndex = -1;
+  for (let i = 1; i < lines.length; i += 1) {
+    if (lines[i].trim() === "---") {
+      endIndex = i;
+      break;
+    }
+  }
+  if (endIndex === -1) {
+    return {
+      frontmatterLines: [],
+      body: content
+    };
+  }
+  return {
+    frontmatterLines: lines.slice(1, endIndex),
+    body: lines.slice(endIndex + 1).join("\n")
+  };
+}
+function stripYamlScalar(value) {
+  return unquote(value).value.trim();
+}
+function parseFrontmatterFields(frontmatterLines) {
+  const fields = /* @__PURE__ */ new Map();
+  for (const line of frontmatterLines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const match = /^([A-Za-z0-9_-]+)\s*:\s*(.*)$/.exec(trimmed);
+    if (!match) continue;
+    const key = match[1];
+    const rawValue = match[2];
+    const parsed = unquote(rawValue);
+    fields.set(key, {
+      key,
+      value: parsed.value,
+      rawValue: rawValue.trim(),
+      quoted: parsed.quoted
+    });
+  }
+  return fields;
+}
+function parseCommandFrontmatterDescription(frontmatterLines) {
+  for (const line of frontmatterLines) {
+    const match = /^description:\s*(.+)\s*$/i.exec(line.trim());
+    if (match?.[1]) {
+      return stripYamlScalar(match[1]);
+    }
+  }
+  return void 0;
+}
+function parseCommandFrontmatterString(frontmatterFields, key) {
+  return frontmatterFields.get(key)?.value;
+}
+function parseCommandFrontmatterBoolean(frontmatterFields, key) {
+  const value = parseCommandFrontmatterString(frontmatterFields, key);
+  if (!value) return void 0;
+  if (/^true$/i.test(value)) return true;
+  if (/^false$/i.test(value)) 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) => stripYamlScalar(part)).map((part) => part.trim()).filter(Boolean);
+}
+function parseCommandFrontmatterStringArray(frontmatterLines, frontmatterFields, key) {
+  const rawValue = frontmatterFields.get(key)?.rawValue;
+  if (rawValue) {
+    const inlineArray = parseInlineStringArray(rawValue);
+    if (inlineArray.length > 0) return inlineArray;
+    if (rawValue.trim()) return [stripYamlScalar(rawValue)];
+  }
+  const lineIndex = frontmatterLines.findIndex((line) => new RegExp(`^${key}:\\s*$`, "i").test(line.trim()));
+  if (lineIndex === -1) return [];
+  const values = [];
+  for (let index = lineIndex + 1; index < frontmatterLines.length; index += 1) {
+    const itemMatch = /^\s*-\s+(.+)$/.exec(frontmatterLines[index]);
+    if (!itemMatch?.[1]) break;
+    const value = stripYamlScalar(itemMatch[1]).trim();
+    if (value) values.push(value);
+  }
+  return values;
+}
+function inferCommandSkillLinks(body) {
+  const skills = /* @__PURE__ */ new Set();
+  for (const match of body.matchAll(/Use the `([^`]+)` skill\./g)) {
+    const skill = match[1]?.trim();
+    if (skill) skills.add(skill);
+  }
+  return [...skills];
+}
+function walkMarkdownFiles2(dir) {
+  const entries = readdirSync2(dir);
+  const files = [];
+  for (const entry of entries) {
+    const fullPath = resolve8(dir, entry);
+    const stat = statSync2(fullPath);
+    if (stat.isDirectory()) {
+      files.push(...walkMarkdownFiles2(fullPath));
+      continue;
+    }
+    if (stat.isFile() && entry.endsWith(".md")) {
+      files.push(fullPath);
+    }
+  }
+  return files;
+}
+function readCanonicalCommandFiles(commandsDir) {
+  if (!commandsDir || !existsSync7(commandsDir)) return [];
+  return walkMarkdownFiles2(commandsDir).sort((a, b) => a.localeCompare(b)).map((filePath) => {
+    const content = readFileSync4(filePath, "utf-8");
+    const { frontmatterLines, body } = splitMarkdownFrontmatter2(content);
+    const frontmatterFields = parseFrontmatterFields(frontmatterLines);
+    const relativeStem = relative2(commandsDir, filePath).replace(/\\/g, "/").replace(/\.md$/i, "");
+    const commandId = relativeStem.replace(/\//g, "-").toLowerCase();
+    const title = parseCommandFrontmatterString(frontmatterFields, "title") ?? firstHeading2(body) ?? commandId;
+    const skills = [
+      .../* @__PURE__ */ new Set([
+        ...parseCommandFrontmatterStringArray(frontmatterLines, frontmatterFields, "skills"),
+        ...(() => {
+          const skill = parseCommandFrontmatterString(frontmatterFields, "skill");
+          return skill ? [skill] : [];
+        })(),
+        ...inferCommandSkillLinks(body)
+      ])
+    ];
+    return {
+      filePath,
+      relativeStem,
+      commandId,
+      frontmatterLines,
+      frontmatterFields,
+      title,
+      description: parseCommandFrontmatterDescription(frontmatterLines),
+      whenToUse: parseCommandFrontmatterString(frontmatterFields, "when_to_use"),
+      argumentHint: parseCommandFrontmatterString(frontmatterFields, "argument-hint"),
+      arguments: parseCommandFrontmatterStringArray(frontmatterLines, frontmatterFields, "arguments"),
+      examples: parseCommandFrontmatterStringArray(frontmatterLines, frontmatterFields, "examples"),
+      ...skills[0] ? { skill: skills[0] } : {},
+      skills,
+      agent: parseCommandFrontmatterString(frontmatterFields, "agent"),
+      subtask: parseCommandFrontmatterBoolean(frontmatterFields, "subtask"),
+      model: parseCommandFrontmatterString(frontmatterFields, "model"),
+      context: parseCommandFrontmatterString(frontmatterFields, "context"),
+      body: body.trim()
+    };
+  });
+}
+function getCanonicalCommandMetadata(command2) {
+  return {
+    commandId: command2.commandId,
+    title: command2.title,
+    ...command2.description ? { description: command2.description } : {},
+    ...command2.whenToUse ? { whenToUse: command2.whenToUse } : {},
+    ...command2.argumentHint ? { argumentHint: command2.argumentHint } : {},
+    ...command2.arguments.length > 0 ? { arguments: [...command2.arguments] } : { arguments: [] },
+    ...command2.examples.length > 0 ? { examples: [...command2.examples] } : { examples: [] },
+    ...command2.skill ? { skill: command2.skill } : {},
+    skills: [...command2.skills],
+    ...command2.agent ? { agent: command2.agent } : {},
+    ...typeof command2.subtask === "boolean" ? { subtask: command2.subtask } : {},
+    ...command2.model ? { model: command2.model } : {},
+    ...command2.context ? { context: command2.context } : {},
+    template: command2.body
+  };
+}
+
+// src/skills.ts
+import { existsSync as existsSync8, readdirSync as readdirSync3, readFileSync as readFileSync5, statSync as statSync3 } from "fs";
+import { relative as relative3, resolve as resolve9 } from "path";
+function unquote2(value) {
   const trimmed = value.trim();
   if (trimmed.length >= 2) {
     if (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'")) {
@@ -6392,14 +6934,14 @@ function unquote(value) {
   }
   return { value: trimmed, quoted: false };
 }
-function firstHeading2(content) {
+function firstHeading3(content) {
   for (const line of content.split(/\r?\n/)) {
     const match = /^#\s+(.+)$/.exec(line.trim());
     if (match?.[1]?.trim()) return match[1].trim();
   }
   return void 0;
 }
-function splitMarkdownFrontmatter2(content) {
+function splitMarkdownFrontmatter3(content) {
   const lines = content.split(/\r?\n/);
   if (lines[0]?.trim() !== "---") {
     return {
@@ -6428,7 +6970,7 @@ function splitMarkdownFrontmatter2(content) {
     body: lines.slice(endIndex + 1).join("\n")
   };
 }
-function parseFrontmatterFields(frontmatterLines) {
+function parseFrontmatterFields2(frontmatterLines) {
   const fields = /* @__PURE__ */ new Map();
   for (const line of frontmatterLines) {
     const trimmed = line.trim();
@@ -6437,7 +6979,7 @@ function parseFrontmatterFields(frontmatterLines) {
     if (!match) continue;
     const key = match[1];
     const rawValue = match[2];
-    const parsed = unquote(rawValue);
+    const parsed = unquote2(rawValue);
     fields.set(key, {
       key,
       value: parsed.value,
@@ -6453,7 +6995,7 @@ function parseAllowedTools(hasValidFrontmatter, frontmatterLines, frontmatterFie
   const inlineValue = inlineField?.rawValue.trim() ?? "";
   if (inlineValue) {
     const raw = inlineValue.startsWith("[") && inlineValue.endsWith("]") ? inlineValue.slice(1, -1) : inlineValue;
-    return raw.split(",").map((part) => unquote(part).value).map((part) => part.trim()).filter(Boolean);
+    return raw.split(",").map((part) => unquote2(part).value).map((part) => part.trim()).filter(Boolean);
   }
   const lineIndex = frontmatterLines.findIndex((line) => /^allowed-tools:\s*$/i.test(line.trim()));
   if (lineIndex === -1) return [];
@@ -6461,7 +7003,7 @@ function parseAllowedTools(hasValidFrontmatter, frontmatterLines, frontmatterFie
   for (let index = lineIndex + 1; index < frontmatterLines.length; index += 1) {
     const itemMatch = /^\s*-\s+(.+)$/.exec(frontmatterLines[index]);
     if (!itemMatch?.[1]) break;
-    const value = unquote(itemMatch[1]).value.trim();
+    const value = unquote2(itemMatch[1]).value.trim();
     if (value) tools.push(value);
   }
   return tools;
@@ -6472,17 +7014,17 @@ function parseBooleanField(frontmatterFields, key) {
   if (value === "false") return false;
   return void 0;
 }
-function parseInlineStringArray(rawValue) {
+function parseInlineStringArray2(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);
+  return inner.split(",").map((part) => unquote2(part).value.trim()).filter(Boolean);
 }
 function parseStringArrayField(frontmatterFields, key) {
   const rawValue = frontmatterFields.get(key)?.rawValue;
   if (!rawValue) return [];
-  return parseInlineStringArray(rawValue);
+  return parseInlineStringArray2(rawValue);
 }
 function parseJsonField(frontmatterFields, key) {
   const rawValue = frontmatterFields.get(key)?.rawValue?.trim();
@@ -6499,8 +7041,8 @@ function parseSkillMarkdown(content) {
     hasValidFrontmatter,
     frontmatterLines,
     body
-  } = splitMarkdownFrontmatter2(content);
-  const frontmatterFields = parseFrontmatterFields(frontmatterLines);
+  } = splitMarkdownFrontmatter3(content);
+  const frontmatterFields = parseFrontmatterFields2(frontmatterLines);
   return {
     hasValidFrontmatter,
     frontmatterLines,
@@ -6521,16 +7063,16 @@ function parseSkillMarkdown(content) {
     hooks: parseJsonField(frontmatterFields, "hooks"),
     paths: parseStringArrayField(frontmatterFields, "paths"),
     shell: frontmatterFields.get("shell")?.value,
-    firstHeading: firstHeading2(body)
+    firstHeading: firstHeading3(body)
   };
 }
 function walkSkillFiles(skillsDir) {
-  if (!skillsDir || !existsSync7(skillsDir)) return [];
-  const entries = readdirSync2(skillsDir);
+  if (!skillsDir || !existsSync8(skillsDir)) return [];
+  const entries = readdirSync3(skillsDir);
   const files = [];
   for (const entry of entries) {
-    const fullPath = resolve8(skillsDir, entry);
-    const stat = statSync2(fullPath);
+    const fullPath = resolve9(skillsDir, entry);
+    const stat = statSync3(fullPath);
     if (stat.isDirectory()) {
       files.push(...walkSkillFiles(fullPath));
       continue;
@@ -6542,12 +7084,12 @@ function walkSkillFiles(skillsDir) {
   return files;
 }
 function readSkillMarkdownFile(filePath) {
-  return parseSkillMarkdown(readFileSync4(filePath, "utf-8"));
+  return parseSkillMarkdown(readFileSync5(filePath, "utf-8"));
 }
 function readCanonicalSkillFiles(skillsDir) {
-  if (!skillsDir || !existsSync7(skillsDir)) return [];
+  if (!skillsDir || !existsSync8(skillsDir)) return [];
   return walkSkillFiles(skillsDir).sort((a, b) => a.localeCompare(b)).map((filePath) => {
-    const relativeDir = relative2(skillsDir, filePath).replace(/\\/g, "/").replace(/\/SKILL\.md$/i, "");
+    const relativeDir = relative3(skillsDir, filePath).replace(/\\/g, "/").replace(/\/SKILL\.md$/i, "");
     return {
       filePath,
       relativeDir,
@@ -6560,6 +7102,48 @@ function serializeSkillMarkdown(frontmatterLines, body) {
   return ["---", ...frontmatterLines, "---", body ? `
 ${body.replace(/^\n/, "")}` : ""].join("\n");
 }
+function walkSupportFiles(dir) {
+  const entries = readdirSync3(dir, { withFileTypes: true });
+  const files = [];
+  for (const entry of entries) {
+    const fullPath = resolve9(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...walkSupportFiles(fullPath));
+      continue;
+    }
+    if (entry.isFile()) {
+      files.push(fullPath);
+    }
+  }
+  return files;
+}
+function getCanonicalSkillMetadata(skill) {
+  const skillDir = resolve9(skill.filePath, "..");
+  const supportPaths = walkSupportFiles(skillDir).filter((fullPath) => fullPath !== skill.filePath).map((fullPath) => relative3(skillDir, fullPath).replace(/\\/g, "/")).sort((a, b) => a.localeCompare(b));
+  return {
+    dirName: skill.dirName,
+    title: skill.firstHeading ?? skill.name ?? skill.dirName,
+    ...skill.description ? { description: skill.description } : {},
+    ...skill.whenToUse ? { whenToUse: skill.whenToUse } : {},
+    ...skill.argumentHint ? { argumentHint: skill.argumentHint } : {},
+    arguments: [...skill.arguments],
+    ...typeof skill.disableModelInvocation === "boolean" ? { disableModelInvocation: skill.disableModelInvocation } : {},
+    ...typeof skill.userInvocable === "boolean" ? { userInvocable: skill.userInvocable } : {},
+    allowedTools: [...skill.allowedTools],
+    ...skill.model ? { model: skill.model } : {},
+    ...skill.effort ? { effort: skill.effort } : {},
+    ...skill.context ? { context: skill.context } : {},
+    ...skill.agent ? { agent: skill.agent } : {},
+    ...skill.hooks !== void 0 ? { hooks: skill.hooks } : {},
+    paths: [...skill.paths],
+    ...skill.shell ? { shell: skill.shell } : {},
+    body: skill.body,
+    supportPaths,
+    helperScripts: supportPaths.filter((path) => path.startsWith("scripts/")),
+    examplePaths: supportPaths.filter((path) => path.startsWith("examples/")),
+    referencePaths: supportPaths.filter((path) => !path.startsWith("examples/") && !path.startsWith("scripts/"))
+  };
+}
 
 // src/generators/claude-code/index.ts
 var ClaudeCodeGenerator = class extends Generator {
@@ -6592,8 +7176,8 @@ var ClaudeCodeGenerator = class extends Generator {
     const wrappedSkills = this.collectCommandWrappedSkills();
     for (const skill of collidingSkills) {
       const outputPath = join2(this.outDir, "skills", skill.dirName, "SKILL.md");
-      if (!existsSync8(outputPath)) continue;
-      const current = readFileSync5(outputPath, "utf-8");
+      if (!existsSync9(outputPath)) continue;
+      const current = readFileSync6(outputPath, "utf-8");
       const hiddenName = buildHiddenSkillName(skill.effectiveName);
       const rewritten = rewriteClaudeSkillVisibility(current, {
         nameOverride: hiddenName,
@@ -6606,8 +7190,8 @@ var ClaudeCodeGenerator = class extends Generator {
     for (const skill of wrappedSkills) {
       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 = readFileSync5(outputPath, "utf-8");
+      if (!existsSync9(outputPath)) continue;
+      const current = readFileSync6(outputPath, "utf-8");
       const rewritten = rewriteClaudeSkillVisibility(current, {
         userInvocable: false
       });
@@ -6682,7 +7266,7 @@ ${bodyParts.join("\n").trim()}
     if (!this.config.commands) return [];
     const commandsSrc = this.resolveConfigPath(this.config.commands, "commands");
     const skillsSrc = this.resolveConfigPath(this.config.skills, "skills");
-    if (!existsSync8(commandsSrc) || !existsSync8(skillsSrc)) return [];
+    if (!existsSync9(commandsSrc) || !existsSync9(skillsSrc)) return [];
     const commandNames = collectTopLevelCommandNames(commandsSrc);
     const collidingSkills = [];
     for (const skill of readCanonicalSkillFiles(skillsSrc)) {
@@ -6697,7 +7281,7 @@ ${bodyParts.join("\n").trim()}
     if (!this.config.commands) return [];
     const commandsSrc = this.resolveConfigPath(this.config.commands, "commands");
     const skillsSrc = this.resolveConfigPath(this.config.skills, "skills");
-    if (!existsSync8(commandsSrc) || !existsSync8(skillsSrc)) return [];
+    if (!existsSync9(commandsSrc) || !existsSync9(skillsSrc)) return [];
     const referencedSkills = collectWrappedSkillNames(commandsSrc);
     if (referencedSkills.size === 0) return [];
     const wrappedSkills = [];
@@ -6712,7 +7296,7 @@ ${bodyParts.join("\n").trim()}
 };
 function collectTopLevelCommandNames(commandsRoot) {
   const commandNames = /* @__PURE__ */ new Set();
-  for (const entry of readdirSync3(commandsRoot, { withFileTypes: true })) {
+  for (const entry of readdirSync4(commandsRoot, { withFileTypes: true })) {
     if (entry.isFile() && entry.name.toLowerCase().endsWith(".md")) {
       commandNames.add(basename2(entry.name, ".md"));
     }
@@ -6721,11 +7305,9 @@ function collectTopLevelCommandNames(commandsRoot) {
 }
 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 = readFileSync5(join2(commandsRoot, entry.name), "utf-8");
-    for (const match of content.matchAll(/Use the `([^`]+)` skill\./g)) {
-      const skillName = match[1]?.trim();
+  for (const command2 of readCanonicalCommandFiles(commandsRoot)) {
+    const metadata = getCanonicalCommandMetadata(command2);
+    for (const skillName of metadata.skills) {
       if (skillName) wrappedSkills.add(skillName);
     }
   }
@@ -6811,6 +7393,70 @@ function asMap3(value) {
   return value;
 }
 
+// src/agent-translation-registry.ts
+var HAS_BOOLEAN = (value) => typeof value === "boolean";
+var AGENT_TRANSLATION_PROFILES = {
+  cursor: {
+    degradedFields: [
+      { key: "mode", present: (metadata) => !!metadata.mode },
+      { key: "hidden", present: (metadata) => metadata.hidden },
+      { key: "model_reasoning_effort", present: (metadata) => !!metadata.modelReasoningEffort },
+      { key: "sandbox_mode", present: (metadata) => !!metadata.sandboxMode },
+      { key: "temperature", present: (metadata) => typeof metadata.temperature === "number" },
+      { key: "steps", present: (metadata) => typeof metadata.steps === "number" },
+      { key: "disable", present: (metadata) => HAS_BOOLEAN(metadata.disabled) },
+      { key: "color", present: (metadata) => !!metadata.color },
+      { key: "topP", present: (metadata) => typeof metadata.topP === "number" },
+      { key: "skills", present: (metadata) => !!metadata.skills },
+      { key: "memory", present: (metadata) => !!metadata.memory },
+      { key: "background", present: (metadata) => HAS_BOOLEAN(metadata.background) },
+      { key: "isolation", present: (metadata) => !!metadata.isolation },
+      { key: "permission", present: (metadata) => !!metadata.permission },
+      { key: "tools", present: (metadata) => metadata.tools !== void 0 }
+    ],
+    guidanceSurfaces: ["subagent framing", "generated notes"],
+    message: (fields) => `Agent fields ${fields.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.`
+  },
+  codex: {
+    degradedFields: [
+      { key: "mode", present: (metadata) => !!metadata.mode },
+      { key: "hidden", present: (metadata) => metadata.hidden },
+      { key: "temperature", present: (metadata) => typeof metadata.temperature === "number" },
+      { key: "steps", present: (metadata) => typeof metadata.steps === "number" },
+      { key: "disable", present: (metadata) => HAS_BOOLEAN(metadata.disabled) },
+      { key: "color", present: (metadata) => !!metadata.color },
+      { key: "topP", present: (metadata) => typeof metadata.topP === "number" },
+      { key: "skills", present: (metadata) => !!metadata.skills },
+      { key: "memory", present: (metadata) => !!metadata.memory },
+      { key: "background", present: (metadata) => HAS_BOOLEAN(metadata.background) },
+      { key: "isolation", present: (metadata) => !!metadata.isolation },
+      { key: "permission", present: (metadata) => !!metadata.permission },
+      { key: "tools", present: (metadata) => metadata.tools !== void 0 }
+    ],
+    guidanceSurfaces: ["developer instructions", "generated companion surfaces"],
+    message: (fields) => `Agent fields ${fields.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.`
+  },
+  opencode: {
+    degradedFields: [
+      { key: "model_reasoning_effort", present: (metadata) => !!metadata.modelReasoningEffort },
+      { key: "sandbox_mode", present: (metadata) => !!metadata.sandboxMode },
+      { key: "skills", present: (metadata) => !!metadata.skills },
+      { key: "memory", present: (metadata) => !!metadata.memory },
+      { key: "background", present: (metadata) => HAS_BOOLEAN(metadata.background) },
+      { key: "isolation", present: (metadata) => !!metadata.isolation }
+    ],
+    guidanceSurfaces: ["agent config notes", "runtime/developer guidance"],
+    message: (fields) => `Agent fields ${fields.map((field) => `"${field}"`).join(", ")} are not native OpenCode agent config fields today. Pluxx keeps the specialist behavior, but translates that intent through agent config notes and surrounding runtime guidance instead.`
+  }
+};
+function getTranslatedAgentFields(platform, metadata) {
+  return AGENT_TRANSLATION_PROFILES[platform].degradedFields.filter((field) => field.present(metadata)).map((field) => field.key);
+}
+function getAgentTranslationMessage(platform, fields) {
+  if (fields.length === 0) return null;
+  return AGENT_TRANSLATION_PROFILES[platform].message(fields);
+}
+
 // src/generators/cursor/index.ts
 var CursorGenerator = class extends Generator {
   platform = "cursor";
@@ -6901,6 +7547,12 @@ var CursorGenerator = class extends Generator {
     }
     for (const [event, entries] of Object.entries(this.config.hooks)) {
       if (!entries) continue;
+      if (!isHookEventSupported("cursor", event)) {
+        console.warn(
+          `[pluxx] cursor generator dropped unsupported hook event "${event}". ${getUnsupportedHookEventReason("cursor") ?? `Supported: ${getSupportedHookEvents("cursor").join(", ")}`}`
+        );
+        continue;
+      }
       const filteredEntries = entries.filter((entry) => {
         if (usesPlatformManagedAuth && entry.type !== "prompt" && entry.command?.includes("check-env.sh")) {
           return false;
@@ -6990,7 +7642,7 @@ var CursorGenerator = class extends Generator {
         frontmatter.push(`model: ${JSON.stringify(metadata.model)}`);
       }
       frontmatter.push("---");
-      const translatedNotes = buildCursorAgentTranslationNotes(agent.frontmatter);
+      const translatedNotes = buildCursorAgentTranslationNotes(agent.frontmatter, metadata);
       const bodyParts = [
         ...translatedNotes,
         agent.body
@@ -7005,8 +7657,12 @@ ${bodyParts.join("\n\n").trim()}
     }
   }
 };
-function buildCursorAgentTranslationNotes(frontmatter) {
-  return buildDelegationBehaviorNotes(frontmatter).map(
+function buildCursorAgentTranslationNotes(frontmatter, metadata) {
+  const notes = [
+    getAgentTranslationMessage("cursor", getTranslatedAgentFields("cursor", metadata)),
+    ...buildDelegationBehaviorNotes(frontmatter)
+  ].filter((note) => Boolean(note));
+  return notes.map(
     (note) => `Cursor translation note: ${note.charAt(0).toLowerCase()}${note.slice(1)}`
   );
 }
@@ -7014,125 +7670,57 @@ function buildCursorAgentTranslationNotes(frontmatter) {
 // src/generators/codex/index.ts
 import { relative as relative4 } from "path";
 
-// src/commands.ts
-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) {
-    const match = line.match(/^#\s+(.*)$/);
-    if (match?.[1]?.trim()) return match[1].trim();
-  }
-  return void 0;
-}
-function splitMarkdownFrontmatter3(content) {
-  const lines = content.split(/\r?\n/);
-  if (lines[0]?.trim() !== "---") {
-    return {
-      frontmatterLines: [],
-      body: content
-    };
-  }
-  let endIndex = -1;
-  for (let i = 1; i < lines.length; i += 1) {
-    if (lines[i].trim() === "---") {
-      endIndex = i;
-      break;
-    }
-  }
-  if (endIndex === -1) {
-    return {
-      frontmatterLines: [],
-      body: content
-    };
-  }
-  return {
-    frontmatterLines: lines.slice(1, endIndex),
-    body: lines.slice(endIndex + 1).join("\n")
-  };
+// src/command-translation-registry.ts
+var CODEX_COMMAND_FIELD_DESCRIPTORS = [
+  { label: "when_to_use", present: (metadata) => Boolean(metadata.whenToUse) },
+  { label: "argument-hint", present: (metadata) => Boolean(metadata.argumentHint) },
+  { label: "arguments", present: (metadata) => metadata.arguments.length > 0 },
+  { label: "examples", present: (metadata) => metadata.examples.length > 0 },
+  { label: "skill", present: (metadata) => Boolean(metadata.skill) },
+  { label: "skills", present: (metadata) => metadata.skills.length > 0 },
+  { label: "agent", present: (metadata) => Boolean(metadata.agent) },
+  { label: "subtask", present: (metadata) => typeof metadata.subtask === "boolean" },
+  { label: "model", present: (metadata) => Boolean(metadata.model) },
+  { label: "context", present: (metadata) => Boolean(metadata.context) }
+];
+function getCodexCommandGuidanceNote() {
+  return "Codex does not currently document plugin-packaged slash-command parity. Pluxx keeps canonical command intent through AGENTS.md routing guidance and `.codex/commands.generated.json`.";
 }
-function stripYamlScalar(value) {
-  const trimmed = value.trim();
-  if (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'")) {
-    return trimmed.slice(1, -1).trim();
-  }
-  return trimmed;
+function getTranslatedCommandFields(platform, metadata) {
+  if (platform !== "codex") return [];
+  return CODEX_COMMAND_FIELD_DESCRIPTORS.filter((descriptor) => descriptor.present(metadata)).map((descriptor) => descriptor.label);
 }
-function parseCommandFrontmatterDescription(frontmatterLines) {
-  for (const line of frontmatterLines) {
-    const match = /^description:\s*(.+)\s*$/i.exec(line.trim());
-    if (match?.[1]) {
-      return stripYamlScalar(match[1]);
-    }
+function getCommandTranslationMessage(platform, degradedFields) {
+  if (degradedFields.length === 0) return void 0;
+  if (platform === "codex") {
+    return `Command fields ${degradedFields.map((field) => `"${field}"`).join(", ")} are not native Codex plugin slash-command fields today. ${getCodexCommandGuidanceNote()}`;
   }
   return void 0;
 }
-function parseCommandFrontmatterString(frontmatterLines, key) {
-  const pattern = new RegExp(`^${key}:\\s*(.+)\\s*$`, "i");
-  for (const line of frontmatterLines) {
-    const match = pattern.exec(line.trim());
-    if (match?.[1]) {
-      return stripYamlScalar(match[1]);
-    }
+function buildCodexCommandRoutingEntry(metadata) {
+  const distinctSkills = metadata.skills.filter((skillId, index, skills) => skills.indexOf(skillId) === index);
+  const hasOnlyPrimarySkill = distinctSkills.length === 1 && distinctSkills[0] === metadata.skill;
+  const routingBits = [
+    metadata.argumentHint ? `arguments: ${metadata.argumentHint}` : null,
+    metadata.skill ? `skill: ${metadata.skill}` : null,
+    distinctSkills.length > 0 && !hasOnlyPrimarySkill ? `skills: ${distinctSkills.join(", ")}` : null,
+    metadata.agent ? `agent: ${metadata.agent}` : null,
+    typeof metadata.subtask === "boolean" ? `subtask: ${metadata.subtask ? "yes" : "no"}` : null,
+    metadata.model ? `model: ${metadata.model}` : null
+  ].filter(Boolean);
+  const lines = [
+    `- \`/${metadata.commandId}\` - ${metadata.description ?? metadata.title}${routingBits.length > 0 ? ` (${routingBits.join("; ")})` : ""}`
+  ];
+  if (metadata.whenToUse) {
+    lines.push(`  - When to use: ${metadata.whenToUse}`);
   }
-  return void 0;
-}
-function parseCommandFrontmatterBoolean(frontmatterLines, key) {
-  const value = parseCommandFrontmatterString(frontmatterLines, key);
-  if (!value) return void 0;
-  if (/^true$/i.test(value)) return true;
-  if (/^false$/i.test(value)) return false;
-  return void 0;
-}
-function walkMarkdownFiles2(dir) {
-  const entries = readdirSync4(dir);
-  const files = [];
-  for (const entry of entries) {
-    const fullPath = resolve9(dir, entry);
-    const stat = statSync3(fullPath);
-    if (stat.isDirectory()) {
-      files.push(...walkMarkdownFiles2(fullPath));
-      continue;
-    }
-    if (stat.isFile() && entry.endsWith(".md")) {
-      files.push(fullPath);
-    }
+  if (metadata.examples.length > 0) {
+    lines.push(`  - Examples: ${metadata.examples.map((example) => `\`${example}\``).join(", ")}`);
   }
-  return files;
-}
-function readCanonicalCommandFiles(commandsDir) {
-  if (!commandsDir || !existsSync9(commandsDir)) return [];
-  return walkMarkdownFiles2(commandsDir).sort((a, b) => a.localeCompare(b)).map((filePath) => {
-    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();
-    const title = firstHeading3(body) ?? commandId;
-    return {
-      filePath,
-      relativeStem,
-      commandId,
-      title,
-      description: parseCommandFrontmatterDescription(frontmatterLines),
-      argumentHint: parseCommandFrontmatterString(frontmatterLines, "argument-hint"),
-      agent: parseCommandFrontmatterString(frontmatterLines, "agent"),
-      subtask: parseCommandFrontmatterBoolean(frontmatterLines, "subtask"),
-      model: parseCommandFrontmatterString(frontmatterLines, "model"),
-      body: body.trim()
-    };
-  });
-}
-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
-  };
+  if (metadata.context) {
+    lines.push(`  - Context hint: ${metadata.context}`);
+  }
+  return lines;
 }
 
 // src/generators/codex/index.ts
@@ -7148,7 +7736,10 @@ var CodexGenerator = class extends Generator {
           const entry = {
             url: server.url
           };
-          if (server.auth?.type === "bearer" && server.auth.envVar) {
+          const nativeOverride = getNativeCodexMcpEntryOverride(this.config, name);
+          if (nativeOverride) {
+            Object.assign(entry, nativeOverride);
+          } else if (server.auth?.type === "bearer" && server.auth.envVar) {
             entry.bearer_token_env_var = server.auth.envVar;
           } else if (server.auth?.type === "header" && server.auth.envVar) {
             const isBearerAuthorizationHeader = server.auth.headerName === "Authorization" && server.auth.headerTemplate === "Bearer ${value}";
@@ -7176,6 +7767,7 @@ var CodexGenerator = class extends Generator {
       this.generateHooksCompanion(),
       this.generateReadinessCompanion(),
       this.generateCommandsCompanion(),
+      this.generateSkillsCompanion(),
       this.generatePermissionsCompanion()
     ]);
     this.copySkills();
@@ -7293,7 +7885,13 @@ var CodexGenerator = class extends Generator {
         lines.push(`sandbox_mode = ${JSON.stringify(metadata.sandboxMode)}`);
       }
       const delegationNotes = buildDelegationBehaviorNotes(agent.frontmatter);
+      const fieldTranslationNote = getAgentTranslationMessage("codex", getTranslatedAgentFields("codex", metadata));
       const developerInstructions = [
+        ...fieldTranslationNote ? [
+          "Host translation note:",
+          `- ${fieldTranslationNote}`,
+          ""
+        ] : [],
         ...delegationNotes.length > 0 ? [
           "Delegation contract:",
           ...delegationNotes.map((note) => `- ${note}`),
@@ -7334,7 +7932,18 @@ var CodexGenerator = class extends Generator {
       const codexEvent = mapHookEventToPascalCase(event);
       const mappedEntries = [];
       for (const entry of entries) {
-        if (entry.type === "prompt" || !entry.command) continue;
+        const entryType = entry.type ?? "command";
+        if (!isHookTypeSupported("codex", entryType)) {
+          const issue = entryType === "command" ? null : getHookTypeTranslationIssue("codex", entryType);
+          unsupported.push({
+            canonicalEvent: event,
+            codexEvent,
+            type: entryType,
+            reason: issue?.message ?? `Codex currently bundles only command-hook entries from Pluxx. ${entryType} hooks will be dropped from the generated Codex bundle.`
+          });
+          continue;
+        }
+        if (!entry.command) continue;
         nextWrapperIndex += 1;
         const relativePath = `hooks/pluxx-hook-command-${nextWrapperIndex}.sh`;
         await this.writeFile(
@@ -7407,22 +8016,62 @@ var CodexGenerator = class extends Generator {
     await this.writeJson(".codex/commands.generated.json", {
       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.",
+      note: `${getCodexCommandGuidanceNote()} Use these canonical command entries as workflow routing guidance alongside AGENTS.md.`,
       commands: commands.map((command2) => {
         const metadata = getCanonicalCommandMetadata(command2);
         return {
           id: metadata.commandId,
           title: metadata.title,
           ...metadata.description ? { description: metadata.description } : {},
+          ...metadata.whenToUse ? { whenToUse: metadata.whenToUse } : {},
           ...metadata.argumentHint ? { argumentHint: metadata.argumentHint } : {},
+          ...metadata.arguments.length > 0 ? { arguments: metadata.arguments } : {},
+          ...metadata.examples.length > 0 ? { examples: metadata.examples } : {},
+          ...metadata.skill ? { skill: metadata.skill } : {},
+          ...metadata.skills.length > 0 ? { skills: metadata.skills } : {},
           ...metadata.agent ? { agent: metadata.agent } : {},
           ...typeof metadata.subtask === "boolean" ? { subtask: metadata.subtask } : {},
           ...metadata.model ? { model: metadata.model } : {},
+          ...metadata.context ? { context: metadata.context } : {},
           template: metadata.template
         };
       })
     });
   }
+  async generateSkillsCompanion() {
+    if (!this.config.skills) return;
+    const skillsDir = this.resolveConfigPath(this.config.skills, "skills");
+    const skills = readCanonicalSkillFiles(skillsDir);
+    if (skills.length === 0) return;
+    await this.writeJson(".codex/skills.generated.json", {
+      model: "pluxx.skills.v1",
+      nativeSurface: "compatibility-skill-files-plus-guidance",
+      note: "Codex preserves canonical SKILL.md files, but richer discovery and support-file metadata may also need command or AGENTS.md guidance. Use this companion to keep that richer canonical metadata visible after translation.",
+      skills: skills.map((skill) => {
+        const metadata = getCanonicalSkillMetadata(skill);
+        return {
+          id: metadata.dirName,
+          title: metadata.title,
+          ...metadata.description ? { description: metadata.description } : {},
+          ...metadata.whenToUse ? { whenToUse: metadata.whenToUse } : {},
+          ...metadata.argumentHint ? { argumentHint: metadata.argumentHint } : {},
+          ...metadata.arguments.length > 0 ? { arguments: metadata.arguments } : {},
+          ...typeof metadata.disableModelInvocation === "boolean" ? { disableModelInvocation: metadata.disableModelInvocation } : {},
+          ...typeof metadata.userInvocable === "boolean" ? { userInvocable: metadata.userInvocable } : {},
+          ...metadata.allowedTools.length > 0 ? { allowedTools: metadata.allowedTools } : {},
+          ...metadata.model ? { model: metadata.model } : {},
+          ...metadata.effort ? { effort: metadata.effort } : {},
+          ...metadata.context ? { context: metadata.context } : {},
+          ...metadata.agent ? { agent: metadata.agent } : {},
+          ...metadata.paths.length > 0 ? { paths: metadata.paths } : {},
+          ...metadata.shell ? { shell: metadata.shell } : {},
+          ...metadata.helperScripts.length > 0 ? { helperScripts: metadata.helperScripts } : {},
+          ...metadata.examplePaths.length > 0 ? { examplePaths: metadata.examplePaths } : {},
+          ...metadata.referencePaths.length > 0 ? { referencePaths: metadata.referencePaths } : {}
+        };
+      })
+    });
+  }
   buildCodexCommandRoutingSection() {
     if (!this.config.commands) return null;
     const commandsDir = this.resolveConfigPath(this.config.commands, "commands");
@@ -7433,10 +8082,7 @@ 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) => {
-        const metadata = getCanonicalCommandMetadata(command2);
-        return `- \`/${metadata.commandId}\` - ${metadata.description ?? metadata.title}${metadata.argumentHint ? ` (arguments: ${metadata.argumentHint})` : ""}`;
-      })
+      ...commands.flatMap((command2) => buildCodexCommandRoutingEntry(getCanonicalCommandMetadata(command2)))
     ];
     return lines.join("\n");
   }
@@ -7451,7 +8097,8 @@ var OpenCodeGenerator = class extends Generator {
     await Promise.all([
       this.generatePackageJson(),
       this.generatePluginWrapper(),
-      this.generateReadinessRuntime()
+      this.generateReadinessRuntime(),
+      this.generateSkillsCompanion()
     ]);
     this.copySkills();
     this.copyCommands();
@@ -7769,6 +8416,40 @@ var OpenCodeGenerator = class extends Generator {
     lines.push("");
     await this.writeFile("index.ts", lines.join("\n"));
   }
+  async generateSkillsCompanion() {
+    if (!this.config.skills) return;
+    const skillsDir = this.resolveConfigPath(this.config.skills, "skills");
+    const skills = readCanonicalSkillFiles(skillsDir);
+    if (skills.length === 0) return;
+    await this.writeJson("skills.generated.json", {
+      model: "pluxx.skills.v1",
+      nativeSurface: "skill-files-plus-runtime-guidance",
+      note: "OpenCode preserves canonical skill files, but richer discovery, helper-script, and support-file metadata may still need command, agent, or runtime guidance. This companion keeps that richer canonical metadata visible after translation.",
+      skills: skills.map((skill) => {
+        const metadata = getCanonicalSkillMetadata(skill);
+        return {
+          id: metadata.dirName,
+          title: metadata.title,
+          ...metadata.description ? { description: metadata.description } : {},
+          ...metadata.whenToUse ? { whenToUse: metadata.whenToUse } : {},
+          ...metadata.argumentHint ? { argumentHint: metadata.argumentHint } : {},
+          ...metadata.arguments.length > 0 ? { arguments: metadata.arguments } : {},
+          ...typeof metadata.disableModelInvocation === "boolean" ? { disableModelInvocation: metadata.disableModelInvocation } : {},
+          ...typeof metadata.userInvocable === "boolean" ? { userInvocable: metadata.userInvocable } : {},
+          ...metadata.allowedTools.length > 0 ? { allowedTools: metadata.allowedTools } : {},
+          ...metadata.model ? { model: metadata.model } : {},
+          ...metadata.effort ? { effort: metadata.effort } : {},
+          ...metadata.context ? { context: metadata.context } : {},
+          ...metadata.agent ? { agent: metadata.agent } : {},
+          ...metadata.paths.length > 0 ? { paths: metadata.paths } : {},
+          ...metadata.shell ? { shell: metadata.shell } : {},
+          ...metadata.helperScripts.length > 0 ? { helperScripts: metadata.helperScripts } : {},
+          ...metadata.examplePaths.length > 0 ? { examplePaths: metadata.examplePaths } : {},
+          ...metadata.referencePaths.length > 0 ? { referencePaths: metadata.referencePaths } : {}
+        };
+      })
+    });
+  }
   async generateReadinessRuntime() {
     if (!this.config.readiness) return;
     await this.writeFile("runtime/pluxx-readiness.mjs", buildGeneratedReadinessScript(this.config.readiness));
@@ -7810,10 +8491,16 @@ var OpenCodeGenerator = class extends Generator {
       output[metadata.commandId] = {
         template: metadata.template,
         ...metadata.description ? { description: metadata.description } : {},
+        ...metadata.whenToUse ? { whenToUse: metadata.whenToUse } : {},
         ...metadata.argumentHint ? { argumentHint: metadata.argumentHint } : {},
+        ...metadata.arguments.length > 0 ? { arguments: metadata.arguments } : {},
+        ...metadata.examples.length > 0 ? { examples: metadata.examples } : {},
+        ...metadata.skill ? { skill: metadata.skill } : {},
+        ...metadata.skills.length > 0 ? { skills: metadata.skills } : {},
         ...metadata.agent ? { agent: metadata.agent } : {},
         ...typeof metadata.subtask === "boolean" ? { subtask: metadata.subtask } : {},
-        ...metadata.model ? { model: metadata.model } : {}
+        ...metadata.model ? { model: metadata.model } : {},
+        ...metadata.context ? { context: metadata.context } : {}
       };
     }
     return output;
@@ -9132,8 +9819,8 @@ var CORE_FOUR_PRIMITIVE_CAPABILITIES = {
       },
       commands: {
         mode: "degrade",
-        nativeSurfaces: ["skills/", "AGENTS.md"],
-        notes: "Current Codex docs do not document plugin-packaged slash-command parity."
+        nativeSurfaces: ["skills/", "AGENTS.md", ".codex/commands.generated.json"],
+        notes: "Current Codex docs do not document plugin-packaged slash-command parity, so Pluxx keeps canonical command intent through routing guidance plus a generated companion mirror."
       },
       agents: {
         mode: "translate",
@@ -9293,7 +9980,7 @@ function renderPrimitiveTranslationSummary(summary) {
 }
 
 // src/branding-completeness.ts
-function asRecord(value) {
+function asRecord2(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) return null;
   return value;
 }
@@ -9305,7 +9992,7 @@ function hasNonEmptyStringArray(value) {
 }
 function getBrandingCompletenessWarnings(config) {
   const warnings = [];
-  const codexInterface = asRecord(config.platforms?.codex?.interface);
+  const codexInterface = asRecord2(config.platforms?.codex?.interface);
   if (config.targets.includes("codex")) {
     const codexHasIcon = hasNonEmptyString(config.brand?.icon) || hasNonEmptyString(codexInterface?.composerIcon) || hasNonEmptyString(codexInterface?.logo);
     const codexHasScreenshots = hasNonEmptyStringArray(config.brand?.screenshots) || hasNonEmptyStringArray(codexInterface?.screenshots);
@@ -9347,6 +10034,54 @@ function getBrandingCompletenessWarnings(config) {
   return warnings;
 }
 
+// src/skill-translation-registry.ts
+var CODEX_SKILL_FIELD_TRANSLATIONS = {
+  when_to_use: "Pluxx currently keeps `when_to_use` as compatibility metadata in Codex skill files and may also surface the same discovery hint through command or routing guidance, because Codex does not document an equivalent skill discovery field.",
+  "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.",
+  "user-invocable": "Pluxx currently keeps `user-invocable` as compatibility metadata in Codex skill files because Codex does not document an equivalent skill visibility field.",
+  "allowed-tools": "Pluxx currently translates `allowed-tools` into Codex permission companions or external config rather than documented Codex skill frontmatter.",
+  model: "Pluxx currently translates skill `model` intent through Codex custom agents, routing guidance, or model overrides rather than documented Codex skill frontmatter.",
+  effort: "Pluxx currently translates skill `effort` intent through Codex custom-agent model reasoning controls or surrounding model guidance 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."
+};
+var OPENCODE_SKILL_FIELD_TRANSLATIONS = {
+  when_to_use: "Pluxx currently keeps `when_to_use` as compatibility metadata in OpenCode skill files and may also surface the same discovery hint through commands or neighboring runtime guidance, because OpenCode does not document an equivalent skill discovery field.",
+  "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.",
+  "user-invocable": "Pluxx currently keeps `user-invocable` as compatibility metadata in OpenCode skill files because OpenCode does not document an equivalent skill visibility field.",
+  "allowed-tools": "Pluxx currently translates `allowed-tools` into OpenCode permission config rather than documented OpenCode skill frontmatter.",
+  model: "Pluxx currently translates skill `model` intent through OpenCode agent/config model selection rather than documented OpenCode skill frontmatter.",
+  effort: "Pluxx currently translates skill `effort` intent through OpenCode model configuration or agent/runtime controls 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."
+};
+function getSkillFrontmatterTranslationIssue(platform, key, supportedFields) {
+  if (platform === "cursor") {
+    return {
+      code: "cursor-skill-frontmatter-unsupported",
+      message: `Skill frontmatter field "${key}" is not supported by Cursor. Supported: ${supportedFields.join(", ")}`
+    };
+  }
+  if (platform === "codex") {
+    return {
+      code: "codex-skill-frontmatter-translation",
+      message: CODEX_SKILL_FIELD_TRANSLATIONS[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.`
+    };
+  }
+  return {
+    code: "opencode-skill-frontmatter-translation",
+    message: OPENCODE_SKILL_FIELD_TRANSLATIONS[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.`
+  };
+}
+
 // src/runtime-script-contract.ts
 var INSTALLER_OWNED_CHECK_ENV_PATH = "scripts/check-env.sh";
 var RUNTIME_SCRIPT_ROLE_PATHS = {
@@ -9493,7 +10228,7 @@ function isCodexManifestRelativePath(path) {
   if (relativePath.includes("..")) return false;
   return !relativePath.startsWith("/") && !relativePath.startsWith("\\");
 }
-function asRecord2(value) {
+function asRecord3(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) return null;
   return value;
 }
@@ -9660,7 +10395,7 @@ function lintBrandMetadata(config, issues) {
 }
 function lintCodexOverrides(config, issues) {
   if (!isCodexTargetEnabled(config)) return;
-  const iface = asRecord2(config.platforms?.codex?.interface);
+  const iface = asRecord3(config.platforms?.codex?.interface);
   if (!iface) return;
   if (typeof iface.brandColor === "string" && !HEX_COLOR_REGEX.test(iface.brandColor)) {
     pushIssue(issues, {
@@ -10202,45 +10937,44 @@ function lintAgentTranslationExplainability(dir, config, issues) {
     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) {
+      const cursorDegradedFields = getTranslatedAgentFields("cursor", metadata);
+      const message = getAgentTranslationMessage("cursor", cursorDegradedFields);
+      if (message) {
         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.`,
+          message,
           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) {
+      const codexDegradedFields = getTranslatedAgentFields("codex", metadata);
+      const message = getAgentTranslationMessage("codex", codexDegradedFields);
+      if (message) {
         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.`,
+          message,
           file: relativePath,
           platform: "Codex"
         });
       }
     }
+    if (config.targets.includes("opencode")) {
+      const opencodeDegradedFields = getTranslatedAgentFields("opencode", metadata);
+      const message = getAgentTranslationMessage("opencode", opencodeDegradedFields);
+      if (message) {
+        pushIssue(issues, {
+          level: "warning",
+          code: "opencode-agent-translation",
+          message,
+          file: relativePath,
+          platform: "OpenCode"
+        });
+      }
+    }
   }
 }
 function lintCommandTranslationExplainability(dir, config, issues) {
@@ -10250,15 +10984,13 @@ function lintCommandTranslationExplainability(dir, config, issues) {
     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) {
+      const degradedFields = getTranslatedCommandFields("codex", metadata);
+      const message = getCommandTranslationMessage("codex", degradedFields);
+      if (degradedFields.length > 0 && message) {
         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\`.`,
+          message,
           file: relativePath,
           platform: "Codex"
         });
@@ -10340,9 +11072,9 @@ function lintLegacyCommandsDir(dir, config, issues) {
 }
 function lintCodexAgentsConfig(config, issues) {
   if (!isCodexTargetEnabled(config)) return;
-  const codexOverrides = asRecord2(config.platforms?.codex);
+  const codexOverrides = asRecord3(config.platforms?.codex);
   if (!codexOverrides) return;
-  const agents = asRecord2(codexOverrides.agents);
+  const agents = asRecord3(codexOverrides.agents);
   if (!agents) return;
   if (typeof agents.max_threads === "number" && agents.max_threads < CODEX_RULES.agents.maxThreadsMin) {
     pushIssue(issues, {
@@ -10366,8 +11098,8 @@ function lintCodexAgentsConfig(config, issues) {
 function lintCodexHooksExternalConfig(config, issues) {
   if (!isCodexTargetEnabled(config) || !config.hooks) return;
   if (Object.keys(config.hooks).length === 0) return;
-  const codexOverrides = asRecord2(config.platforms?.codex);
-  const features = codexOverrides ? asRecord2(codexOverrides.features) : null;
+  const codexOverrides = asRecord3(config.platforms?.codex);
+  const features = codexOverrides ? asRecord3(codexOverrides.features) : null;
   const hasPluxxCodexHooksFlag = features && features.codex_hooks === true;
   if (hasPluxxCodexHooksFlag) return;
   pushIssue(issues, {
@@ -10423,12 +11155,14 @@ function lintRuntimeReadiness(config, issues) {
 }
 function lintCursorHooks(config, issues) {
   if (!config.targets.includes("cursor") || !config.hooks) return;
+  const supportedCursorEvents = getSupportedHookEvents("cursor");
+  const unsupportedCursorEventReason = getUnsupportedHookEventReason("cursor");
   for (const [hookEvent, hookEntries] of Object.entries(config.hooks)) {
-    if (!CURSOR_SUPPORTED_HOOK_EVENTS.includes(hookEvent)) {
+    if (!isHookEventSupported("cursor", hookEvent)) {
       pushIssue(issues, {
         level: "warning",
         code: "cursor-hook-event-unknown",
-        message: `Cursor does not support hook event "${hookEvent}". Supported: ${CURSOR_SUPPORTED_HOOK_EVENTS.join(", ")}`,
+        message: unsupportedCursorEventReason ? `Cursor does not support hook event "${hookEvent}". ${unsupportedCursorEventReason}` : `Cursor does not support hook event "${hookEvent}". Supported: ${supportedCursorEvents.join(", ")}`,
         file: "pluxx.config.ts",
         platform: "Cursor"
       });
@@ -10437,11 +11171,12 @@ 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") {
+      if (typeof rec.type === "string" && !isHookTypeSupported("cursor", rec.type)) {
+        const issue = getHookTypeTranslationIssue("cursor", rec.type);
         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.`,
+          code: issue?.code ?? "cursor-hook-type-unsupported",
+          message: issue?.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"
         });
@@ -10473,50 +11208,16 @@ function lintCursorSkillFrontmatter(config, skillFiles, issues, frontmatterCache
     for (const [key] of parsed.frontmatterFields) {
       for (const [target, supported] of supportedByTarget.entries()) {
         if (supported.has(key)) continue;
-        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"
-          };
-        }
+        const issue = getSkillFrontmatterTranslationIssue(
+          target,
+          key,
+          [...supported]
+        );
         pushIssue(issues, {
           level: "warning",
           file: skillFile,
-          ...issue
+          ...issue,
+          platform: target === "cursor" ? "Cursor" : target === "codex" ? "Codex" : "OpenCode"
         });
       }
     }
@@ -10535,69 +11236,111 @@ function lintHookFieldTranslations(config, issues) {
   );
   if (hasPromptHooks) {
     if (config.targets.includes("claude-code")) {
-      pushIssue(issues, {
-        level: "warning",
-        code: "claude-prompt-hook-degrade",
-        message: "Prompt hooks are documented in Claude-native hook surfaces, but the current Claude-family generator still drops prompt hooks. Expect a degraded result unless you remodel them as command hooks or host-specific manual work.",
-        file: "pluxx.config.ts",
-        platform: "claude-code"
-      });
+      const warnedEvents = /* @__PURE__ */ new Set();
+      for (const [event, entries] of Object.entries(config.hooks)) {
+        if (!(entries ?? []).some((entry) => entry.type === "prompt")) continue;
+        const mappedEvent = mapHookEventToPascalCase(event);
+        const issue = getPromptHookTranslationIssue("claude-code", mappedEvent);
+        if (!issue || warnedEvents.has(mappedEvent)) continue;
+        warnedEvents.add(mappedEvent);
+        pushIssue(issues, {
+          level: "warning",
+          file: "pluxx.config.ts",
+          platform: "claude-code",
+          ...issue
+        });
+      }
     }
     if (config.targets.includes("codex")) {
-      pushIssue(issues, {
-        level: "warning",
-        code: "codex-prompt-hook-drop",
-        message: "Codex currently receives only command-hook companions from Pluxx. Prompt hooks will be dropped from the generated Codex bundle.",
-        file: "pluxx.config.ts",
-        platform: "codex"
-      });
+      const issue = getPromptHookTranslationIssue("codex");
+      if (issue) {
+        pushIssue(issues, {
+          level: "warning",
+          file: "pluxx.config.ts",
+          platform: "codex",
+          ...issue
+        });
+      }
     }
     if (config.targets.includes("opencode")) {
+      const issue = getPromptHookTranslationIssue("opencode");
+      if (issue) {
+        pushIssue(issues, {
+          level: "warning",
+          file: "pluxx.config.ts",
+          platform: "opencode",
+          ...issue
+        });
+      }
+    }
+  }
+  if (hasFailClosed && config.targets.includes("claude-code")) {
+    const issue = getHookFieldTranslationIssue("claude-code", "failClosed");
+    if (issue) {
       pushIssue(issues, {
         level: "warning",
-        code: "opencode-prompt-hook-drop",
-        message: "The current OpenCode runtime wrapper only emits command hooks. Prompt hooks will be dropped from the generated OpenCode plugin.",
         file: "pluxx.config.ts",
-        platform: "opencode"
+        platform: "claude-code",
+        ...issue
       });
     }
   }
-  if (hasFailClosed && config.targets.includes("claude-code")) {
-    pushIssue(issues, {
-      level: "warning",
-      code: "claude-hook-failclosed-degrade",
-      message: "Claude hook entries currently drop `failClosed` in generated output. Keep this behavior host-specific or verify the generated hook bundle carefully.",
-      file: "pluxx.config.ts",
-      platform: "claude-code"
-    });
-  }
   if (hasLoopLimit) {
     if (config.targets.includes("claude-code")) {
-      pushIssue(issues, {
-        level: "warning",
-        code: "claude-hook-loop-limit-degrade",
-        message: "Claude outputs currently drop `loop_limit`. Recursive hook protection is not preserved there today.",
-        file: "pluxx.config.ts",
-        platform: "claude-code"
-      });
+      const issue = getHookFieldTranslationIssue("claude-code", "loop_limit");
+      if (issue) {
+        pushIssue(issues, {
+          level: "warning",
+          file: "pluxx.config.ts",
+          platform: "claude-code",
+          ...issue
+        });
+      }
     }
     if (config.targets.includes("codex")) {
-      pushIssue(issues, {
-        level: "warning",
-        code: "codex-hook-loop-limit-drop",
-        message: "Codex hook companions currently drop `loop_limit`. Only command, matcher, timeout, and failClosed survive there today.",
-        file: "pluxx.config.ts",
-        platform: "codex"
-      });
+      const issue = getHookFieldTranslationIssue("codex", "loop_limit");
+      if (issue) {
+        pushIssue(issues, {
+          level: "warning",
+          file: "pluxx.config.ts",
+          platform: "codex",
+          ...issue
+        });
+      }
     }
     if (config.targets.includes("opencode")) {
-      pushIssue(issues, {
-        level: "warning",
-        code: "opencode-hook-loop-limit-drop",
-        message: "OpenCode runtime hooks currently drop `loop_limit`. Recursive hook protection is still Cursor-first in Pluxx.",
-        file: "pluxx.config.ts",
-        platform: "opencode"
-      });
+      const issue = getHookFieldTranslationIssue("opencode", "loop_limit");
+      if (issue) {
+        pushIssue(issues, {
+          level: "warning",
+          file: "pluxx.config.ts",
+          platform: "opencode",
+          ...issue
+        });
+      }
+    }
+  }
+}
+function lintHookTypeTranslations(config, issues) {
+  if (!config.hooks) return;
+  const seen = /* @__PURE__ */ new Set();
+  for (const entries of Object.values(config.hooks)) {
+    for (const entry of entries ?? []) {
+      if (!entry.type || entry.type === "command") continue;
+      for (const target of ["codex", "opencode"]) {
+        if (!config.targets.includes(target) || isHookTypeSupported(target, entry.type)) continue;
+        const key = `${target}:${entry.type}`;
+        if (seen.has(key)) continue;
+        seen.add(key);
+        const issue = getHookTypeTranslationIssue(target, entry.type);
+        if (!issue) continue;
+        pushIssue(issues, {
+          level: "warning",
+          file: "pluxx.config.ts",
+          platform: target,
+          ...issue
+        });
+      }
     }
   }
 }
@@ -10606,7 +11349,7 @@ function lintCodexCommandGuidance(config, issues) {
   pushIssue(issues, {
     level: "warning",
     code: "codex-commands-routing-guidance",
-    message: "Codex does not currently document plugin-packaged slash-command parity. Pluxx will degrade commands into skills plus AGENTS.md and `.codex/commands.generated.json` routing guidance.",
+    message: `${getCodexCommandGuidanceNote()} Pluxx will degrade commands into skills plus those routing surfaces today.`,
     file: "pluxx.config.ts",
     platform: "codex"
   });
@@ -10816,6 +11559,7 @@ async function lintProject(dir = process.cwd(), options = {}) {
   lintPermissions(lintConfig, issues);
   lintPrimitiveTranslations(lintConfig, issues);
   lintHookFieldTranslations(lintConfig, issues);
+  lintHookTypeTranslations(lintConfig, issues);
   lintCodexCommandGuidance(lintConfig, issues);
   lintCursorHooks(lintConfig, issues);
   lintCursorRuleContentLimits(lintConfig, issues);
@@ -10902,131 +11646,6 @@ import { resolve as resolve14 } from "path";
 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 resolve13 } from "path";
-
-// src/user-config.ts
-var ENV_VAR_NAME = /^[A-Za-z_][A-Za-z0-9_]*$/;
-var PLACEHOLDER_SECRET_PATTERNS = [
-  /\bdummy\b/i,
-  /\bplaceholder\b/i,
-  /\bexample\b/i,
-  /\bchangeme\b/i,
-  /\breplace[_ -]?me\b/i,
-  /\byour[_ -]?(api[_ -]?)?key\b/i,
-  /\bapi[_ -]?key[_ -]?here\b/i,
-  /\btoken[_ -]?here\b/i
-];
-function normalizeUserConfigKey(value) {
-  return value.replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1-$2").replace(/[._/\s]+/g, "-").toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "");
-}
-function humanizeUserConfigLabel(value) {
-  return value.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").replace(/[._/]+/g, " ").replace(/-/g, " ").split(/\s+/).filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1).toLowerCase()).join(" ");
-}
-function defaultUserConfigEnvVar(key) {
-  return key.replace(/[^A-Za-z0-9]+/g, "_").replace(/_+/g, "_").replace(/^_+|_+$/g, "").toUpperCase();
-}
-function extractEnvReference(value) {
-  if (!value) return void 0;
-  const match = value.match(/^\$\{([A-Za-z_][A-Za-z0-9_]*)\}$/);
-  return match?.[1];
-}
-function isPlaceholderSecretValue(value) {
-  if (typeof value !== "string") return false;
-  const normalized = value.trim();
-  if (normalized === "") return false;
-  return PLACEHOLDER_SECRET_PATTERNS.some((pattern) => pattern.test(normalized));
-}
-function isRuntimePlatformManaged(config, target, server) {
-  if (server.transport === "stdio") return false;
-  if (server.auth?.type === "platform") {
-    return true;
-  }
-  if (target === "claude-code") {
-    return config.platforms?.["claude-code"]?.mcpAuth === "platform";
-  }
-  if (target === "cursor") {
-    return config.platforms?.cursor?.mcpAuth === "platform";
-  }
-  return false;
-}
-function targetApplies(entry, target) {
-  return !entry.targets || entry.targets.includes(target);
-}
-function dedupeUserConfigEntries(entries) {
-  const deduped = [];
-  const seenKeys = /* @__PURE__ */ new Set();
-  const seenEnvVars = /* @__PURE__ */ new Set();
-  for (const entry of entries) {
-    const envVar = entry.envVar?.trim();
-    if (seenKeys.has(entry.key)) continue;
-    if (envVar && seenEnvVars.has(envVar)) continue;
-    deduped.push(entry);
-    seenKeys.add(entry.key);
-    if (envVar) seenEnvVars.add(envVar);
-  }
-  return deduped;
-}
-function collectUserConfigEntries(config, platforms = config.targets) {
-  const explicitEntries = (config.userConfig ?? []).filter((entry) => !entry.targets || entry.targets.some((target) => platforms.includes(target))).map((entry) => ({ ...entry, source: "explicit" }));
-  const derivedEntries = [];
-  for (const [serverName, server] of Object.entries(config.mcp ?? {})) {
-    const applicableTargets = platforms.filter((target) => !isRuntimePlatformManaged(config, target, server));
-    if (server.auth?.type && server.auth.type !== "none" && server.auth.type !== "platform" && ENV_VAR_NAME.test(server.auth.envVar) && applicableTargets.length > 0) {
-      derivedEntries.push({
-        key: normalizeUserConfigKey(server.auth.envVar),
-        title: humanizeUserConfigLabel(server.auth.envVar),
-        description: `Authentication credential for the ${serverName} MCP server.`,
-        type: "secret",
-        required: true,
-        envVar: server.auth.envVar,
-        targets: applicableTargets,
-        source: "mcp-auth"
-      });
-    }
-    if (server.transport === "stdio") {
-      for (const [key, rawValue] of Object.entries(server.env ?? {})) {
-        const envVar = extractEnvReference(rawValue) ?? (ENV_VAR_NAME.test(key) ? key : void 0);
-        if (!envVar || !ENV_VAR_NAME.test(envVar)) continue;
-        if (extractEnvReference(rawValue) === void 0 && rawValue !== "") {
-          continue;
-        }
-        derivedEntries.push({
-          key: normalizeUserConfigKey(envVar),
-          title: humanizeUserConfigLabel(envVar),
-          description: `Environment value required to launch the ${serverName} stdio MCP server.`,
-          type: "secret",
-          required: true,
-          envVar,
-          targets: applicableTargets.length > 0 ? applicableTargets : platforms,
-          source: "mcp-env"
-        });
-      }
-    }
-  }
-  return dedupeUserConfigEntries([
-    ...explicitEntries,
-    ...derivedEntries
-  ]);
-}
-function resolveUserConfigEntriesForTarget(entries, target) {
-  return entries.filter(({ field }) => targetApplies(field, target));
-}
-function buildUserConfigEnvMap(entries) {
-  const env = {};
-  for (const entry of entries) {
-    if (!entry.envVar) continue;
-    env[entry.envVar] = String(entry.value);
-  }
-  return env;
-}
-function buildUserConfigValueMap(entries) {
-  const values = {};
-  for (const entry of entries) {
-    values[entry.field.key] = entry.value;
-  }
-  return values;
-}
-
-// src/cli/init-from-mcp.ts
 var MCP_SKILL_GROUPINGS = ["workflow", "tool"];
 var MCP_HOOK_MODES = ["none", "safe"];
 var MCP_RUNTIME_AUTH_MODES = ["inline", "platform"];
@@ -11243,17 +11862,29 @@ async function planMcpScaffold(options) {
   const instructionsPath = resolve13(options.rootDir, "INSTRUCTIONS.md");
   const skillRoot = resolve13(options.rootDir, "skills");
   const commandsRoot = resolve13(options.rootDir, "commands");
+  const basePlatforms = runtimeAuthMode === "platform" ? {
+    "claude-code": { mcpAuth: "platform" },
+    cursor: { mcpAuth: "platform" }
+  } : void 0;
+  const platforms = mergePlatformConfigMaps(basePlatforms, options.platformOverrides);
   const userConfigSource = {
     targets: options.targets,
     mcp: {
       [serverName]: options.source
     },
-    platforms: runtimeAuthMode === "platform" ? {
-      "claude-code": { mcpAuth: "platform" },
-      cursor: { mcpAuth: "platform" }
-    } : void 0
+    platforms
   };
-  const userConfig = collectUserConfigEntries(userConfigSource).map(({ source: _source, ...entry }) => entry);
+  const baseUserConfig = collectUserConfigEntries(userConfigSource);
+  const userConfig = [
+    ...baseUserConfig,
+    ...collectNativeMcpAuthUserConfigEntries(userConfigSource, options.targets, baseUserConfig)
+  ].map((entry) => {
+    if ("source" in entry) {
+      const { source: _source, ...rest } = entry;
+      return rest;
+    }
+    return entry;
+  });
   const skillDirectories = [];
   const commandFiles = [];
   const generatedFiles = ["pluxx.config.ts", "./INSTRUCTIONS.md"];
@@ -11283,6 +11914,7 @@ async function planMcpScaffold(options) {
       passthroughPaths,
       runtimeAuthMode,
       permissions,
+      platforms,
       commandsPath: plannedCommands.length > 0 ? "./commands/" : void 0
     })
   );
@@ -11521,6 +12153,7 @@ function buildSkillContent(skill) {
 function buildCommandContent(skill, existingContent) {
   const description = truncate(cleanSingleLineText(skill.description), 140);
   const argumentHint = inferCommandArgumentHint(skill);
+  const argumentNames = inferCommandArgumentNames(skill);
   const entryBlurb = buildCommandEntryBlurb(skill);
   const hasRelatedResources = skill.resources.length > 0 || skill.resourceTemplates.length > 0;
   const hasRelatedPrompts = skill.prompts.length > 0;
@@ -11539,7 +12172,10 @@ function buildCommandContent(skill, existingContent) {
   const generatedContent = [
     "---",
     `description: ${JSON.stringify(description)}`,
+    `when_to_use: ${JSON.stringify(entryBlurb)}`,
     `argument-hint: ${formatArgumentHintFrontmatter(argumentHint)}`,
+    `arguments: ${JSON.stringify(argumentNames)}`,
+    `skill: ${JSON.stringify(skill.dirName)}`,
     "---",
     "",
     entryBlurb,
@@ -11704,15 +12340,8 @@ function buildConfigTemplate(input) {
   const permissionsBlock = input.permissions ? `
   permissions: ${serializePermissions(input.permissions)},
 ` : "";
-  const platformsBlock = input.runtimeAuthMode === "platform" ? `
-  platforms: {
-    'claude-code': {
-      mcpAuth: 'platform',
-    },
-    cursor: {
-      mcpAuth: 'platform',
-    },
-  },
+  const platformsBlock = input.platforms ? `
+  platforms: ${serializePlatformOverrides(input.platforms)},
 ` : "";
   return `import { definePlugin } from 'pluxx'
 
@@ -11861,6 +12490,88 @@ function serializePermissions(permissions) {
 ${entries}
   }`;
 }
+function mergePlatformConfigMaps(base, extra) {
+  const merged = {
+    ...base ?? {},
+    ...extra ?? {}
+  };
+  if (base?.["claude-code"] || extra?.["claude-code"]) {
+    merged["claude-code"] = {
+      ...base?.["claude-code"] ?? {},
+      ...extra?.["claude-code"] ?? {},
+      ...base?.["claude-code"]?.mcpServers || extra?.["claude-code"]?.mcpServers ? {
+        mcpServers: {
+          ...base?.["claude-code"]?.mcpServers ?? {},
+          ...extra?.["claude-code"]?.mcpServers ?? {}
+        }
+      } : {}
+    };
+  }
+  if (base?.cursor || extra?.cursor) {
+    merged.cursor = {
+      ...base?.cursor ?? {},
+      ...extra?.cursor ?? {},
+      ...base?.cursor?.mcpServers || extra?.cursor?.mcpServers ? {
+        mcpServers: {
+          ...base?.cursor?.mcpServers ?? {},
+          ...extra?.cursor?.mcpServers ?? {}
+        }
+      } : {}
+    };
+  }
+  if (base?.codex || extra?.codex) {
+    merged.codex = {
+      ...base?.codex ?? {},
+      ...extra?.codex ?? {},
+      ...base?.codex?.mcpServers || extra?.codex?.mcpServers ? {
+        mcpServers: {
+          ...base?.codex?.mcpServers ?? {},
+          ...extra?.codex?.mcpServers ?? {}
+        }
+      } : {}
+    };
+  }
+  if (base?.opencode || extra?.opencode) {
+    merged.opencode = {
+      ...base?.opencode ?? {},
+      ...extra?.opencode ?? {},
+      ...base?.opencode?.mcpServers || extra?.opencode?.mcpServers ? {
+        mcpServers: {
+          ...base?.opencode?.mcpServers ?? {},
+          ...extra?.opencode?.mcpServers ?? {}
+        }
+      } : {}
+    };
+  }
+  return Object.keys(merged).length > 0 ? merged : void 0;
+}
+function serializePlatformOverrides(platforms) {
+  return serializeTsLiteral(platforms, 1);
+}
+function serializeTsLiteral(value, indentLevel) {
+  const indent = "  ".repeat(indentLevel);
+  const nextIndent = "  ".repeat(indentLevel + 1);
+  if (Array.isArray(value)) {
+    if (value.length === 0) return "[]";
+    return `[
+${value.map((item) => `${nextIndent}${serializeTsLiteral(item, indentLevel + 1)}`).join(",\n")}
+${indent}]`;
+  }
+  if (value && typeof value === "object") {
+    const entries = Object.entries(value).filter(([, entryValue]) => entryValue !== void 0);
+    if (entries.length === 0) return "{}";
+    return `{
+${entries.map(([key, entryValue]) => `${nextIndent}${serializeTsKey(key)}: ${serializeTsLiteral(entryValue, indentLevel + 1)}`).join(",\n")}
+${indent}}`;
+  }
+  if (typeof value === "string") {
+    return `'${value.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`;
+  }
+  return JSON.stringify(value);
+}
+function serializeTsKey(key) {
+  return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key) ? key : `'${key}'`;
+}
 var MUTATING_PREFIXES = [
   "create",
   "add",
@@ -12374,6 +13085,13 @@ function buildInstructionSkillSummary(skill) {
   return `\`${skill.dirName}\`: ${description} Primary tools: ${toolNames}.${resourceNote}${promptNote}`;
 }
 function inferCommandArgumentHint(skill) {
+  const fieldHints = inferCommandArgumentNames(skill);
+  if (fieldHints.length === 0) {
+    return "[request]";
+  }
+  return fieldHints.slice(0, 2).map((hint) => `[${hint}]`).join(" ");
+}
+function inferCommandArgumentNames(skill) {
   const fieldHints = /* @__PURE__ */ new Set();
   for (const tool of skill.tools) {
     const fields = getTopLevelSchemaFields(tool.inputSchema);
@@ -12386,9 +13104,9 @@ function inferCommandArgumentHint(skill) {
     if (fieldHints.size >= 2) break;
   }
   if (fieldHints.size === 0) {
-    return "[request]";
+    return ["request"];
   }
-  return [...fieldHints].slice(0, 2).map((hint) => `[${hint}]`).join(" ");
+  return [...fieldHints].slice(0, 2);
 }
 function buildCommandEntryBlurb(skill) {
   const intent = inferSkillIntentPhrase(skill);
@@ -14798,12 +15516,21 @@ function loadManualAgentProjectModel(rootDir, config) {
   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)),
-    title: command2.title,
-    description: command2.description,
-    argumentHint: command2.argumentHint
-  }));
+  const commands = readCanonicalCommandFiles(commandsDir).map((command2) => {
+    const metadata = getCanonicalCommandMetadata(command2);
+    return {
+      path: normalizeRelativePath(relative10(rootDir, command2.filePath)),
+      title: metadata.title,
+      description: metadata.description,
+      whenToUse: metadata.whenToUse,
+      argumentHint: metadata.argumentHint,
+      ...metadata.arguments.length > 0 ? { arguments: metadata.arguments } : {},
+      ...metadata.examples.length > 0 ? { examples: metadata.examples } : {},
+      ...metadata.skill ? { skill: metadata.skill } : {},
+      ...metadata.skills.length > 0 ? { skills: metadata.skills } : {},
+      ...metadata.agent ? { agent: metadata.agent } : {}
+    };
+  });
   return {
     sourceKind: "manual",
     displayName,
@@ -14872,6 +15599,9 @@ function buildAgentContext(config, project, lint, contextSources, ingestion, doc
     if (skill.description) {
       lines.push(`- Description: ${skill.description}`);
     }
+    if ((skill.supportPaths?.length ?? 0) > 0) {
+      lines.push(`- Related files: ${skill.supportPaths?.map((path) => `\`${path}\``).join(", ")}`);
+    }
     if (relatedResourceLabels.length > 0) {
       lines.push(`- Related resources: ${relatedResourceLabels.join(", ")}`);
     }
@@ -14884,7 +15614,18 @@ function buildAgentContext(config, project, lint, contextSources, ingestion, doc
     lines.push("## Commands");
     lines.push("");
     for (const command2 of project.commands) {
-      lines.push(`- \`${command2.path}\`: ${command2.description ?? command2.title}${command2.argumentHint ? ` (arguments: ${command2.argumentHint})` : ""}`);
+      const details = [
+        command2.argumentHint ? `arguments: ${command2.argumentHint}` : null,
+        command2.skill ? `skill: ${command2.skill}` : null,
+        command2.agent ? `agent: ${command2.agent}` : null
+      ].filter(Boolean);
+      lines.push(`- \`${command2.path}\`: ${command2.description ?? command2.title}${details.length > 0 ? ` (${details.join("; ")})` : ""}`);
+      if (command2.whenToUse) {
+        lines.push(`  - When to use: ${command2.whenToUse}`);
+      }
+      if ((command2.examples?.length ?? 0) > 0) {
+        lines.push(`  - Examples: ${command2.examples?.map((example) => `\`${example}\``).join(", ")}`);
+      }
     }
     lines.push("");
   }
@@ -16301,13 +17042,17 @@ function normalizeRelativePath(path) {
   return path.replace(/\\/g, "/").replace(/^\.\//, "");
 }
 function readCanonicalSkillFiles2(rootDir, skillsDir) {
-  return readCanonicalSkillFiles(skillsDir).map((skill) => ({
-    dirName: normalizeRelativePath(skill.dirName),
-    title: skill.firstHeading ?? skill.name ?? skill.dirName,
-    description: skill.description,
-    toolNames: [],
-    path: normalizeRelativePath(relative10(rootDir, skill.filePath))
-  }));
+  return readCanonicalSkillFiles(skillsDir).map((skill) => {
+    const metadata = getCanonicalSkillMetadata(skill);
+    return {
+      dirName: normalizeRelativePath(skill.dirName),
+      title: metadata.title,
+      description: metadata.description,
+      toolNames: [],
+      path: normalizeRelativePath(relative10(rootDir, skill.filePath)),
+      ...metadata.supportPaths.length > 0 ? { supportPaths: metadata.supportPaths } : {}
+    };
+  });
 }
 function summarizeDiscoveryDescription(description, trailing) {
   const base = description?.replace(/\s+/g, " ").trim().slice(0, 180);
@@ -16823,7 +17568,7 @@ ${additions.map((block) => `- ${block.replace(/\n/g, "\n  ")}`).join("\n")}
 }
 
 // src/cli/doctor.ts
-import { spawn as spawn3 } from "child_process";
+import { spawn as spawn3, spawnSync as spawnSync2 } from "child_process";
 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";
 
@@ -16876,7 +17621,11 @@ function listHookCommands(hooks) {
   return commands;
 }
 function planInstallUserConfig(config, platforms = config.targets) {
-  const entries = collectUserConfigEntries(config, platforms);
+  const baseEntries = collectUserConfigEntries(config, platforms);
+  const entries = [
+    ...baseEntries,
+    ...collectNativeMcpAuthUserConfigEntries(config, platforms, baseEntries)
+  ];
   return entries.map((field) => {
     const envVar = field.envVar ?? defaultUserConfigEnvVar(field.key);
     const envValue = process.env[envVar];
@@ -17330,7 +18079,10 @@ function patchInstalledMcpConfig(pluginDir, platform, config, entries) {
         type: server.transport === "sse" ? "sse" : "http",
         url: server.url
       };
-      if (!usesPlatformManagedAuth && server.auth?.type === "bearer" && server.auth.envVar && env[server.auth.envVar]) {
+      const nativeHeaders = getNativeJsonHeadersOverride(config, platform, name);
+      if (!usesPlatformManagedAuth && nativeHeaders) {
+        entry.headers = materializeEnvRecord(nativeHeaders, env);
+      } else if (!usesPlatformManagedAuth && server.auth?.type === "bearer" && server.auth.envVar && env[server.auth.envVar]) {
         entry.headers = {
           Authorization: `Bearer ${env[server.auth.envVar]}`
         };
@@ -17360,7 +18112,32 @@ function patchInstalledMcpConfig(pluginDir, platform, config, entries) {
       const entry = {
         url: server.url
       };
-      if (server.auth?.type === "bearer" && server.auth.envVar && env[server.auth.envVar]) {
+      const nativeOverride = getNativeCodexMcpEntryOverride(config, name);
+      if (nativeOverride) {
+        if (typeof nativeOverride.bearer_token_env_var === "string") {
+          const envVar = nativeOverride.bearer_token_env_var;
+          if (env[envVar]) {
+            entry.bearer_token_env_var = envVar;
+          }
+        }
+        if (nativeOverride.auth) {
+          entry.auth = nativeOverride.auth;
+        }
+        if (nativeOverride.env_http_headers && typeof nativeOverride.env_http_headers === "object") {
+          entry.http_headers = Object.fromEntries(
+            Object.entries(nativeOverride.env_http_headers).filter(([, value]) => typeof value === "string").map(([headerName, envVar]) => [
+              headerName,
+              env[envVar] ?? `\${${envVar}}`
+            ])
+          );
+        }
+        if (nativeOverride.http_headers && typeof nativeOverride.http_headers === "object") {
+          entry.http_headers = materializeEnvRecord(
+            nativeOverride.http_headers,
+            env
+          );
+        }
+      } else if (server.auth?.type === "bearer" && server.auth.envVar && env[server.auth.envVar]) {
         entry.http_headers = {
           Authorization: `Bearer ${env[server.auth.envVar]}`
         };
@@ -18801,6 +19578,166 @@ function checkInstalledBundleIntegrity(checks, rootDir, layout) {
     path: layout.manifestPath
   });
 }
+function parseInstalledPermissionRules(scriptSource) {
+  const match = scriptSource.match(/const RULES = (\[[\s\S]*?\]);\nconst ACTION_PRIORITY/);
+  if (!match?.[1]) {
+    throw new Error("Could not locate embedded RULES payload in hooks/pluxx-permissions.mjs.");
+  }
+  const parsed = JSON.parse(match[1]);
+  if (!Array.isArray(parsed)) {
+    throw new Error("Embedded RULES payload is not an array.");
+  }
+  return parsed;
+}
+function materializePermissionPattern(pattern) {
+  return pattern.replace(/\*\*/g, "probe/path").replace(/\*/g, "probe");
+}
+function buildInstalledPermissionProbe(platform, rule) {
+  const value = materializePermissionPattern(rule.pattern);
+  if (rule.kind === "Bash") {
+    return {
+      action: rule.action,
+      raw: rule.raw,
+      mode: platform === "cursor" ? "cursor-shell" : "claude-pretool",
+      event: platform === "cursor" ? { command: value } : { tool_name: "Bash", tool_input: { command: value } }
+    };
+  }
+  if (rule.kind === "Read") {
+    return {
+      action: rule.action,
+      raw: rule.raw,
+      mode: platform === "cursor" ? "cursor-read" : "claude-pretool",
+      event: platform === "cursor" ? { file_path: value } : { tool_name: "Read", tool_input: { file_path: value } }
+    };
+  }
+  if (rule.kind === "Edit") {
+    return {
+      action: rule.action,
+      raw: rule.raw,
+      mode: platform === "cursor" ? "cursor" : "claude-pretool",
+      event: { tool_name: "Edit", tool_input: { file_path: value } }
+    };
+  }
+  if (rule.kind === "Skill") {
+    return {
+      action: rule.action,
+      raw: rule.raw,
+      mode: platform === "cursor" ? "cursor" : "claude-pretool",
+      event: { tool_name: "Skill", tool_input: { name: value } }
+    };
+  }
+  if (rule.kind === "MCP") {
+    const canonical = value.includes(".") ? value : `${value}.probe`;
+    const dotIndex = canonical.indexOf(".");
+    const server = canonical.slice(0, dotIndex).trim();
+    const tool = canonical.slice(dotIndex + 1).trim();
+    if (!server || !tool) return null;
+    return {
+      action: rule.action,
+      raw: rule.raw,
+      mode: platform === "cursor" ? "cursor-mcp" : "claude-pretool",
+      event: platform === "cursor" ? { tool_name: `mcp__${server}__${tool.replace(/\./g, "__")}` } : { tool_name: `mcp__${server}__${tool.replace(/\./g, "__")}` }
+    };
+  }
+  return null;
+}
+function extractPermissionDecision(platform, payload) {
+  if (platform === "claude-code") {
+    const hookSpecificOutput = payload.hookSpecificOutput;
+    if (!hookSpecificOutput || typeof hookSpecificOutput !== "object") return void 0;
+    const decision2 = hookSpecificOutput.permissionDecision;
+    return typeof decision2 === "string" ? decision2 : void 0;
+  }
+  const decision = payload.permission;
+  return typeof decision === "string" ? decision : void 0;
+}
+function smokeCheckInstalledPermissionHook(rootDir, layout) {
+  if (layout.platform !== "claude-code" && layout.platform !== "cursor") {
+    return null;
+  }
+  const scriptPath = resolve19(rootDir, "hooks/pluxx-permissions.mjs");
+  if (!existsSync23(scriptPath)) {
+    return null;
+  }
+  const rules = parseInstalledPermissionRules(readFileSync13(scriptPath, "utf-8"));
+  const selected = /* @__PURE__ */ new Map();
+  for (const rule of rules) {
+    if (selected.has(rule.action)) continue;
+    const probe = buildInstalledPermissionProbe(layout.platform, rule);
+    if (!probe) continue;
+    selected.set(rule.action, probe);
+  }
+  if (selected.size === 0) {
+    return {
+      ok: false,
+      detail: "Permission hook script is present, but no supported canonical probe cases could be derived from its embedded rules."
+    };
+  }
+  const failures = [];
+  const successes = [];
+  for (const probe of selected.values()) {
+    const result = spawnSync2("node", [scriptPath, probe.mode], {
+      cwd: rootDir,
+      input: JSON.stringify(probe.event),
+      encoding: "utf-8",
+      env: process.env
+    });
+    if (result.status !== 0) {
+      failures.push(`${probe.raw} exited ${result.status ?? "null"}${result.stderr ? `: ${result.stderr.trim()}` : ""}`);
+      continue;
+    }
+    let payload;
+    try {
+      payload = JSON.parse(result.stdout || "{}");
+    } catch (error) {
+      failures.push(`${probe.raw} returned non-JSON output: ${error instanceof Error ? error.message : String(error)}`);
+      continue;
+    }
+    const decision = extractPermissionDecision(layout.platform, payload);
+    if (decision !== probe.action) {
+      failures.push(`${probe.raw} returned ${decision ?? "no decision"} instead of ${probe.action}`);
+      continue;
+    }
+    successes.push(`${probe.raw} -> ${decision}`);
+  }
+  return failures.length > 0 ? { ok: false, detail: failures.join("; ") } : { ok: true, detail: `Validated ${successes.join(", ")}` };
+}
+function checkInstalledPermissionHook(checks, rootDir, layout) {
+  const permissionScriptPath = "hooks/pluxx-permissions.mjs";
+  let scriptResult;
+  try {
+    scriptResult = smokeCheckInstalledPermissionHook(rootDir, layout);
+  } catch (error) {
+    addCheck2(checks, {
+      level: "error",
+      code: "consumer-permission-hook-invalid",
+      title: "Installed bundled permission hook behavior is broken",
+      detail: error instanceof Error ? error.message : String(error),
+      fix: "Rebuild or reinstall the plugin so the bundled permission hook script and hook wiring stay aligned with the declared permission rules.",
+      path: permissionScriptPath
+    });
+    return;
+  }
+  if (!scriptResult) {
+    addCheck2(checks, {
+      level: "info",
+      code: "consumer-permission-hook-not-applicable",
+      title: "No bundled permission hook smoke check for this install",
+      detail: layout.platform === "claude-code" || layout.platform === "cursor" ? "This installed bundle does not include hooks/pluxx-permissions.mjs." : "This platform does not currently use a bundled pluxx-permissions.mjs hook script for permission enforcement.",
+      fix: "No action needed unless you expected bundled permission-hook enforcement in this installed bundle.",
+      path: permissionScriptPath
+    });
+    return;
+  }
+  addCheck2(checks, {
+    level: scriptResult.ok ? "success" : "error",
+    code: scriptResult.ok ? "consumer-permission-hook-valid" : "consumer-permission-hook-invalid",
+    title: scriptResult.ok ? "Installed bundled permission hook returns expected decisions" : "Installed bundled permission hook behavior is broken",
+    detail: scriptResult.detail,
+    fix: scriptResult.ok ? "No action needed." : "Rebuild or reinstall the plugin so the bundled permission hook script and hook wiring stay aligned with the declared permission rules.",
+    path: permissionScriptPath
+  });
+}
 function findMissingInstalledStdioRuntimePaths(rootDir, stdioEntries) {
   const missing = /* @__PURE__ */ new Set();
   for (const server of stdioEntries) {
@@ -19068,6 +20005,7 @@ async function doctorConsumer(rootDir = process.cwd()) {
   });
   checkConsumerManifest(checks, rootDir, layout);
   checkInstalledBundleIntegrity(checks, rootDir, layout);
+  checkInstalledPermissionHook(checks, rootDir, layout);
   checkInstalledUserConfig(checks, rootDir);
   checkInstalledEnvValidation(checks, rootDir);
   checkInstalledRuntimeScriptRoles(checks, rootDir);
@@ -19262,7 +20200,7 @@ async function runBuild(rootDir, targets) {
 }
 
 // src/cli/migrate.ts
-import { basename as basename7, relative as relative12, resolve as resolve21 } from "path";
+import { basename as basename7, dirname as dirname8, 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 = [
@@ -19291,11 +20229,19 @@ function detectPlatform(pluginDir) {
     } catch {
     }
   }
+  if (existsSync24(resolve21(pluginDir, "CLAUDE.md"))) {
+    return { platform: "claude-code" };
+  }
   return null;
 }
 function parseManifest(detection) {
+  if (!detection.manifestPath) {
+    return {};
+  }
   const raw = JSON.parse(readFileSync14(detection.manifestPath, "utf-8"));
   const result = {};
+  const brand = {};
+  const platforms = {};
   if (raw.name) result.name = raw.name;
   if (raw.version) result.version = raw.version;
   if (raw.description) result.description = raw.description;
@@ -19315,169 +20261,730 @@ function parseManifest(detection) {
       };
     }
   }
+  const homepage = typeof raw.homepage === "string" ? raw.homepage : void 0;
+  if (homepage) brand.websiteURL = homepage;
+  if (typeof raw.icon === "string") brand.icon = raw.icon;
+  if (typeof raw.logo === "string") {
+    brand.logo = raw.logo;
+    if (!brand.icon) brand.icon = raw.logo;
+  }
+  const codexInterface = asRecord4(raw.interface);
+  if (codexInterface) {
+    if (typeof codexInterface.displayName === "string") brand.displayName = codexInterface.displayName;
+    if (typeof codexInterface.shortDescription === "string") brand.shortDescription = codexInterface.shortDescription;
+    if (typeof codexInterface.longDescription === "string") brand.longDescription = codexInterface.longDescription;
+    if (typeof codexInterface.category === "string") brand.category = codexInterface.category;
+    if (typeof codexInterface.brandColor === "string") brand.color = codexInterface.brandColor;
+    if (typeof codexInterface.composerIcon === "string") brand.icon = codexInterface.composerIcon;
+    if (typeof codexInterface.logo === "string") brand.logo = codexInterface.logo;
+    if (Array.isArray(codexInterface.defaultPrompt)) {
+      const prompts = codexInterface.defaultPrompt.filter((value) => typeof value === "string");
+      if (prompts.length > 0) brand.defaultPrompts = prompts;
+    }
+    if (typeof codexInterface.websiteURL === "string") brand.websiteURL = codexInterface.websiteURL;
+    if (typeof codexInterface.privacyPolicyURL === "string") brand.privacyPolicyURL = codexInterface.privacyPolicyURL;
+    if (typeof codexInterface.termsOfServiceURL === "string") brand.termsOfServiceURL = codexInterface.termsOfServiceURL;
+    if (Array.isArray(codexInterface.screenshots)) {
+      const screenshots = codexInterface.screenshots.filter((value) => typeof value === "string");
+      if (screenshots.length > 0) brand.screenshots = screenshots;
+    }
+    const remainingInterface = Object.fromEntries(
+      Object.entries(codexInterface).filter(([key]) => !(/* @__PURE__ */ new Set([
+        "displayName",
+        "shortDescription",
+        "longDescription",
+        "category",
+        "brandColor",
+        "composerIcon",
+        "logo",
+        "defaultPrompt",
+        "websiteURL",
+        "privacyPolicyURL",
+        "termsOfServiceURL",
+        "screenshots"
+      ])).has(key))
+    );
+    if (Object.keys(remainingInterface).length > 0) {
+      platforms.codex = {
+        ...platforms.codex ?? {},
+        interface: remainingInterface
+      };
+    }
+  }
+  if (detection.platform === "cursor") {
+    const marketplacePath = resolve21(dirname8(detection.manifestPath), "marketplace.json");
+    if (existsSync24(marketplacePath)) {
+      try {
+        const marketplace = JSON.parse(readFileSync14(marketplacePath, "utf-8"));
+        if (marketplace && typeof marketplace === "object") {
+          platforms.cursor = {
+            ...platforms.cursor ?? {},
+            marketplace
+          };
+        }
+      } catch {
+      }
+    }
+  }
+  if (detection.platform === "codex") {
+    const appPath = resolve21(dirname8(dirname8(detection.manifestPath)), ".app.json");
+    if (existsSync24(appPath)) {
+      try {
+        const app = JSON.parse(readFileSync14(appPath, "utf-8"));
+        if (app && typeof app === "object" && !Array.isArray(app)) {
+          platforms.codex = {
+            ...platforms.codex ?? {},
+            app
+          };
+        }
+      } catch {
+      }
+    }
+  }
+  if (detection.platform === "opencode") {
+    const pluginConfig = asRecord4(raw.plugin);
+    if (pluginConfig) {
+      platforms.opencode = {
+        ...platforms.opencode ?? {},
+        plugin: pluginConfig
+      };
+    }
+  }
+  if (Object.keys(brand).length > 0) result.brand = brand;
+  if (Object.keys(platforms).length > 0) result.platforms = platforms;
   return result;
 }
 function parseMcp(pluginDir, detection) {
-  const mcpPaths = [
-    resolve21(pluginDir, ".mcp.json"),
-    resolve21(pluginDir, "mcp.json")
+  const mcpCandidates = [
+    { path: resolve21(pluginDir, ".mcp.json"), parser: "json" },
+    { path: resolve21(pluginDir, "mcp.json"), parser: "json" }
   ];
-  try {
-    const manifest = JSON.parse(readFileSync14(detection.manifestPath, "utf-8"));
-    if (manifest.mcpServers && typeof manifest.mcpServers === "string") {
-      mcpPaths.unshift(resolve21(pluginDir, manifest.mcpServers));
+  if (detection.platform === "codex") {
+    mcpCandidates.push({ path: resolve21(pluginDir, ".codex/config.toml"), parser: "toml" });
+  }
+  if (detection.platform === "opencode") {
+    mcpCandidates.push({ path: resolve21(pluginDir, "opencode.json"), parser: "json" });
+    mcpCandidates.push({ path: resolve21(pluginDir, ".opencode.json"), parser: "json" });
+  }
+  if (detection.manifestPath) {
+    try {
+      const manifest = JSON.parse(readFileSync14(detection.manifestPath, "utf-8"));
+      if (manifest.mcpServers && typeof manifest.mcpServers === "string") {
+        mcpCandidates.unshift({ path: resolve21(pluginDir, manifest.mcpServers), parser: "json" });
+      }
+    } catch {
+    }
+  }
+  const mergedServers = {};
+  const mergedWarnings = /* @__PURE__ */ new Set();
+  let runtimeAuthMode = "inline";
+  let platformOverrides;
+  for (const candidate of mcpCandidates) {
+    if (!existsSync24(candidate.path)) continue;
+    const parsed = candidate.parser === "toml" ? parseTomlMcpFile(candidate.path, detection.platform) : parseJsonMcpFile(candidate.path, detection.platform);
+    if (Object.keys(parsed.servers).length === 0) continue;
+    for (const [serverName, server] of Object.entries(parsed.servers)) {
+      const previous = mergedServers[serverName];
+      const combinedWarnings = [.../* @__PURE__ */ new Set([...previous?.warnings ?? [], ...server.warnings ?? []])];
+      mergedServers[serverName] = {
+        ...previous ?? {},
+        ...server,
+        ...combinedWarnings.length > 0 ? { warnings: combinedWarnings } : {}
+      };
+    }
+    if (parsed.runtimeAuthMode === "platform") {
+      runtimeAuthMode = "platform";
+    }
+    for (const warning of parsed.warnings) {
+      mergedWarnings.add(warning);
+    }
+    platformOverrides = mergePlatformOverrideMaps(platformOverrides, parsed.platformOverrides);
+  }
+  if (Object.keys(mergedServers).length > 0) {
+    return {
+      servers: mergedServers,
+      runtimeAuthMode,
+      warnings: [...mergedWarnings],
+      ...platformOverrides ? { platformOverrides } : {}
+    };
+  }
+  return {
+    servers: {},
+    runtimeAuthMode: "inline",
+    warnings: []
+  };
+}
+var HOOK_EVENT_MAP = {
+  SessionStart: "sessionStart",
+  SessionEnd: "sessionEnd",
+  PreToolUse: "preToolUse",
+  PostToolUse: "postToolUse",
+  UserPromptSubmit: "beforeSubmitPrompt",
+  BeforeShellExecution: "beforeShellExecution",
+  AfterShellExecution: "afterShellExecution",
+  BeforeMCPExecution: "beforeMCPExecution",
+  AfterMCPExecution: "afterMCPExecution",
+  AfterFileEdit: "afterFileEdit",
+  BeforeReadFile: "beforeReadFile",
+  BeforeSubmitPrompt: "beforeSubmitPrompt",
+  Stop: "stop",
+  // Also handle already-normalized names
+  sessionStart: "sessionStart",
+  sessionEnd: "sessionEnd",
+  preToolUse: "preToolUse",
+  postToolUse: "postToolUse"
+};
+function parseHooks(pluginDir, detection) {
+  const hooksPaths = [
+    resolve21(pluginDir, ".codex", "hooks.json"),
+    resolve21(pluginDir, "hooks.json"),
+    resolve21(pluginDir, "hooks", "hooks.json")
+  ];
+  if (detection.manifestPath) {
+    try {
+      const manifest = JSON.parse(readFileSync14(detection.manifestPath, "utf-8"));
+      if (manifest.hooks && typeof manifest.hooks === "string") {
+        hooksPaths.unshift(resolve21(pluginDir, manifest.hooks));
+      }
+    } catch {
     }
-  } catch {
   }
-  for (const mcpPath of mcpPaths) {
-    if (!existsSync24(mcpPath)) continue;
+  for (const hooksPath of hooksPaths) {
+    if (!existsSync24(hooksPath)) continue;
     try {
-      const raw = JSON.parse(readFileSync14(mcpPath, "utf-8"));
-      const servers = raw.mcpServers ?? raw;
-      if (!servers || typeof servers !== "object") continue;
+      const raw = JSON.parse(readFileSync14(hooksPath, "utf-8"));
+      const hooksObj = raw.hooks ?? raw;
+      if (!hooksObj || typeof hooksObj !== "object") continue;
       const result = {};
-      for (const [name, config] of Object.entries(servers)) {
-        const cfg = config;
-        const entry = {};
-        if (cfg.url) entry.url = cfg.url;
-        if (cfg.type === "stdio" || cfg.command) {
-          entry.transport = "stdio";
-          if (cfg.command) entry.command = cfg.command;
-          if (cfg.args) entry.args = cfg.args;
-          if (cfg.env) entry.env = cfg.env;
-        } else if (cfg.type === "sse") {
-          entry.transport = "sse";
-        } else {
-          entry.transport = "http";
-        }
-        if (cfg.headers && typeof cfg.headers === "object") {
-          const headers = cfg.headers;
-          const authHeader = headers["Authorization"] ?? headers["authorization"];
-          if (authHeader) {
-            const envMatch = authHeader.match(/\$\{(\w+)\}/);
-            if (envMatch) {
-              entry.auth = {
-                type: "bearer",
-                envVar: envMatch[1],
-                headerTemplate: authHeader.replace(/\$\{\w+\}/, "${value}")
-              };
+      for (const [event, entries] of Object.entries(hooksObj)) {
+        const normalizedEvent = HOOK_EVENT_MAP[event] ?? event;
+        const hookEntries = [];
+        if (!Array.isArray(entries)) continue;
+        for (const entry of entries) {
+          if (entry.hooks && Array.isArray(entry.hooks)) {
+            for (const hook of entry.hooks) {
+              const parsedHook = parseMigratedHookEntry(hook, entry.matcher);
+              if (parsedHook) hookEntries.push(parsedHook);
+            }
+          } else {
+            const parsedHook = parseMigratedHookEntry(entry);
+            if (parsedHook) {
+              hookEntries.push(parsedHook);
             }
           }
         }
-        if (cfg.bearer_token_env_var) {
-          entry.auth = {
-            type: "bearer",
-            envVar: cfg.bearer_token_env_var
-          };
+        if (hookEntries.length > 0) {
+          result[normalizedEvent] = hookEntries;
         }
-        if (cfg.env_http_headers && typeof cfg.env_http_headers === "object") {
-          const envHeaders = Object.entries(cfg.env_http_headers);
-          if (envHeaders.length > 0) {
-            const [headerName, envVar] = envHeaders[0];
-            entry.auth = {
-              type: "header",
-              envVar,
-              headerName,
-              headerTemplate: "${value}"
-            };
-          }
+      }
+      return result;
+    } catch {
+      continue;
+    }
+  }
+  return {};
+}
+function parseMigratedHookEntry(raw, fallbackMatcher) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
+  const candidate = raw;
+  const inferredType = candidate.type;
+  const type = inferredType === "command" || inferredType === "http" || inferredType === "mcp_tool" || inferredType === "prompt" || inferredType === "agent" ? inferredType : typeof candidate.prompt === "string" ? "prompt" : typeof candidate.url === "string" ? "http" : typeof candidate.server === "string" || typeof candidate.tool === "string" ? "mcp_tool" : "command";
+  const entry = { type };
+  if (typeof candidate.command === "string") entry.command = candidate.command;
+  if (typeof candidate.prompt === "string") entry.prompt = candidate.prompt;
+  if (typeof candidate.model === "string") entry.model = candidate.model;
+  if (typeof candidate.url === "string") entry.url = candidate.url;
+  if (candidate.headers && typeof candidate.headers === "object" && !Array.isArray(candidate.headers)) {
+    entry.headers = Object.fromEntries(
+      Object.entries(candidate.headers).filter(([, value]) => typeof value === "string").map(([key, value]) => [key, value])
+    );
+  }
+  if (Array.isArray(candidate.allowedEnvVars) && candidate.allowedEnvVars.every((value) => typeof value === "string")) {
+    entry.allowedEnvVars = candidate.allowedEnvVars;
+  }
+  if (typeof candidate.server === "string") entry.server = candidate.server;
+  if (typeof candidate.tool === "string") entry.tool = candidate.tool;
+  if (candidate.input && typeof candidate.input === "object" && !Array.isArray(candidate.input)) {
+    entry.input = candidate.input;
+  }
+  if (typeof candidate.if === "string") entry.if = candidate.if;
+  if (typeof candidate.async === "boolean") entry.async = candidate.async;
+  if (typeof candidate.asyncRewake === "boolean") entry.asyncRewake = candidate.asyncRewake;
+  if (candidate.shell === "bash") entry.shell = "bash";
+  if (typeof candidate.timeout === "number") entry.timeout = candidate.timeout;
+  const matcher = candidate.matcher ?? fallbackMatcher;
+  if (typeof matcher === "string") {
+    entry.matcher = matcher;
+  } else if (matcher && typeof matcher === "object" && !Array.isArray(matcher)) {
+    entry.matcher = matcher;
+  }
+  if (typeof candidate.failClosed === "boolean") entry.failClosed = candidate.failClosed;
+  if (typeof candidate.loop_limit === "number" || candidate.loop_limit === null) {
+    entry.loop_limit = candidate.loop_limit;
+  }
+  if (type === "command" && !entry.command) return null;
+  if (type === "http" && !entry.url) return null;
+  if (type === "mcp_tool" && (!entry.server || !entry.tool)) return null;
+  if ((type === "prompt" || type === "agent") && !entry.prompt) return null;
+  return entry;
+}
+function findInstructions(pluginDir) {
+  const candidates = [
+    "CLAUDE.md",
+    "AGENTS.md",
+    "instructions.md",
+    "INSTRUCTIONS.md",
+    "README.md"
+  ];
+  for (const candidate of candidates) {
+    const filePath = resolve21(pluginDir, candidate);
+    if (existsSync24(filePath)) {
+      return `./${candidate}`;
+    }
+  }
+  return void 0;
+}
+function parseCursorRules(pluginDir, detection) {
+  if (detection.platform !== "cursor") return [];
+  const manifest = detection.manifestPath ? tryReadJson(detection.manifestPath) : null;
+  const configuredRulesDir = typeof manifest?.rules === "string" ? stripRelativePrefix(manifest.rules) : void 0;
+  const candidates = [
+    configuredRulesDir,
+    "rules",
+    ".cursor/rules"
+  ].filter((value) => Boolean(value));
+  for (const relativeDir of candidates) {
+    const dirPath = resolve21(pluginDir, relativeDir);
+    if (!existsSync24(dirPath)) continue;
+    const entries = collectFiles(dirPath, (entry) => entry.endsWith(".mdc")).map((entry) => parseCursorRuleFile(pluginDir, entry)).filter((entry) => Boolean(entry));
+    if (entries.length > 0) return entries;
+  }
+  return [];
+}
+function parseCursorRuleFile(pluginDir, filePath) {
+  const content = readFileSync14(filePath, "utf-8");
+  const { hasFrontmatter, frontmatterLines, body } = splitMarkdownFrontmatter5(content);
+  if (!hasFrontmatter) return null;
+  const description = parseTopLevelStringFrontmatter(frontmatterLines, "description") ?? titleCaseFromDirName(basename7(filePath, ".mdc"));
+  const globs = parseTopLevelStringOrStringArrayFrontmatter(frontmatterLines, "globs");
+  const alwaysApply = parseTopLevelBooleanFrontmatter(frontmatterLines, "alwaysApply");
+  return {
+    description,
+    ...globs !== void 0 ? { globs } : {},
+    ...alwaysApply !== void 0 ? { alwaysApply } : {},
+    ...body.trim() ? { content: body.trim() } : {},
+    path: `./${relative12(pluginDir, filePath).replace(/\\/g, "/")}`
+  };
+}
+function collectFiles(dir, predicate) {
+  const results = [];
+  const stack = [dir];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    for (const entry of readdirSync11(current, { withFileTypes: true })) {
+      const fullPath = resolve21(current, entry.name);
+      if (entry.isDirectory()) {
+        stack.push(fullPath);
+        continue;
+      }
+      if (entry.isFile() && predicate(entry.name)) {
+        results.push(fullPath);
+      }
+    }
+  }
+  return results.sort((a, b) => a.localeCompare(b));
+}
+function findOpenCodeConfiguredInstructions(pluginDir) {
+  const candidates = [resolve21(pluginDir, "opencode.json"), resolve21(pluginDir, ".opencode.json")];
+  const discovered = /* @__PURE__ */ new Set();
+  for (const path of candidates) {
+    const raw = tryReadJson(path);
+    if (!raw) continue;
+    const instructions = raw.instructions;
+    const values = typeof instructions === "string" ? [instructions] : Array.isArray(instructions) ? instructions.filter((value) => typeof value === "string") : [];
+    for (const value of values) {
+      if (value.startsWith("./") || value.startsWith("../")) {
+        const normalized = `./${stripRelativePrefix(value)}`;
+        if (existsSync24(resolve21(pluginDir, normalized))) {
+          discovered.add(normalized);
+        }
+      }
+    }
+  }
+  return [...discovered];
+}
+function findInstructionSources(pluginDir, detection) {
+  const primary = findInstructions(pluginDir);
+  const extraPaths = /* @__PURE__ */ new Set();
+  const platformOverrides = {};
+  if (detection.platform === "cursor") {
+    const nestedAgents = collectFiles(pluginDir, (entry) => entry === "AGENTS.md").map((path) => `./${relative12(pluginDir, path).replace(/\\/g, "/")}`).filter((path) => path !== primary);
+    if (nestedAgents.length > 0) {
+      platformOverrides.cursor = {
+        ...platformOverrides.cursor ?? {},
+        instructionSources: {
+          ...asRecord4(platformOverrides.cursor?.instructionSources) ?? {},
+          nestedAgents
+        }
+      };
+      for (const path of nestedAgents) extraPaths.add(path);
+    }
+  }
+  if (detection.platform === "codex") {
+    const overridePath = "./AGENTS.override.md";
+    if (existsSync24(resolve21(pluginDir, stripRelativePrefix(overridePath)))) {
+      platformOverrides.codex = {
+        ...platformOverrides.codex ?? {},
+        instructionSources: {
+          ...asRecord4(platformOverrides.codex?.instructionSources) ?? {},
+          override: overridePath
+        }
+      };
+      if (overridePath !== primary) {
+        extraPaths.add(overridePath);
+      }
+    }
+  }
+  if (detection.platform === "opencode") {
+    const configured = findOpenCodeConfiguredInstructions(pluginDir);
+    if (configured.length > 0) {
+      platformOverrides.opencode = {
+        ...platformOverrides.opencode ?? {},
+        instructionSources: {
+          ...asRecord4(platformOverrides.opencode?.instructionSources) ?? {},
+          configured
+        }
+      };
+      for (const path of configured) {
+        if (path !== primary) extraPaths.add(path);
+      }
+    }
+  }
+  return {
+    primary: primary ?? (detection.platform === "opencode" ? findOpenCodeConfiguredInstructions(pluginDir)[0] : void 0),
+    extraPaths: [...extraPaths].sort(),
+    ...Object.keys(platformOverrides).length > 0 ? { platformOverrides } : {}
+  };
+}
+function collectPackageEntryPaths(value, acc) {
+  if (typeof value === "string") {
+    if (value.startsWith("./") || value.startsWith("../")) {
+      acc.add(`./${stripRelativePrefix(value)}`);
+    }
+    return;
+  }
+  if (!value || typeof value !== "object" || Array.isArray(value)) return;
+  for (const nested of Object.values(value)) {
+    collectPackageEntryPaths(nested, acc);
+  }
+}
+function findOpenCodeDistributionSources(pluginDir, detection) {
+  if (detection.platform !== "opencode" || !detection.manifestPath) {
+    return { extraPaths: [] };
+  }
+  const pkg = tryReadJson(detection.manifestPath);
+  if (!pkg) return { extraPaths: [] };
+  const entrypoints = {};
+  const extraPaths = /* @__PURE__ */ new Set();
+  for (const key of ["main", "module", "types"]) {
+    const value = pkg[key];
+    if (typeof value === "string") {
+      entrypoints[key] = value;
+      collectPackageEntryPaths(value, extraPaths);
+    }
+  }
+  if (pkg.exports !== void 0) {
+    entrypoints.exports = pkg.exports;
+    collectPackageEntryPaths(pkg.exports, extraPaths);
+  }
+  const fallbackEntries = ["./index.ts", "./index.js", "./src/index.ts", "./src/index.js"];
+  if (Object.keys(entrypoints).length === 0) {
+    for (const candidate of fallbackEntries) {
+      if (existsSync24(resolve21(pluginDir, stripRelativePrefix(candidate)))) {
+        entrypoints.entry = candidate;
+        extraPaths.add(candidate);
+        break;
+      }
+    }
+  }
+  const presentPaths = [...extraPaths].filter((entry) => existsSync24(resolve21(pluginDir, stripRelativePrefix(entry))));
+  if (Object.keys(entrypoints).length === 0) {
+    return { extraPaths: presentPaths };
+  }
+  return {
+    extraPaths: presentPaths,
+    platformOverrides: {
+      opencode: {
+        entrypoints
+      }
+    }
+  };
+}
+function tryReadJson(path) {
+  try {
+    const parsed = JSON.parse(readFileSync14(path, "utf-8"));
+    return asRecord4(parsed) ?? null;
+  } catch {
+    return null;
+  }
+}
+function parseJsonMcpFile(path, platform) {
+  const raw = tryReadJson(path);
+  if (!raw) {
+    return { servers: {}, runtimeAuthMode: "inline", warnings: [] };
+  }
+  const servers = extractJsonMcpServers(raw, platform, path);
+  if (!servers) {
+    return { servers: {}, runtimeAuthMode: "inline", warnings: [] };
+  }
+  return parseMcpServerRecords(servers, platform);
+}
+function extractJsonMcpServers(raw, platform, path) {
+  if (platform === "opencode") {
+    const mcp = asRecord4(raw.mcp);
+    if (mcp) return mcp;
+  }
+  const mcpServers = asRecord4(raw.mcpServers);
+  if (mcpServers) return mcpServers;
+  if (typeof raw.mcpServers === "string") return null;
+  if (path.endsWith("mcp.json") || path.endsWith(".mcp.json")) {
+    return raw;
+  }
+  return null;
+}
+function parseTomlMcpFile(path, platform) {
+  const content = readFileSync14(path, "utf-8");
+  const servers = {};
+  let currentServer;
+  let currentSubtable;
+  for (const rawLine of content.split(/\r?\n/)) {
+    const line = stripTomlComment(rawLine).trim();
+    if (!line) continue;
+    const section = line.match(/^\[mcp_servers\.([A-Za-z0-9_.-]+)(?:\.([A-Za-z0-9_.-]+))?\]$/);
+    if (section) {
+      currentServer = section[1];
+      currentSubtable = section[2];
+      servers[currentServer] ??= {};
+      if (currentSubtable) {
+        const existing = servers[currentServer][currentSubtable];
+        if (!existing || typeof existing !== "object" || Array.isArray(existing)) {
+          servers[currentServer][currentSubtable] = {};
         }
-        result[name] = entry;
       }
-      return result;
-    } catch {
-      continue;
+      continue;
+    }
+    if (!currentServer) continue;
+    const assignment = line.match(/^([A-Za-z0-9_-]+)\s*=\s*(.+)$/);
+    if (!assignment) continue;
+    const key = assignment[1];
+    const value = parseTomlValue(assignment[2].trim());
+    if (currentSubtable) {
+      const table = servers[currentServer][currentSubtable];
+      table[key] = value;
+    } else {
+      servers[currentServer][key] = value;
+    }
+  }
+  return parseMcpServerRecords(servers, platform);
+}
+function parseMcpServerRecords(servers, platform) {
+  const parsed = {};
+  const warnings = [];
+  let runtimeAuthMode = "inline";
+  const nativePlatformOverrides = buildNativeMcpPlatformOverrides(platform, servers);
+  for (const [name, config] of Object.entries(servers)) {
+    const cfg = asRecord4(config);
+    if (!cfg) continue;
+    const entryWarnings = [];
+    const entry = parseMcpServerEntry(cfg, entryWarnings);
+    if (entry.auth?.type === "platform" && entry.transport !== "stdio") {
+      runtimeAuthMode = "platform";
+    }
+    if (entryWarnings.length > 0) {
+      entry.warnings = entryWarnings;
+      warnings.push(...entryWarnings.map((warning) => `${name}: ${warning}`));
+    }
+    parsed[name] = entry;
+  }
+  return {
+    servers: parsed,
+    runtimeAuthMode,
+    warnings,
+    ...nativePlatformOverrides ? { platformOverrides: nativePlatformOverrides } : {}
+  };
+}
+function parseMcpServerEntry(cfg, warnings) {
+  const entry = {};
+  if (typeof cfg.url === "string") entry.url = cfg.url;
+  if (cfg.type === "stdio" || cfg.command) {
+    entry.transport = "stdio";
+    entry.command = normalizeCommandValue(cfg.command);
+    entry.args = normalizeStringArray(cfg.args);
+    entry.env = normalizeEnvRecord(cfg.env);
+  } else if (cfg.type === "sse") {
+    entry.transport = "sse";
+  } else {
+    entry.transport = "http";
+  }
+  const auth = inferMigrateAuth(cfg, warnings);
+  if (auth) entry.auth = auth;
+  return entry;
+}
+function inferMigrateAuth(cfg, warnings) {
+  const explicitAuth = asRecord4(cfg.auth);
+  const explicitType = typeof explicitAuth?.type === "string" ? explicitAuth.type : void 0;
+  if (explicitType === "platform") {
+    return {
+      type: "platform",
+      mode: explicitAuth?.mode === "oauth" ? "oauth" : "oauth"
+    };
+  }
+  if (explicitType === "none") {
+    return { type: "none" };
+  }
+  if (explicitType === "bearer") {
+    const envVar = firstString2(explicitAuth?.envVar, explicitAuth?.env_var);
+    if (envVar) {
+      return {
+        type: "bearer",
+        envVar,
+        headerName: firstString2(explicitAuth?.headerName, explicitAuth?.header_name) ?? "Authorization",
+        headerTemplate: firstString2(explicitAuth?.headerTemplate, explicitAuth?.header_template) ?? "Bearer ${value}"
+      };
+    }
+  }
+  if (explicitType === "header") {
+    const envVar = firstString2(explicitAuth?.envVar, explicitAuth?.env_var);
+    const headerName = firstString2(explicitAuth?.headerName, explicitAuth?.header_name);
+    if (envVar && headerName) {
+      return {
+        type: "header",
+        envVar,
+        headerName,
+        headerTemplate: firstString2(explicitAuth?.headerTemplate, explicitAuth?.header_template) ?? "${value}"
+      };
+    }
+  }
+  const bearerTokenEnv = firstString2(cfg.bearer_token_env_var, cfg.bearerTokenEnvVar);
+  if (bearerTokenEnv) {
+    return {
+      type: "bearer",
+      envVar: bearerTokenEnv,
+      headerName: "Authorization",
+      headerTemplate: "Bearer ${value}"
+    };
+  }
+  const envHttpHeaders = asRecord4(cfg.env_http_headers ?? cfg.envHttpHeaders);
+  if (envHttpHeaders) {
+    const stringHeaders = Object.entries(envHttpHeaders).filter(([, value]) => typeof value === "string").map(([key, value]) => [key, String(value)]);
+    if (stringHeaders.length > 0) {
+      const preferred = stringHeaders.find(([key]) => key.toLowerCase() === "authorization") ?? stringHeaders[0];
+      const [headerName, envVar] = preferred;
+      const extras = stringHeaders.filter(([key]) => key !== headerName);
+      if (extras.length > 0) {
+        warnings.push(`Preserved ${headerName} as canonical auth but native env_http_headers declared additional header auth keys (${extras.map(([key]) => key).join(", ")}). Review the migrated MCP config and platform overrides.`);
+      }
+      return {
+        type: headerName.toLowerCase() === "authorization" ? "bearer" : "header",
+        envVar,
+        headerName,
+        headerTemplate: headerName.toLowerCase() === "authorization" ? "Bearer ${value}" : "${value}"
+      };
     }
   }
-  return {};
-}
-var HOOK_EVENT_MAP = {
-  SessionStart: "sessionStart",
-  SessionEnd: "sessionEnd",
-  PreToolUse: "preToolUse",
-  PostToolUse: "postToolUse",
-  BeforeShellExecution: "beforeShellExecution",
-  AfterShellExecution: "afterShellExecution",
-  BeforeMCPExecution: "beforeMCPExecution",
-  AfterMCPExecution: "afterMCPExecution",
-  AfterFileEdit: "afterFileEdit",
-  BeforeReadFile: "beforeReadFile",
-  BeforeSubmitPrompt: "beforeSubmitPrompt",
-  Stop: "stop",
-  // Also handle already-normalized names
-  sessionStart: "sessionStart",
-  sessionEnd: "sessionEnd",
-  preToolUse: "preToolUse",
-  postToolUse: "postToolUse"
-};
-function parseHooks(pluginDir, detection) {
-  const hooksPaths = [
-    resolve21(pluginDir, ".codex", "hooks.json"),
-    resolve21(pluginDir, "hooks.json"),
-    resolve21(pluginDir, "hooks", "hooks.json")
-  ];
-  try {
-    const manifest = JSON.parse(readFileSync14(detection.manifestPath, "utf-8"));
-    if (manifest.hooks && typeof manifest.hooks === "string") {
-      hooksPaths.unshift(resolve21(pluginDir, manifest.hooks));
+  const headers = asRecord4(cfg.headers ?? cfg.http_headers ?? cfg.httpHeaders);
+  if (!headers) return void 0;
+  const envBackedHeaders = Object.entries(headers).filter(([, value]) => typeof value === "string").map(([headerName, rawValue]) => ({
+    headerName,
+    rawValue,
+    envVar: extractEnvVar2(rawValue)
+  })).filter((entry) => Boolean(entry.envVar));
+  if (envBackedHeaders.length > 0) {
+    const preferred = envBackedHeaders.find((entry) => entry.headerName.toLowerCase() === "authorization") ?? envBackedHeaders[0];
+    const extras = envBackedHeaders.filter((entry) => entry.headerName !== preferred.headerName);
+    if (extras.length > 0) {
+      warnings.push(`Preserved ${preferred.headerName} as canonical auth but native headers declared additional env-backed auth keys (${extras.map((entry) => entry.headerName).join(", ")}). Review the migrated MCP config and platform overrides.`);
     }
-  } catch {
+    return {
+      type: preferred.headerName.toLowerCase() === "authorization" ? "bearer" : "header",
+      envVar: preferred.envVar,
+      headerName: preferred.headerName,
+      headerTemplate: preferred.rawValue.replace(envReferencePattern(preferred.envVar), "${value}")
+    };
   }
-  for (const hooksPath of hooksPaths) {
-    if (!existsSync24(hooksPath)) continue;
+  return void 0;
+}
+function normalizeCommandValue(value) {
+  if (typeof value === "string") return value;
+  if (Array.isArray(value) && typeof value[0] === "string") return value[0];
+  return void 0;
+}
+function normalizeStringArray(value) {
+  if (!Array.isArray(value)) return void 0;
+  return value.map(String);
+}
+function normalizeEnvRecord(value) {
+  const record = asRecord4(value);
+  if (!record) return void 0;
+  const env = Object.fromEntries(
+    Object.entries(record).filter(([, rawValue]) => typeof rawValue === "string").map(([key, rawValue]) => [key, rawValue])
+  );
+  return Object.keys(env).length > 0 ? env : void 0;
+}
+function asRecord4(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  return value;
+}
+function firstString2(...values) {
+  for (const value of values) {
+    if (typeof value === "string" && value.trim()) return value.trim();
+  }
+  return void 0;
+}
+function extractEnvVar2(value) {
+  const match = value.match(/\$\{(?:env:)?([A-Za-z_][A-Za-z0-9_]*)\}|\$([A-Za-z_][A-Za-z0-9_]*)/);
+  return match?.[1] ?? match?.[2];
+}
+function envReferencePattern(envVar) {
+  return new RegExp(`\\$\\{(?:env:)?${escapeRegExp2(envVar)}\\}|\\$${escapeRegExp2(envVar)}`);
+}
+function escapeRegExp2(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function parseTopLevelStringFrontmatter(frontmatterLines, key) {
+  const match = frontmatterLines.find((line) => new RegExp(`^${escapeRegExp2(key)}\\s*:`).test(line.trim()));
+  if (!match) return void 0;
+  const rawValue = match.replace(/^[^:]+:\s*/, "");
+  return unquoteFrontmatterValue(rawValue);
+}
+function parseTopLevelBooleanFrontmatter(frontmatterLines, key) {
+  const value = parseTopLevelStringFrontmatter(frontmatterLines, key)?.toLowerCase();
+  if (value === "true") return true;
+  if (value === "false") return false;
+  return void 0;
+}
+function parseTopLevelStringOrStringArrayFrontmatter(frontmatterLines, key) {
+  const match = frontmatterLines.find((line) => new RegExp(`^${escapeRegExp2(key)}\\s*:`).test(line.trim()));
+  if (!match) return void 0;
+  const rawValue = match.replace(/^[^:]+:\s*/, "").trim();
+  if (rawValue.startsWith("[") && rawValue.endsWith("]")) {
     try {
-      const raw = JSON.parse(readFileSync14(hooksPath, "utf-8"));
-      const hooksObj = raw.hooks ?? raw;
-      if (!hooksObj || typeof hooksObj !== "object") continue;
-      const result = {};
-      for (const [event, entries] of Object.entries(hooksObj)) {
-        const normalizedEvent = HOOK_EVENT_MAP[event] ?? event;
-        const hookEntries = [];
-        if (!Array.isArray(entries)) continue;
-        for (const entry of entries) {
-          if (entry.hooks && Array.isArray(entry.hooks)) {
-            for (const hook of entry.hooks) {
-              if (hook.command) {
-                hookEntries.push({
-                  command: hook.command,
-                  ...hook.timeout && { timeout: hook.timeout }
-                });
-              }
-            }
-          } else if (entry.command) {
-            hookEntries.push({
-              command: entry.command,
-              ...entry.timeout && { timeout: entry.timeout },
-              ...entry.matcher && { matcher: entry.matcher }
-            });
-          }
-        }
-        if (hookEntries.length > 0) {
-          result[normalizedEvent] = hookEntries;
-        }
+      const parsed = JSON.parse(rawValue);
+      if (Array.isArray(parsed) && parsed.every((value) => typeof value === "string")) {
+        return parsed;
       }
-      return result;
     } catch {
-      continue;
+      return void 0;
     }
   }
-  return {};
+  return unquoteFrontmatterValue(rawValue);
 }
-function findInstructions(pluginDir) {
-  const candidates = [
-    "CLAUDE.md",
-    "AGENTS.md",
-    "instructions.md",
-    "INSTRUCTIONS.md",
-    "README.md"
-  ];
-  for (const candidate of candidates) {
-    const filePath = resolve21(pluginDir, candidate);
-    if (existsSync24(filePath)) {
-      return `./${candidate}`;
-    }
+function unquoteFrontmatterValue(value) {
+  const trimmed = value.trim();
+  if (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'")) {
+    return trimmed.slice(1, -1);
   }
-  return void 0;
+  return trimmed;
 }
 var CANONICAL_SOURCE_CANDIDATES = {
   skills: ["skills", ".claude/skills", ".cursor/skills", ".agents/skills", ".opencode/skills"],
@@ -19559,7 +21066,12 @@ function inferPermissionsFromMigratedSkills(pluginDir, sourcePaths) {
     if (!entry.isDirectory()) continue;
     const skillPath = resolve21(skillsDir, entry.name, "SKILL.md");
     if (!existsSync24(skillPath)) continue;
-    const skill = parseSkillMarkdown(readFileSync14(skillPath, "utf-8"));
+    const skill = getCanonicalSkillMetadata({
+      filePath: skillPath,
+      relativeDir: entry.name,
+      dirName: entry.name,
+      ...parseSkillMarkdown(readFileSync14(skillPath, "utf-8"))
+    });
     const inferredRules = skill.allowedTools.map(normalizeMigratedAllowedTool).filter((rule) => Boolean(rule));
     if (inferredRules.length === 0) continue;
     sawAllowedTools = true;
@@ -19581,7 +21093,7 @@ function inferPermissionsFromMigratedSkills(pluginDir, sourcePaths) {
     if (skill.shell) sourceFrontmatter.shell = skill.shell;
     skillPolicies.push({
       skillDir: entry.name,
-      title: skill.name ?? skill.firstHeading ?? titleCaseFromDirName(entry.name),
+      title: skill.title,
       description: skill.description,
       ...Object.keys(sourceFrontmatter).length > 0 ? { sourceFrontmatter } : {},
       source: {
@@ -19612,10 +21124,11 @@ function readMigratedSkills(pluginDir, sourcePaths) {
   if (sourcePaths.skills) {
     const skillsDir = resolve21(pluginDir, stripRelativePrefix(sourcePaths.skills));
     for (const skill of readCanonicalSkillFiles(skillsDir)) {
+      const metadata = getCanonicalSkillMetadata(skill);
       skills.push({
         dirName: skill.dirName,
-        title: skill.name ?? skill.firstHeading ?? titleCaseFromDirName(skill.dirName),
-        description: skill.description,
+        title: metadata.title,
+        description: metadata.description,
         toolNames: []
       });
     }
@@ -19674,9 +21187,84 @@ function parseCodexAgentToml(content) {
     description: readTomlScalarValue(content, "description"),
     model: readTomlScalarValue(content, "model"),
     effort: readTomlScalarValue(content, "model_reasoning_effort"),
+    sandboxMode: readTomlScalarValue(content, "sandbox_mode"),
     developerInstructions: readTomlMultilineValue(content, "developer_instructions")
   };
 }
+function stripTomlComment(line) {
+  let inString = false;
+  let quote2 = "";
+  for (let i = 0; i < line.length; i += 1) {
+    const char = line[i];
+    if ((char === '"' || char === "'") && line[i - 1] !== "\\") {
+      if (!inString) {
+        inString = true;
+        quote2 = char;
+      } else if (quote2 === char) {
+        inString = false;
+        quote2 = "";
+      }
+      continue;
+    }
+    if (char === "#" && !inString) return line.slice(0, i);
+  }
+  return line;
+}
+function parseTomlValue(value) {
+  if (value.startsWith('"') && value.endsWith('"')) return unquoteTomlString(value);
+  if (value.startsWith("'") && value.endsWith("'")) return value.slice(1, -1);
+  if (value.startsWith("[") && value.endsWith("]")) {
+    const inner = value.slice(1, -1).trim();
+    if (!inner) return [];
+    return splitTomlList(inner).map((part) => parseTomlValue(part.trim()));
+  }
+  if (value.startsWith("{") && value.endsWith("}")) {
+    const inner = value.slice(1, -1).trim();
+    const result = {};
+    if (!inner) return result;
+    for (const part of splitTomlList(inner)) {
+      const assignment = part.trim().match(/^([A-Za-z0-9_-]+)\s*=\s*(.+)$/);
+      if (!assignment) continue;
+      result[assignment[1]] = parseTomlValue(assignment[2].trim());
+    }
+    return result;
+  }
+  if (value === "true") return true;
+  if (value === "false") return false;
+  return value;
+}
+function splitTomlList(value) {
+  const parts = [];
+  let current = "";
+  let inString = false;
+  let quote2 = "";
+  let braceDepth = 0;
+  for (let i = 0; i < value.length; i += 1) {
+    const char = value[i];
+    if ((char === '"' || char === "'") && value[i - 1] !== "\\") {
+      if (!inString) {
+        inString = true;
+        quote2 = char;
+      } else if (quote2 === char) {
+        inString = false;
+        quote2 = "";
+      }
+    }
+    if (!inString && char === "{") braceDepth += 1;
+    if (!inString && char === "}") braceDepth -= 1;
+    if (!inString && braceDepth === 0 && char === ",") {
+      parts.push(current);
+      current = "";
+      continue;
+    }
+    current += char;
+  }
+  if (current.trim()) parts.push(current);
+  return parts;
+}
+function unquoteTomlString(value) {
+  return value.slice(1, -1).replace(/\\"/g, '"').replace(/\\n/g, "\n").replace(/\\t/g, "	").replace(/\\\\/g, "\\");
+}
 function renderMigratedAgentMarkdown(fileStem, parsed) {
   const agentName = toKebabCase2(parsed.name ?? fileStem) || "agent";
   const title = parsed.name ?? titleCaseFromDirName(agentName);
@@ -19692,6 +21280,7 @@ function renderMigratedAgentMarkdown(fileStem, parsed) {
     ...parsed.description ? [`description: ${JSON.stringify(parsed.description)}`] : [],
     ...parsed.model ? [`model: ${JSON.stringify(parsed.model)}`] : [],
     ...parsed.effort ? [`model_reasoning_effort: ${JSON.stringify(parsed.effort)}`] : [],
+    ...parsed.sandboxMode ? [`sandbox_mode: ${JSON.stringify(parsed.sandboxMode)}`] : [],
     "---",
     "",
     `# ${title}`,
@@ -19855,6 +21444,12 @@ function normalizeMigrateAuth(auth) {
   if (auth.type === "none") {
     return { type: "none" };
   }
+  if (auth.type === "platform") {
+    return {
+      type: "platform",
+      mode: auth.mode ?? "oauth"
+    };
+  }
   if (auth.type === "bearer" && auth.envVar) {
     return {
       type: "bearer",
@@ -19880,6 +21475,7 @@ function buildMigratedScaffoldMetadata(result, outputDir) {
   const generatedHookEvents = Object.keys(result.hooks);
   const managedFiles = [
     ...result.instructions ? [result.instructions.replace(/^\.\//, "")] : [],
+    ...result.extraCopyPaths.map((path) => path.replace(/^\.\//, "")),
     ...["skills", "commands", "agents", "scripts", "assets"].flatMap((dir) => {
       if (!result.sourcePaths[dir]) return [];
       const baseDir = dir;
@@ -19926,7 +21522,7 @@ function buildMigratedScaffoldMetadata(result, outputDir) {
       requestedHookMode: generatedHookEvents.length > 0 ? "safe" : "none",
       generatedHookMode: generatedHookEvents.length > 0 ? "safe" : "none",
       generatedHookEvents,
-      runtimeAuthMode: "inline"
+      runtimeAuthMode: result.runtimeAuthMode
     },
     userConfig: [],
     tools: [],
@@ -20007,6 +21603,9 @@ function generateConfigTs(result) {
   if (result.manifest.keywords && result.manifest.keywords.length > 0) {
     lines.push(`  keywords: [${result.manifest.keywords.map((k) => quote(k)).join(", ")}],`);
   }
+  if (result.manifest.brand && Object.keys(result.manifest.brand).length > 0) {
+    lines.push("  brand: " + renderIndentedTsValue(result.manifest.brand, 2) + ",");
+  }
   lines.push("");
   if (result.sourcePaths.skills) {
     lines.push(`  skills: './skills/',`);
@@ -20053,6 +21652,9 @@ function generateConfigTs(result) {
     for (const name2 of mcpNames) {
       const server = result.mcp[name2];
       lines.push(`    ${quote(name2)}: {`);
+      for (const warning of server.warnings ?? []) {
+        lines.push(`      // ${warning}`);
+      }
       if (server.url) lines.push(`      url: ${quote(server.url)},`);
       if (server.transport && server.transport !== "http") {
         lines.push(`      transport: ${quote(server.transport)},`);
@@ -20072,6 +21674,9 @@ function generateConfigTs(result) {
         lines.push("      auth: {");
         lines.push(`        type: ${quote(server.auth.type)},`);
         if (server.auth.envVar) lines.push(`        envVar: ${quote(server.auth.envVar)},`);
+        if (server.auth.mode && server.auth.type === "platform") {
+          lines.push(`        mode: ${quote(server.auth.mode)},`);
+        }
         if (server.auth.headerName && server.auth.headerName !== "Authorization") {
           lines.push(`        headerName: ${quote(server.auth.headerName)},`);
         }
@@ -20084,6 +21689,11 @@ function generateConfigTs(result) {
     }
     lines.push("  },");
   }
+  const platforms = buildMigratedPlatformOverrides(result);
+  if (platforms && Object.keys(platforms).length > 0) {
+    lines.push("");
+    lines.push("  platforms: " + renderIndentedTsValue(platforms, 2) + ",");
+  }
   const hookEvents = Object.keys(result.hooks);
   if (hookEvents.length > 0) {
     lines.push("");
@@ -20092,9 +21702,25 @@ function generateConfigTs(result) {
       const entries = result.hooks[event];
       lines.push(`    ${event}: [`);
       for (const entry of entries) {
-        const parts = [`command: ${quote(entry.command)}`];
-        if (entry.timeout) parts.push(`timeout: ${entry.timeout}`);
-        if (entry.matcher) parts.push(`matcher: ${quote(entry.matcher)}`);
+        const parts = [];
+        if (entry.type && entry.type !== "command") parts.push(`type: ${renderTsValue(entry.type)}`);
+        if (entry.command) parts.push(`command: ${renderTsValue(entry.command)}`);
+        if (entry.prompt) parts.push(`prompt: ${renderTsValue(entry.prompt)}`);
+        if (entry.model) parts.push(`model: ${renderTsValue(entry.model)}`);
+        if (entry.url) parts.push(`url: ${renderTsValue(entry.url)}`);
+        if (entry.headers) parts.push(`headers: ${renderTsValue(entry.headers)}`);
+        if (entry.allowedEnvVars) parts.push(`allowedEnvVars: ${renderTsValue(entry.allowedEnvVars)}`);
+        if (entry.server) parts.push(`server: ${renderTsValue(entry.server)}`);
+        if (entry.tool) parts.push(`tool: ${renderTsValue(entry.tool)}`);
+        if (entry.input) parts.push(`input: ${renderTsValue(entry.input)}`);
+        if (entry.if) parts.push(`if: ${renderTsValue(entry.if)}`);
+        if (entry.async !== void 0) parts.push(`async: ${renderTsValue(entry.async)}`);
+        if (entry.asyncRewake !== void 0) parts.push(`asyncRewake: ${renderTsValue(entry.asyncRewake)}`);
+        if (entry.shell) parts.push(`shell: ${renderTsValue(entry.shell)}`);
+        if (entry.timeout !== void 0) parts.push(`timeout: ${renderTsValue(entry.timeout)}`);
+        if (entry.matcher !== void 0) parts.push(`matcher: ${renderTsValue(entry.matcher)}`);
+        if (entry.failClosed !== void 0) parts.push(`failClosed: ${renderTsValue(entry.failClosed)}`);
+        if (entry.loop_limit !== void 0) parts.push(`loop_limit: ${renderTsValue(entry.loop_limit)}`);
         lines.push(`      { ${parts.join(", ")} },`);
       }
       lines.push("    ],");
@@ -20111,6 +21737,65 @@ function generateConfigTs(result) {
 function quote(s) {
   return `'${s.replace(/'/g, "\\'")}'`;
 }
+function renderTsValue(value) {
+  if (typeof value === "string") return quote(value);
+  return JSON.stringify(value);
+}
+function renderIndentedTsValue(value, indentLevel) {
+  const rendered = JSON.stringify(value, null, 2);
+  if (!rendered.includes("\n")) return rendered;
+  const indent = " ".repeat(indentLevel);
+  return rendered.split("\n").map((line, index) => index === 0 ? line : indent + line).join("\n");
+}
+function buildMigratedPlatformOverrides(result) {
+  const platforms = cloneRecordMap(result.manifest.platforms);
+  if (result.runtimeAuthMode === "platform") {
+    platforms["claude-code"] = {
+      ...platforms["claude-code"] ?? {},
+      mcpAuth: "platform"
+    };
+    platforms.cursor = {
+      ...platforms.cursor ?? {},
+      mcpAuth: "platform"
+    };
+  }
+  return mergePlatformOverrideMaps(platforms);
+}
+function cloneRecordMap(input) {
+  if (!input) return {};
+  return JSON.parse(JSON.stringify(input));
+}
+function mergePlatformOverrideMaps(...maps) {
+  const merged = {};
+  for (const map of maps) {
+    if (!map) continue;
+    for (const [platform, override] of Object.entries(map)) {
+      const current = asRecord4(merged[platform]) ?? {};
+      const next = asRecord4(override) ?? {};
+      const mergedPlatform = {
+        ...current,
+        ...next
+      };
+      const currentMcpServers = asRecord4(current.mcpServers);
+      const nextMcpServers = asRecord4(next.mcpServers);
+      if (currentMcpServers || nextMcpServers) {
+        const mergedMcpServers = {};
+        for (const [serverName, serverConfig] of Object.entries(currentMcpServers ?? {})) {
+          const currentServerConfig = asRecord4(serverConfig);
+          mergedMcpServers[serverName] = currentServerConfig ? { ...currentServerConfig } : serverConfig;
+        }
+        for (const [serverName, serverConfig] of Object.entries(nextMcpServers ?? {})) {
+          const previousServerConfig = asRecord4(mergedMcpServers[serverName]);
+          const nextServerConfig = asRecord4(serverConfig);
+          mergedMcpServers[serverName] = previousServerConfig && nextServerConfig ? { ...previousServerConfig, ...nextServerConfig } : serverConfig;
+        }
+        mergedPlatform.mcpServers = mergedMcpServers;
+      }
+      merged[platform] = mergedPlatform;
+    }
+  }
+  return Object.keys(merged).length > 0 ? merged : void 0;
+}
 async function migrate(inputPath) {
   const pluginDir = resolve21(inputPath);
   const outputDir = process.cwd();
@@ -20124,6 +21809,7 @@ async function migrate(inputPath) {
     console.error("Error: Could not detect plugin platform.");
     console.error("Expected one of:");
     console.error("  .claude-plugin/plugin.json");
+    console.error("  or a manifest-less Claude plugin with CLAUDE.md");
     console.error("  .cursor-plugin/plugin.json");
     console.error("  .codex-plugin/plugin.json");
     console.error("  package.json with @opencode-ai/plugin dependency");
@@ -20133,7 +21819,8 @@ async function migrate(inputPath) {
   const manifest = parseManifest(detection);
   console.log(`  name: ${manifest.name ?? "(none)"}`);
   console.log(`  version: ${manifest.version ?? "(none)"}`);
-  const mcp = parseMcp(pluginDir, detection);
+  const parsedMcp = parseMcp(pluginDir, detection);
+  const mcp = parsedMcp.servers;
   const mcpCount = Object.keys(mcp).length;
   if (mcpCount > 0) {
     console.log(`  mcp servers: ${Object.keys(mcp).join(", ")}`);
@@ -20143,10 +21830,32 @@ async function migrate(inputPath) {
   if (hookCount > 0) {
     console.log(`  hooks: ${Object.keys(hooks).join(", ")}`);
   }
-  const instructions = findInstructions(pluginDir);
+  const instructionSources = findInstructionSources(pluginDir, detection);
+  const instructions = instructionSources.primary;
   if (instructions) {
     console.log(`  instructions: ${instructions}`);
   }
+  if (instructionSources.platformOverrides) {
+    manifest.platforms = mergePlatformOverrideMaps(manifest.platforms, instructionSources.platformOverrides);
+  }
+  const cursorRules = parseCursorRules(pluginDir, detection);
+  const openCodeDistributionSources = findOpenCodeDistributionSources(pluginDir, detection);
+  if (cursorRules.length > 0) {
+    manifest.platforms = {
+      ...manifest.platforms ?? {},
+      cursor: {
+        ...manifest.platforms?.cursor ?? {},
+        rules: cursorRules
+      }
+    };
+    console.log(`  cursor rules: ${cursorRules.length}`);
+  }
+  if (openCodeDistributionSources.platformOverrides) {
+    manifest.platforms = mergePlatformOverrideMaps(manifest.platforms, openCodeDistributionSources.platformOverrides);
+  }
+  if (parsedMcp.platformOverrides) {
+    manifest.platforms = mergePlatformOverrideMaps(manifest.platforms, parsedMcp.platformOverrides);
+  }
   const sourcePaths = detectCanonicalSourcePaths(pluginDir);
   const passthrough = detectPassthroughDirs(pluginDir, mcp);
   const persistedSkills = readMigratedSkills(pluginDir, sourcePaths);
@@ -20165,6 +21874,7 @@ async function migrate(inputPath) {
     platform: detection.platform,
     manifest,
     mcp,
+    runtimeAuthMode: parsedMcp.runtimeAuthMode,
     hooks,
     permissions: inferredPermissions.permissions,
     permissionNotes: inferredPermissions.notes,
@@ -20172,6 +21882,11 @@ async function migrate(inputPath) {
     instructions,
     sourcePaths,
     persistedSkills,
+    warnings: parsedMcp.warnings,
+    extraCopyPaths: [.../* @__PURE__ */ new Set([
+      ...instructionSources.extraPaths,
+      ...openCodeDistributionSources.extraPaths
+    ])].sort(),
     ...inferredPermissions.skillPolicies.length > 0 ? {
       compilerIntent: {
         version: 1,
@@ -20204,6 +21919,14 @@ Generated pluxx.config.ts`);
       console.log(`Copied: ${instructions}`);
     }
   }
+  for (const copiedPath of result.extraCopyPaths) {
+    const srcPath = resolve21(pluginDir, copiedPath);
+    const destPath = resolve21(outputDir, copiedPath);
+    if (existsSync24(destPath)) continue;
+    const content = readFileSync14(srcPath, "utf-8");
+    await writeTextFile(destPath, content);
+    console.log(`Copied: ${copiedPath}`);
+  }
   const taxonomyPath = resolve21(outputDir, MCP_TAXONOMY_PATH);
   const metadataPath = resolve21(outputDir, MCP_SCAFFOLD_METADATA_PATH);
   mkdirSync5(resolve21(outputDir, ".pluxx"), { recursive: true });
@@ -20234,7 +21957,7 @@ Generated pluxx.config.ts`);
 
 // src/cli/mcp-proxy.ts
 import { mkdirSync as mkdirSync6, readFileSync as readFileSync15 } from "fs";
-import { dirname as dirname8, resolve as resolve22 } from "path";
+import { dirname as dirname9, resolve as resolve22 } from "path";
 import * as readline3 from "readline";
 function usage() {
   return [
@@ -20311,7 +22034,7 @@ async function loadReplayTape(filepath) {
 }
 async function writeTape(filepath, tape) {
   const absolutePath = resolve22(process.cwd(), filepath);
-  mkdirSync6(dirname8(absolutePath), { recursive: true });
+  mkdirSync6(dirname9(absolutePath), { recursive: true });
   await writeTextFile(absolutePath, `${JSON.stringify(tape, null, 2)}
 `);
 }
@@ -21488,17 +23211,17 @@ ${c2}
 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";
+import { spawn as spawn5, spawnSync as spawnSync4 } from "child_process";
 
 // src/cli/publish.ts
 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 resolve23 } from "path";
-import { spawnSync as spawnSync2 } from "child_process";
+import { spawnSync as spawnSync3 } from "child_process";
 import { tmpdir as tmpdir3 } from "os";
 var INSTALLER_TARGETS = ["claude-code", "cursor", "codex", "opencode"];
 function runCommandDefault2(command2, args2, options) {
-  const result = spawnSync2(command2, args2, {
+  const result = spawnSync3(command2, args2, {
     cwd: options?.cwd,
     encoding: "utf-8"
   });
@@ -22873,7 +24596,14 @@ async function runBehavioralSuite(rootDir, config, targets, options = {}) {
     for (const platform of selectedPlatforms) {
       const targetConfig = behavioralCase.targets[platform];
       if (!targetConfig) continue;
-      checks.push(await runBehavioralCheck(rootDir, config, behavioralCase.name, platform, targetConfig));
+      checks.push(await runBehavioralCheck(
+        rootDir,
+        config,
+        behavioralCase.name,
+        behavioralCase.commandId,
+        platform,
+        targetConfig
+      ));
     }
   }
   return {
@@ -22903,17 +24633,31 @@ function loadBehavioralCases(rootDir, targets, promptOverride) {
   }
   return parsed.cases;
 }
-async function runBehavioralCheck(rootDir, config, caseName, platform, targetConfig) {
+async function runBehavioralCheck(rootDir, config, caseName, caseCommandId, platform, targetConfig) {
   const prompt = targetConfig.prompt.trim();
   if (!prompt) {
     throw new Error(`Behavioral smoke case "${caseName}" for ${platform} is missing a prompt.`);
   }
-  const command2 = await buildBehavioralCommand(platform, prompt, rootDir);
+  const commandId = targetConfig.commandId ?? caseCommandId;
+  if (commandId) {
+    if (!behavioralPromptReferencesCommand(prompt, commandId)) {
+      throw new Error(
+        `Behavioral smoke case "${caseName}" for ${platform} declares commandId "${commandId}" but the prompt does not reference that command explicitly.`
+      );
+    }
+    if (!targetConfig.require?.length) {
+      throw new Error(
+        `Behavioral smoke case "${caseName}" for ${platform} declares commandId "${commandId}" but does not define any required output markers.`
+      );
+    }
+  }
+  const expectedExitCodes = targetConfig.expectedExitCodes?.length ? [...new Set(targetConfig.expectedExitCodes)] : targetConfig.expectFailure ? [1] : [0];
+  const command2 = await buildBehavioralCommand(platform, prompt, rootDir, targetConfig);
   const execution = await executeBehavioralCommand(platform, command2, rootDir);
   const responseText = execution.response.trim();
   const failures = [];
-  if (execution.exitCode !== 0) {
-    failures.push(`runner exited with code ${execution.exitCode}`);
+  if (!expectedExitCodes.includes(execution.exitCode)) {
+    failures.push(`runner exited with code ${execution.exitCode}; expected one of ${expectedExitCodes.join(", ")}`);
   }
   if (!responseText) {
     failures.push("runner returned no response text");
@@ -22932,6 +24676,7 @@ async function runBehavioralCheck(rootDir, config, caseName, platform, targetCon
     caseName,
     platform,
     prompt,
+    commandId,
     command: command2,
     ok: failures.length === 0,
     exitCode: execution.exitCode,
@@ -22939,10 +24684,12 @@ async function runBehavioralCheck(rootDir, config, caseName, platform, targetCon
     responsePreview: truncate2(responseText, 220),
     require: targetConfig.require,
     forbid: targetConfig.forbid,
+    expectedExitCodes,
     failures
   };
 }
-async function buildBehavioralCommand(platform, prompt, workspace) {
+async function buildBehavioralCommand(platform, prompt, workspace, targetConfig) {
+  const runnerArgs = targetConfig.runnerArgs ?? [];
   if (platform === "claude-code") {
     return [
       "claude",
@@ -22951,6 +24698,7 @@ async function buildBehavioralCommand(platform, prompt, workspace) {
       "text",
       "--permission-mode",
       "acceptEdits",
+      ...runnerArgs,
       "-p",
       prompt
     ];
@@ -22968,6 +24716,7 @@ async function buildBehavioralCommand(platform, prompt, workspace) {
       "--workspace",
       workspace,
       "--force",
+      ...runnerArgs,
       prompt
     ];
   }
@@ -22978,10 +24727,11 @@ async function buildBehavioralCommand(platform, prompt, workspace) {
       "--ephemeral",
       "--skip-git-repo-check",
       "--full-auto",
+      ...runnerArgs,
       prompt
     ];
   }
-  return ["opencode", "run", prompt];
+  return ["opencode", "run", ...runnerArgs, prompt];
 }
 async function executeBehavioralCommand(platform, command2, cwd) {
   let codexOutputDir = null;
@@ -23064,6 +24814,12 @@ function truncate2(value, length) {
 function includesNeedle(haystack, needle) {
   return haystack.toLowerCase().includes(needle.trim().toLowerCase());
 }
+function behavioralPromptReferencesCommand(prompt, commandId) {
+  const normalizedPrompt = prompt.toLowerCase();
+  const normalizedCommandId = commandId.trim().toLowerCase();
+  if (!normalizedCommandId) return false;
+  return normalizedPrompt.includes(`/${normalizedCommandId}`) || normalizedPrompt.includes(`:${normalizedCommandId}`) || normalizedPrompt.includes(`command ${normalizedCommandId}`) || normalizedPrompt.includes(`command \`${normalizedCommandId}\``) || normalizedPrompt.includes(normalizedCommandId);
+}
 function shellQuote2(value) {
   if (/^[A-Za-z0-9_./:-]+$/.test(value)) return value;
   return `'${value.replace(/'/g, `'\\''`)}'`;
@@ -23082,7 +24838,7 @@ function discoverInstalledMcpServers(options = {}) {
   const seen = /* @__PURE__ */ new Set();
   for (const candidate of installedMcpFileCandidates(rootDir, homeDir)) {
     if (!hostSet.has(candidate.host) || !existsSync28(candidate.path)) continue;
-    const parsed = candidate.parser === "json" ? parseJsonMcpFile(candidate.path, candidate.host) : parseCodexTomlMcpFile(candidate.path);
+    const parsed = candidate.parser === "json" ? parseJsonMcpFile2(candidate.path, candidate.host) : parseCodexTomlMcpFile(candidate.path);
     for (const discovered of parsed) {
       const key = `${discovered.host}:${discovered.serverName}:${discovered.sourcePath}`;
       if (seen.has(key)) continue;
@@ -23162,20 +24918,21 @@ function installedMcpFileCandidates(rootDir, homeDir) {
     { host: "opencode", path: resolve26(homeDir, ".config/opencode/opencode.json"), parser: "json" }
   ];
 }
-function parseJsonMcpFile(path, host) {
+function parseJsonMcpFile2(path, host) {
   try {
     const raw = JSON.parse(readFileSync19(path, "utf-8"));
-    const servers = extractJsonMcpServers(raw, path, host);
+    const servers = extractJsonMcpServers2(raw, path, host);
     return Object.entries(servers).flatMap(([serverName, config]) => {
       const normalized = normalizeCommonMcpServer(config, host);
       if (!normalized) return [];
-      return [toDiscovered(host, serverName, path, normalized.server, normalized.warnings)];
+      const platformOverrides = buildNativeMcpPlatformOverrides(host, { [serverName]: config });
+      return [toDiscovered(host, serverName, path, normalized.server, normalized.warnings, platformOverrides)];
     });
   } catch {
     return [];
   }
 }
-function extractJsonMcpServers(raw, path, host) {
+function extractJsonMcpServers2(raw, path, host) {
   if (host === "opencode" && raw.mcp && typeof raw.mcp === "object") {
     return raw.mcp;
   }
@@ -23204,7 +24961,7 @@ function parseCodexTomlMcpFile(path) {
   let currentServer;
   let currentSubtable;
   for (const rawLine of text.split(/\r?\n/)) {
-    const line = stripTomlComment(rawLine).trim();
+    const line = stripTomlComment2(rawLine).trim();
     if (!line) continue;
     const section = line.match(/^\[mcp_servers\.([A-Za-z0-9_.-]+)(?:\.([A-Za-z0-9_.-]+))?\]$/);
     if (section) {
@@ -23223,7 +24980,7 @@ function parseCodexTomlMcpFile(path) {
     const assignment = line.match(/^([A-Za-z0-9_-]+)\s*=\s*(.+)$/);
     if (!assignment) continue;
     const key = assignment[1];
-    const value = parseTomlValue(assignment[2].trim());
+    const value = parseTomlValue2(assignment[2].trim());
     if (currentSubtable) {
       const table = servers[currentServer][currentSubtable];
       table[key] = value;
@@ -23234,7 +24991,8 @@ function parseCodexTomlMcpFile(path) {
   return Object.entries(servers).flatMap(([serverName, config]) => {
     const normalized = normalizeCommonMcpServer(config, "codex");
     if (!normalized) return [];
-    return [toDiscovered("codex", serverName, path, normalized.server, normalized.warnings)];
+    const platformOverrides = buildNativeMcpPlatformOverrides("codex", { [serverName]: config });
+    return [toDiscovered("codex", serverName, path, normalized.server, normalized.warnings, platformOverrides)];
   });
 }
 function normalizeCommonMcpServer(config, host) {
@@ -23242,7 +25000,7 @@ function normalizeCommonMcpServer(config, host) {
   const cfg = config;
   const warnings = [];
   const auth = inferAuth(cfg, warnings);
-  const remoteUrl = firstString(cfg.url, cfg.endpoint);
+  const remoteUrl = firstString3(cfg.url, cfg.endpoint);
   if (remoteUrl) {
     const server = cfg.type === "sse" || cfg.transport === "sse" ? {
       transport: "sse",
@@ -23281,9 +25039,9 @@ function normalizeArgs(command2, args2, host) {
   if (host === "opencode" && Array.isArray(command2)) {
     return command2.slice(1).map(String);
   }
-  return normalizeStringArray(args2);
+  return normalizeStringArray2(args2);
 }
-function normalizeStringArray(value) {
+function normalizeStringArray2(value) {
   if (!Array.isArray(value)) return [];
   return value.map(String);
 }
@@ -23307,7 +25065,7 @@ function normalizeEnv(value, warnings) {
   return env;
 }
 function inferAuth(cfg, warnings) {
-  const bearerTokenEnv = firstString(cfg.bearer_token_env_var, cfg.bearerTokenEnvVar);
+  const bearerTokenEnv = firstString3(cfg.bearer_token_env_var, cfg.bearerTokenEnvVar);
   if (bearerTokenEnv) {
     return {
       type: "bearer",
@@ -23333,13 +25091,13 @@ function inferAuth(cfg, warnings) {
   const headerEntries = Object.entries(headers);
   for (const [headerName, rawValue] of headerEntries) {
     if (typeof rawValue !== "string") continue;
-    const envVar = extractEnvVar(rawValue);
+    const envVar = extractEnvVar3(rawValue);
     if (envVar) {
       return {
         type: headerName.toLowerCase() === "authorization" ? "bearer" : "header",
         envVar,
         headerName,
-        headerTemplate: rawValue.replace(envReferencePattern(envVar), "${value}")
+        headerTemplate: rawValue.replace(envReferencePattern2(envVar), "${value}")
       };
     }
     if (looksSecretValue(rawValue)) {
@@ -23348,43 +25106,44 @@ function inferAuth(cfg, warnings) {
   }
   return void 0;
 }
-function toDiscovered(host, serverName, sourcePath, server, warnings) {
+function toDiscovered(host, serverName, sourcePath, server, warnings, platformOverrides) {
   return {
     id: `${host}:${serverName}`,
     host,
     serverName,
     sourcePath,
     server,
-    warnings
+    warnings,
+    ...platformOverrides ? { platformOverrides } : {}
   };
 }
-function firstString(...values) {
+function firstString3(...values) {
   for (const value of values) {
     if (typeof value === "string" && value.trim()) return value.trim();
   }
   return void 0;
 }
 function envPlaceholder(value) {
-  const envVar = extractEnvVar(value);
+  const envVar = extractEnvVar3(value);
   return envVar ? `\${${envVar}}` : void 0;
 }
-function extractEnvVar(value) {
+function extractEnvVar3(value) {
   const match = value.match(/\$\{(?:env:)?([A-Za-z_][A-Za-z0-9_]*)\}|\$([A-Za-z_][A-Za-z0-9_]*)/);
   return match?.[1] ?? match?.[2];
 }
-function envReferencePattern(envVar) {
-  return new RegExp(`\\$\\{(?:env:)?${escapeRegExp2(envVar)}\\}|\\$${escapeRegExp2(envVar)}`);
+function envReferencePattern2(envVar) {
+  return new RegExp(`\\$\\{(?:env:)?${escapeRegExp3(envVar)}\\}|\\$${escapeRegExp3(envVar)}`);
 }
-function escapeRegExp2(value) {
+function escapeRegExp3(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 function looksSecretKey(value) {
   return /(api|auth|secret|token|key|password|credential)/i.test(value);
 }
 function looksSecretValue(value) {
-  return value.length >= 16 && !extractEnvVar(value);
+  return value.length >= 16 && !extractEnvVar3(value);
 }
-function stripTomlComment(line) {
+function stripTomlComment2(line) {
   let inString = false;
   let quote2 = "";
   for (let i = 0; i < line.length; i += 1) {
@@ -23403,22 +25162,22 @@ function stripTomlComment(line) {
   }
   return line;
 }
-function parseTomlValue(value) {
-  if (value.startsWith('"') && value.endsWith('"')) return unquoteTomlString(value);
+function parseTomlValue2(value) {
+  if (value.startsWith('"') && value.endsWith('"')) return unquoteTomlString2(value);
   if (value.startsWith("'") && value.endsWith("'")) return value.slice(1, -1);
   if (value.startsWith("[") && value.endsWith("]")) {
     const inner = value.slice(1, -1).trim();
     if (!inner) return [];
-    return splitTomlList(inner).map((part) => parseTomlValue(part.trim()));
+    return splitTomlList2(inner).map((part) => parseTomlValue2(part.trim()));
   }
   if (value.startsWith("{") && value.endsWith("}")) {
     const inner = value.slice(1, -1).trim();
     const result = {};
     if (!inner) return result;
-    for (const part of splitTomlList(inner)) {
+    for (const part of splitTomlList2(inner)) {
       const assignment = part.match(/^([A-Za-z0-9_-]+)\s*=\s*(.+)$/);
       if (!assignment) continue;
-      result[assignment[1]] = parseTomlValue(assignment[2].trim());
+      result[assignment[1]] = parseTomlValue2(assignment[2].trim());
     }
     return result;
   }
@@ -23426,7 +25185,7 @@ function parseTomlValue(value) {
   if (value === "false") return false;
   return value;
 }
-function splitTomlList(value) {
+function splitTomlList2(value) {
   const parts = [];
   let current = "";
   let inString = false;
@@ -23455,7 +25214,7 @@ function splitTomlList(value) {
   if (current.trim()) parts.push(current);
   return parts;
 }
-function unquoteTomlString(value) {
+function unquoteTomlString2(value) {
   return value.slice(1, -1).replace(/\\"/g, '"').replace(/\\n/g, "\n").replace(/\\t/g, "	").replace(/\\\\/g, "\\");
 }
 
@@ -23616,7 +25375,7 @@ async function runUpgradeCommand() {
     }
     return;
   }
-  const install = spawnSync3(summary.command[0], summary.command.slice(1), runtime.jsonOutput ? {
+  const install = spawnSync4(summary.command[0], summary.command.slice(1), runtime.jsonOutput ? {
     env: process.env,
     encoding: "utf-8",
     stdio: "pipe"
@@ -24686,7 +26445,8 @@ ${formatAuthRequiredMessage("init", retryError, source)}`);
         setupHints: sourcedContextPack.docsContext.setupHints,
         authHints: sourcedContextPack.docsContext.authHints,
         warnings: sourcedContextPack.docsContext.warnings
-      } : void 0
+      } : void 0,
+      platformOverrides: installedMcpSource?.platformOverrides
     });
     const createdFiles = plan.files.filter((file) => file.action === "create").map((file) => file.relativePath);
     const updatedFiles = plan.files.filter((file) => file.action === "update").map((file) => file.relativePath);