@orchid-labs/pluxx 0.1.20 → 0.1.22

package/dist/cli/index.js

@@ -5170,12 +5170,39 @@ function buildUserConfigEnvMap(entries) {
   }
   return env;
 }
-function buildUserConfigValueMap(entries) {
+function buildInstalledUserConfigPayload(entries, options = {}) {
+  const preserveSecretReferences = options.preserveSecretReferences === true;
   const values = {};
+  const env = {};
+  const envRefs = {};
+  const secretKeys = /* @__PURE__ */ new Set();
+  const secretEnv = /* @__PURE__ */ new Set();
+  let hasSecret = false;
   for (const entry of entries) {
+    const envVar = entry.envVar;
+    const isSecret = entry.field.type === "secret";
+    if (isSecret) {
+      hasSecret = true;
+      if (preserveSecretReferences) {
+        secretKeys.add(entry.field.key);
+        if (envVar) secretEnv.add(envVar);
+      }
+    }
+    if (preserveSecretReferences && isSecret) {
+      if (envVar) envRefs[envVar] = envVar;
+      continue;
+    }
     values[entry.field.key] = entry.value;
+    if (envVar) env[envVar] = String(entry.value);
   }
-  return values;
+  return {
+    ...Object.keys(values).length > 0 ? { values } : {},
+    ...Object.keys(env).length > 0 ? { env } : {},
+    ...Object.keys(envRefs).length > 0 ? { envRefs } : {},
+    ...hasSecret ? { secretStorage: preserveSecretReferences ? "env-ref" : "materialized" } : {},
+    ...preserveSecretReferences && secretKeys.size > 0 ? { secretKeys: [...secretKeys].sort() } : {},
+    ...preserveSecretReferences && secretEnv.size > 0 ? { secretEnv: [...secretEnv].sort() } : {}
+  };
 }
 
 // src/mcp-native-overrides.ts
@@ -5386,9 +5413,9 @@ var Generator = class {
     for (const configPath of this.config.passthrough ?? []) {
       const src = this.resolveConfigPath(configPath, "passthrough");
       if (!existsSync4(src)) continue;
-      const basename10 = src.split("/").filter(Boolean).pop();
-      if (!basename10) continue;
-      this.copyDir(configPath, `${basename10}/`, "passthrough");
+      const basename11 = src.split("/").filter(Boolean).pop();
+      if (!basename11) continue;
+      this.copyDir(configPath, `${basename11}/`, "passthrough");
     }
   }
   /** Build canonical MCP server configs for target-specific output shaping. */
@@ -5494,6 +5521,18 @@ var CURSOR_SUPPORTED_HOOK_EVENTS = [
   "beforeTabFileRead",
   "afterTabFileEdit"
 ];
+var CODEX_SUPPORTED_HOOK_EVENTS = [
+  "SessionStart",
+  "SubagentStart",
+  "PreToolUse",
+  "PermissionRequest",
+  "PostToolUse",
+  "PreCompact",
+  "PostCompact",
+  "UserPromptSubmit",
+  "SubagentStop",
+  "Stop"
+];
 var PASCAL_CASE_HOOK_ALIASES = {
   beforeSubmitPrompt: "UserPromptSubmit"
 };
@@ -5540,8 +5579,8 @@ 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.",
+    supportedEvents: CODEX_SUPPORTED_HOOK_EVENTS,
+    unsupportedEventReason: `Codex currently documents only ${CODEX_SUPPORTED_HOOK_EVENTS.join(", ")} for hook configuration.`,
     fields: {
       prompt: { mode: "drop" },
       matcher: {
@@ -5838,8 +5877,16 @@ function loadUserEnv(pluginRoot) {
     const env = parsed && typeof parsed === "object" && parsed.env && typeof parsed.env === "object"
       ? parsed.env
       : {}
+    const envRefs = parsed && typeof parsed === "object" && parsed.envRefs && typeof parsed.envRefs === "object"
+      ? parsed.envRefs
+      : {}
     return Object.fromEntries(
-      Object.entries(env).filter(([key]) => /^[A-Za-z_][A-Za-z0-9_]*$/.test(key)),
+      [
+        ...Object.entries(env),
+        ...Object.entries(envRefs)
+          .filter(([, value]) => typeof value === "string" && value in process.env)
+          .map(([key, value]) => [key, process.env[value]]),
+      ].filter(([key, value]) => /^[A-Za-z_][A-Za-z0-9_]*$/.test(key) && typeof value === "string"),
     )
   } catch {
     return {}
@@ -6077,7 +6124,7 @@ function getEnabledRuntimeReadinessBindings(capability, plan) {
   });
 }
 var NAMED_PROMPT_TARGET_NOTE = "Named `skills` / `commands` readiness targets currently translate through prompt-entry gating with best-effort matching because the core four do not share one exact per-skill or per-command runtime interception surface.";
-var CODEX_EXTERNAL_NOTE = "Codex readiness now bundles translated hooks in the plugin, and Pluxx still emits `.codex/readiness.generated.json` plus `.codex/hooks.generated.json` as debugging companions because plugin-bundled hook activation still depends on `[features].plugin_hooks = true`. The general `hooks = true` flag covers non-plugin hook config and defaults on, while `codex_hooks` is deprecated and should not be treated as a plugin-bundled hook fallback.";
+var CODEX_EXTERNAL_NOTE = "Codex readiness now bundles translated hooks in the plugin, and Pluxx still emits `.codex/readiness.generated.json` plus `.codex/hooks.generated.json` as debugging companions because hook activation still depends on `[features].hooks = true`, enabled plugin state, review, trust, and runtime support. `codex_hooks` is deprecated and should not be treated as the current hook feature key.";
 function getRuntimeReadinessNamedPromptTargetNote() {
   return NAMED_PROMPT_TARGET_NOTE;
 }
@@ -6151,18 +6198,18 @@ function getRuntimeReadinessCapability(platform, pluginRootVar = "PLUGIN_ROOT")
           {
             gate: "session-start",
             event: "SessionStart",
-            command: "node ./.codex/pluxx-readiness.mjs session-start"
+            command: `node "\${${pluginRootVar}}/.codex/pluxx-readiness.mjs" session-start`
           },
           {
             gate: "mcp-gate",
             event: "PreToolUse",
             matcher: "MCP",
-            command: "node ./.codex/pluxx-readiness.mjs mcp-gate"
+            command: `node "\${${pluginRootVar}}/.codex/pluxx-readiness.mjs" mcp-gate`
           },
           {
             gate: "prompt-gate",
             event: "UserPromptSubmit",
-            command: "node ./.codex/pluxx-readiness.mjs prompt-gate"
+            command: `node "\${${pluginRootVar}}/.codex/pluxx-readiness.mjs" prompt-gate`
           }
         ],
         notes: CODEX_EXTERNAL_NOTE
@@ -6378,6 +6425,9 @@ function shellSingleQuote(value) {
   return `'${value.replace(/'/g, `'"'"'`)}'`;
 }
 function buildHookCommandWrapperScript(command2, pluginRootVar, envFileVar) {
+  if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(pluginRootVar)) {
+    throw new Error(`Invalid plugin root environment variable name: ${pluginRootVar}`);
+  }
   const serializedCommand = shellSingleQuote(command2);
   const exportLoader = [
     'import { readFileSync } from "node:fs"',
@@ -6390,10 +6440,19 @@ function buildHookCommandWrapperScript(command2, pluginRootVar, envFileVar) {
     'const env = payload && typeof payload === "object" && payload.env && typeof payload.env === "object"',
     "  ? payload.env",
     "  : {}",
+    'const envRefs = payload && typeof payload === "object" && payload.envRefs && typeof payload.envRefs === "object"',
+    "  ? payload.envRefs",
+    "  : {}",
     "",
     "for (const [key, value] of Object.entries(env)) {",
     "  if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key)) continue",
     "  process.stdout.write(`export ${key}=${shellSingleQuote(value)}\\0`)",
+    "}",
+    "for (const [key, envVar] of Object.entries(envRefs)) {",
+    "  if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key)) continue",
+    '  if (typeof envVar !== "string" || !/^[A-Za-z_][A-Za-z0-9_]*$/.test(envVar)) continue',
+    "  if (!(envVar in process.env)) continue",
+    "  process.stdout.write(`export ${key}=${shellSingleQuote(process.env[envVar])}\\0`)",
     "}"
   ].join("\n");
   const maybeAppendEnvFile = envFileVar ? [
@@ -6406,6 +6465,8 @@ function buildHookCommandWrapperScript(command2, pluginRootVar, envFileVar) {
     "set -euo pipefail",
     "",
     `PLUXX_PLUGIN_ROOT="\${${pluginRootVar}:-$(cd "$(dirname "$0")/.." && pwd)}"`,
+    `export ${pluginRootVar}="$PLUXX_PLUGIN_ROOT"`,
+    'export PLUGIN_ROOT="$PLUXX_PLUGIN_ROOT"',
     'PLUXX_USER_CONFIG_PATH="$PLUXX_PLUGIN_ROOT/.pluxx-user.json"',
     "",
     'if [ -f "$PLUXX_USER_CONFIG_PATH" ]; then',
@@ -9870,7 +9931,7 @@ function toQuotedTomlKey(value) {
 // src/codex-hooks-feature.ts
 var RECOMMENDED_CODEX_HOOKS_FEATURE_FLAG = "hooks";
 var ALTERNATE_CODEX_HOOKS_FEATURE_FLAG = "codex_hooks";
-var PLUGIN_BUNDLED_CODEX_HOOKS_FEATURE_FLAG = "plugin_hooks";
+var PLUGIN_BUNDLED_CODEX_HOOKS_FEATURE_FLAG = "hooks";
 function getCodexHooksFeatureState(features) {
   if (!features) {
     return {
@@ -10145,7 +10206,7 @@ var CodexGenerator = class extends Generator {
   }
   async generateHooksCompanion() {
     const readinessPlan = getRuntimeReadinessPlan(this.config.readiness);
-    const readinessCapability = getRuntimeReadinessCapability("codex");
+    const readinessCapability = getRuntimeReadinessCapability("codex", "CODEX_PLUGIN_ROOT");
     if (!this.config.hooks && !readinessPlan.hasReadiness) return;
     const hooks = {};
     const unsupported = [];
@@ -10193,12 +10254,12 @@ var CodexGenerator = class extends Generator {
         const relativePath = `hooks/pluxx-hook-command-${nextWrapperIndex}.sh`;
         await this.writeFile(
           relativePath,
-          buildHookCommandWrapperScript(entry.command.replace("${PLUGIN_ROOT}", "."), "CODEX_PLUGIN_ROOT")
+          buildHookCommandWrapperScript(entry.command.replace("${PLUGIN_ROOT}", "${PLUXX_PLUGIN_ROOT}"), "CODEX_PLUGIN_ROOT")
         );
         const matcher = typeof entry.matcher === "string" && isHookFieldPreserved("codex", "matcher", codexEvent) ? entry.matcher : void 0;
         mappedEntries.push(this.buildCodexCommandHookGroup(
           codexEvent,
-          `bash ./${relativePath}`,
+          `bash "\${CODEX_PLUGIN_ROOT}/${relativePath}"`,
           matcher,
           entry.timeout
         ));
@@ -10220,14 +10281,14 @@ var CodexGenerator = class extends Generator {
       pluginBundleFeatureFlag: PLUGIN_BUNDLED_CODEX_HOOKS_FEATURE_FLAG,
       generalFeatureFlag: RECOMMENDED_CODEX_HOOKS_FEATURE_FLAG,
       deprecatedGeneralFeatureFlag: ALTERNATE_CODEX_HOOKS_FEATURE_FLAG,
-      note: "Codex plugin-bundled hook configuration is bundled at hooks/hooks.json in the plugin and currently requires `[features].plugin_hooks = true`. The general `[features].hooks` flag covers non-plugin hook config and defaults on, while `codex_hooks` is deprecated and should not be treated as a plugin-bundled hook fallback. This companion mirror preserves the translated native event names, matcher groups, and command handlers while highlighting any dropped events or fields.",
+      note: "Codex plugin-bundled hook configuration is bundled at hooks/hooks.json in the plugin and currently requires `[features].hooks = true`, enabled plugin state, review, trust, and runtime support. `codex_hooks` is deprecated and should not be treated as the current hook feature key. This companion mirror preserves the translated native event names, matcher groups, and command handlers while highlighting any dropped events or fields.",
       hooks,
       ...unsupported.length > 0 ? { unsupported } : {}
     });
   }
   async generateReadinessCompanion() {
     const readinessPlan = getRuntimeReadinessPlan(this.config.readiness);
-    const readinessCapability = getRuntimeReadinessCapability("codex");
+    const readinessCapability = getRuntimeReadinessCapability("codex", "CODEX_PLUGIN_ROOT");
     if (!readinessPlan.hasReadiness || !this.config.readiness) return;
     const translatedHooks = Object.fromEntries(
       getEnabledRuntimeReadinessBindings(readinessCapability, readinessPlan).map((binding) => [
@@ -10429,7 +10490,7 @@ var OpenCodeGenerator = class extends Generator {
       `const isMcpTool = (tool: string): boolean =>`,
       `  tool === "mcp" || tool.startsWith("mcp.") || tool.startsWith("mcp_")`,
       "",
-      `const loadUserConfig = (directory: string): { values?: Record<string, string | number | boolean>; env?: Record<string, string> } => {`,
+      `const loadUserConfig = (directory: string): { values?: Record<string, string | number | boolean>; env?: Record<string, string>; envRefs?: Record<string, string> } => {`,
       `  const filepath = resolve(directory, ".pluxx-user.json")`,
       `  if (!existsSync(filepath)) return {}`,
       `  try {`,
@@ -10439,28 +10500,30 @@ var OpenCodeGenerator = class extends Generator {
       `  }`,
       `}`,
       "",
-      `const resolveRuntimeValue = (name: string, userEnv: Record<string, string>): string | undefined =>`,
-      `  userEnv[name] ?? process.env[name]`,
+      `const resolveRuntimeValue = (name: string, userEnv: Record<string, string>, userEnvRefs: Record<string, string>): string | undefined =>`,
+      `  userEnv[name] ?? (userEnvRefs[name] ? process.env[userEnvRefs[name]] : undefined) ?? process.env[name]`,
       "",
-      `const materializeEnv = (input: Record<string, string> | undefined, userEnv: Record<string, string>): Record<string, string> | undefined => {`,
+      `const materializeEnv = (input: Record<string, string> | undefined, userEnv: Record<string, string>, userEnvRefs: Record<string, string>): Record<string, string> | undefined => {`,
       `  if (!input) return undefined`,
       `  const output: Record<string, string> = {}`,
       `  for (const [key, value] of Object.entries(input)) {`,
-      `    output[key] = value.replace(/\\$\\{([A-Za-z_][A-Za-z0-9_]*)\\}/g, (_match, name) => resolveRuntimeValue(name, userEnv) ?? \`\\\${\${name}}\`)`,
+      `    output[key] = value.replace(/\\$\\{([A-Za-z_][A-Za-z0-9_]*)\\}/g, (_match, name) => resolveRuntimeValue(name, userEnv, userEnvRefs) ?? \`\\\${\${name}}\`)`,
       `  }`,
       `  return output`,
       `}`,
       "",
       `const buildMcpConfig = (directory: string): NonNullable<Config["mcp"]> => {`,
       `  const config: NonNullable<Config["mcp"]> = {}`,
-      `  const userEnv = loadUserConfig(directory).env ?? {}`,
+      `  const userConfig = loadUserConfig(directory)`,
+      `  const userEnv = userConfig.env ?? {}`,
+      `  const userEnvRefs = userConfig.envRefs ?? {}`,
       "",
       `  for (const [name, definition] of Object.entries(MCP_DEFINITIONS)) {`,
       `    if (definition.transport === "stdio" && definition.command) {`,
       `      config[name] = {`,
       `        type: "local",`,
       `        command: [definition.command, ...(definition.args ?? [])],`,
-      `        ...(definition.env ? { environment: materializeEnv(definition.env, userEnv) } : {}),`,
+      `        ...(definition.env ? { environment: materializeEnv(definition.env, userEnv, userEnvRefs) } : {}),`,
       `      }`,
       `      continue`,
       `    }`,
@@ -10477,12 +10540,12 @@ var OpenCodeGenerator = class extends Generator {
       `    }`,
       "",
       `    if (definition.auth?.type === "bearer" && definition.auth.envVar) {`,
-      `      const token = resolveRuntimeValue(definition.auth.envVar, userEnv)`,
+      `      const token = resolveRuntimeValue(definition.auth.envVar, userEnv, userEnvRefs)`,
       `      if (token) remote.headers = { Authorization: \`Bearer \${token}\` }`,
       `    }`,
       "",
       `    if (definition.auth?.type === "header" && definition.auth.envVar && definition.auth.headerName && definition.auth.headerTemplate) {`,
-      `      const value = resolveRuntimeValue(definition.auth.envVar, userEnv)`,
+      `      const value = resolveRuntimeValue(definition.auth.envVar, userEnv, userEnvRefs)`,
       `      if (value) {`,
       `        remote.headers = {`,
       `          ...(remote.headers ?? {}),`,
@@ -10512,10 +10575,15 @@ var OpenCodeGenerator = class extends Generator {
       `  const shellSingleQuote = (input: string): string => \`'\${String(input ?? "").replace(/'/g, \`'"'"'\`)}'\``,
       "",
       `  const buildHookShellCommand = (rawCommand: string): string => {`,
-      `    const userEnv = loadUserConfig(directory).env ?? {}`,
+      `    const userConfig = loadUserConfig(directory)`,
+      `    const userEnv = userConfig.env ?? {}`,
+      `    const userEnvRefs = userConfig.envRefs ?? {}`,
       `    const exports = Object.entries(userEnv)`,
       `      .filter(([key]) => /^[A-Za-z_][A-Za-z0-9_]*$/.test(key))`,
       `      .map(([key, value]) => \`export \${key}=\${shellSingleQuote(String(value))}\`)`,
+      `      .concat(Object.entries(userEnvRefs)`,
+      `        .filter(([key, envVar]) => /^[A-Za-z_][A-Za-z0-9_]*$/.test(key) && typeof envVar === "string" && envVar in process.env)`,
+      `        .map(([key, envVar]) => \`export \${key}=\${shellSingleQuote(String(process.env[envVar]))}\`))`,
       `      .join("; ")`,
       `    const command = rawCommand.replaceAll("\${PLUGIN_ROOT}", directory)`,
       `    return exports ? \`\${exports}; \${command}\` : command`,
@@ -11313,6 +11381,7 @@ import { existsSync as existsSync18, lstatSync as lstatSync2, readdirSync as rea
 import { resolve as resolve14, relative as relative8, basename as basename5, dirname as dirname4 } from "path";
 
 // src/validation/platform-rules.ts
+var CORE_FOUR_PLATFORMS = ["claude-code", "cursor", "codex", "opencode"];
 var STANDARD_SKILL_FRONTMATTER = [
   "name",
   "description",
@@ -11441,7 +11510,7 @@ var PLATFORM_LIMIT_POLICIES = {
     },
     hooksFeatureFlag: {
       kind: "hard",
-      notes: "Hook support depends on the Codex hooks feature flag/runtime support."
+      notes: "Codex hook support depends on the canonical hooks feature flag plus enabled-plugin, trust/review, and runtime support."
     }
   },
   "cursor": {
@@ -11641,8 +11710,8 @@ var PLATFORM_VALIDATION_RULES = {
     hooks: {
       supported: true,
       files: ["hooks/hooks.json", ".codex/hooks.json", "~/.codex/hooks.json"],
-      eventNames: ["SessionStart", "PreToolUse", "PermissionRequest", "PostToolUse", "UserPromptSubmit", "Stop"],
-      notes: "Codex documents both project or user hook config and plugin-bundled hooks. Plugin-bundled hooks live at `hooks/hooks.json` in the plugin and require `[features].plugin_hooks = true`; the general `[features].hooks = true` flag covers non-plugin hook config and defaults on. `codex_hooks` is deprecated and should not be treated as a plugin-bundled hook fallback."
+      eventNames: [...CODEX_SUPPORTED_HOOK_EVENTS],
+      notes: "Codex documents both project/user hook config and plugin-bundled hooks. Plugin-bundled hooks live at `hooks/hooks.json` in the plugin and require the canonical `[features].hooks = true` flag, enabled plugin state, user review, trust, and runtime support. `codex_hooks` is deprecated and should not be treated as the current hook feature key."
     },
     instructions: {
       files: ["AGENTS.md", "AGENTS.override.md"],
@@ -12081,7 +12150,7 @@ var CORE_FOUR_PRIMITIVE_CAPABILITIES = {
       hooks: {
         mode: "translate",
         nativeSurfaces: ["hooks/hooks.json", ".codex/hooks.json", "~/.codex/hooks.json"],
-        notes: "Hooks are native. Pluxx bundles translated Codex hooks in the plugin with the documented `[features].plugin_hooks = true` plugin gate, and still tracks the broader project/user hook config paths where `[features].hooks` is the general flag and `codex_hooks` is deprecated."
+        notes: "Hooks are native. Pluxx bundles translated Codex hooks in the plugin with the documented `[features].hooks = true` feature key, and still tracks broader project/user hook config paths where `codex_hooks` is deprecated. Plugin-bundled execution still also depends on enabled plugin state, review, trust, and runtime support."
       },
       permissions: {
         mode: "translate",
@@ -12152,7 +12221,6 @@ function getCoreFourPrimitiveCapabilities(platform) {
 }
 
 // src/cli/primitive-summary.ts
-var CORE_FOUR_ORDER = ["claude-code", "cursor", "codex", "opencode"];
 var TARGET_LABELS = {
   "claude-code": "claude",
   cursor: "cursor",
@@ -12166,7 +12234,7 @@ var MODE_LABELS = {
   drop: "drop"
 };
 function buildPrimitiveTranslationSummary(config, targets = config.targets) {
-  const selectedTargets = CORE_FOUR_ORDER.filter((target) => targets.includes(target));
+  const selectedTargets = CORE_FOUR_PLATFORMS.filter((target) => targets.includes(target));
   if (selectedTargets.length === 0) return void 0;
   const configuredBuckets = getConfiguredCompilerBuckets({
     ...config,
@@ -13356,7 +13424,7 @@ function lintCodexHooksExternalConfig(config, issues) {
     pushIssue(issues, {
       level: "warning",
       code: "codex-hooks-external-config",
-      message: `Pluxx now bundles Codex hooks at \`hooks/hooks.json\`, and Codex plugin-bundled hook loading requires \`${PLUGIN_BUNDLED_CODEX_HOOKS_FEATURE_FLAG} = true\` under \`[features]\`. The general \`${RECOMMENDED_CODEX_HOOKS_FEATURE_FLAG}\` flag covers non-plugin hook config and defaults on; \`${ALTERNATE_CODEX_HOOKS_FEATURE_FLAG}\` is deprecated and should not be treated as a plugin-bundled hook fallback. If bundled hooks do not activate, enable \`${PLUGIN_BUNDLED_CODEX_HOOKS_FEATURE_FLAG} = true\`, reload Codex, and retest in a trusted interactive session.`,
+      message: `Pluxx now bundles Codex hooks at \`hooks/hooks.json\`, and current Codex docs use \`${RECOMMENDED_CODEX_HOOKS_FEATURE_FLAG} = true\` under \`[features]\` as the canonical hook feature key. \`${ALTERNATE_CODEX_HOOKS_FEATURE_FLAG}\` is deprecated and should not be treated as the current hook feature key. If bundled hooks do not activate, enable \`${RECOMMENDED_CODEX_HOOKS_FEATURE_FLAG} = true\`, reload Codex, and retest in a trusted interactive session.`,
       file: "pluxx.config.ts",
       platform: "Codex"
     });
@@ -13365,7 +13433,7 @@ function lintCodexHooksExternalConfig(config, issues) {
     pushIssue(issues, {
       level: "warning",
       code: "codex-hooks-legacy-feature-flag",
-      message: `\`${ALTERNATE_CODEX_HOOKS_FEATURE_FLAG}\` is deprecated for general Codex hook config and should not be treated as a plugin-bundled hook fallback. Keep it only as a compatibility fallback for non-plugin hook wiring, prefer \`${RECOMMENDED_CODEX_HOOKS_FEATURE_FLAG} = true\` there, and use \`${PLUGIN_BUNDLED_CODEX_HOOKS_FEATURE_FLAG} = true\` for plugin-bundled hooks.`,
+      message: `\`${ALTERNATE_CODEX_HOOKS_FEATURE_FLAG}\` is deprecated for Codex hook config. Prefer \`${RECOMMENDED_CODEX_HOOKS_FEATURE_FLAG} = true\` under \`[features]\`.`,
       file: "pluxx.config.ts",
       platform: "Codex"
     });
@@ -13374,7 +13442,7 @@ function lintCodexHooksExternalConfig(config, issues) {
     pushIssue(issues, {
       level: "warning",
       code: "codex-hooks-general-feature-flag-only",
-      message: `This Codex config enables only general hook flags. Plugin-bundled hooks at \`hooks/hooks.json\` still need \`${PLUGIN_BUNDLED_CODEX_HOOKS_FEATURE_FLAG} = true\` under \`[features]\`; \`${RECOMMENDED_CODEX_HOOKS_FEATURE_FLAG}\` and \`${ALTERNATE_CODEX_HOOKS_FEATURE_FLAG}\` alone are not sufficient.`,
+      message: `This Codex config enables only deprecated hook flags. Plugin-bundled hooks at \`hooks/hooks.json\` should use \`${RECOMMENDED_CODEX_HOOKS_FEATURE_FLAG} = true\` under \`[features]\`.`,
       file: "pluxx.config.ts",
       platform: "Codex"
     });
@@ -17987,10 +18055,10 @@ ${additions.map((block) => `- ${block.replace(/\n/g, "\n  ")}`).join("\n")}
 import { spawn as spawn3, spawnSync as spawnSync2 } from "child_process";
 import { accessSync, constants, existsSync as existsSync24, lstatSync as lstatSync3, readFileSync as readFileSync14, readdirSync as readdirSync10, realpathSync } from "fs";
 import { homedir as homedir2 } from "os";
-import { basename as basename6, dirname as dirname7, resolve as resolve20 } from "path";
+import { basename as basename7, dirname as dirname7, relative as relative12, resolve as resolve20 } from "path";
 
 // src/cli/install.ts
-import { resolve as resolve19, dirname as dirname6 } from "path";
+import { resolve as resolve19, dirname as dirname6, basename as basename6, relative as relative11 } from "path";
 import { existsSync as existsSync23, symlinkSync, mkdirSync as mkdirSync4, rmSync as rmSync3, readFileSync as readFileSync13, writeFileSync as writeFileSync4, cpSync as cpSync3, readdirSync as readdirSync9 } from "fs";
 import { spawnSync } from "child_process";
 import * as readline2 from "readline";
@@ -18474,19 +18542,25 @@ function createOpenCodeCopiedInstall(target, pluginName) {
   writeOpenCodeEntryFile(target.pluginDir, pluginName);
   syncOpenCodeSkills(target.pluginDir, pluginName);
 }
-function materializeTemplateValue(value, env) {
-  return value.replace(/\$\{([A-Za-z_][A-Za-z0-9_]*)\}/g, (_match, name) => env[name] ?? `\${${name}}`);
+function materializeTemplateValue(value, env, secretEnvVars = /* @__PURE__ */ new Set()) {
+  return value.replace(
+    /\$\{([A-Za-z_][A-Za-z0-9_]*)\}/g,
+    (_match, name) => secretEnvVars.has(name) ? `\${${name}}` : env[name] ?? `\${${name}}`
+  );
 }
-function materializeEnvRecord(input, env) {
+function materializeEnvRecord(input, env, secretEnvVars = /* @__PURE__ */ new Set()) {
   const output = {};
   for (const [key, value] of Object.entries(input ?? {})) {
-    output[key] = materializeTemplateValue(value, env);
+    output[key] = materializeTemplateValue(value, env, secretEnvVars);
   }
   return output;
 }
 function patchInstalledMcpConfig(pluginDir, platform, config, entries) {
   if (!config.mcp) return;
   const env = buildUserConfigEnvMap(entries);
+  const secretEnvVars = new Set(
+    entries.filter((entry) => entry.field.type === "secret" && entry.envVar).map((entry) => entry.envVar)
+  );
   if (platform === "claude-code" || platform === "cursor") {
     const filepath = resolve19(pluginDir, platform === "claude-code" ? ".mcp.json" : "mcp.json");
     if (!existsSync23(filepath)) return;
@@ -18531,7 +18605,7 @@ function patchInstalledMcpConfig(pluginDir, platform, config, entries) {
         mcpServers[name] = {
           command: materializeInstalledPluginOwnedStdioPathForPlatform(server.command, platform, pluginDir),
           args: (server.args ?? []).map((value) => materializeInstalledPluginOwnedStdioPathForPlatform(value, platform, pluginDir)),
-          env: materializeEnvRecord(server.env, env)
+          env: materializeEnvRecord(server.env, env, secretEnvVars)
         };
         continue;
       }
@@ -18541,49 +18615,46 @@ function patchInstalledMcpConfig(pluginDir, platform, config, entries) {
       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;
-          }
+          entry.bearer_token_env_var = nativeOverride.bearer_token_env_var;
         }
         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}}`
-            ])
+          entry.env_http_headers = Object.fromEntries(
+            Object.entries(nativeOverride.env_http_headers).filter(([, value]) => typeof value === "string").map(([headerName, envVar]) => [headerName, envVar])
           );
         }
         if (nativeOverride.http_headers && typeof nativeOverride.http_headers === "object") {
           entry.http_headers = materializeEnvRecord(
             nativeOverride.http_headers,
-            env
+            env,
+            secretEnvVars
           );
         }
-      } else if (server.auth?.type === "bearer" && server.auth.envVar && env[server.auth.envVar]) {
-        entry.http_headers = {
-          Authorization: `Bearer ${env[server.auth.envVar]}`
-        };
-      } else if (server.auth?.type === "header" && server.auth.envVar && env[server.auth.envVar]) {
-        entry.http_headers = {
-          [server.auth.headerName]: server.auth.headerTemplate.replace("${value}", env[server.auth.envVar])
-        };
+      } 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}";
+        if (isBearerAuthorizationHeader) {
+          entry.bearer_token_env_var = server.auth.envVar;
+        } else if (server.auth.headerTemplate === "${value}") {
+          entry.env_http_headers = {
+            [server.auth.headerName]: server.auth.envVar
+          };
+        }
       }
       mcpServers[name] = entry;
     }
     writeFileSync4(filepath, JSON.stringify({ mcpServers }, null, 2) + "\n");
   }
 }
-function writeInstalledUserConfig(pluginDir, entries) {
+function writeInstalledUserConfig(pluginDir, entries, platform) {
   if (entries.length === 0) return;
   const filepath = resolve19(pluginDir, ".pluxx-user.json");
-  const payload = {
-    values: buildUserConfigValueMap(entries),
-    env: buildUserConfigEnvMap(entries)
-  };
+  const payload = buildInstalledUserConfigPayload(entries, {
+    preserveSecretReferences: platform === "codex"
+  });
   writeFileSync4(filepath, JSON.stringify(payload, null, 2) + "\n");
 }
 function disableInstalledEnvValidation(pluginDir, entries) {
@@ -18597,7 +18668,7 @@ function disableInstalledEnvValidation(pluginDir, entries) {
 }
 function materializeInstalledPlugin(pluginDir, platform, config, entries) {
   if (entries.length > 0) {
-    writeInstalledUserConfig(pluginDir, entries);
+    writeInstalledUserConfig(pluginDir, entries, platform);
     disableInstalledEnvValidation(pluginDir, entries);
   }
   patchInstalledMcpConfig(pluginDir, platform, config, entries);
@@ -18676,7 +18747,7 @@ function resolveBundleReference(rootDir, value) {
   if (isRelativeBundlePath(value)) {
     return resolve19(rootDir, value);
   }
-  const pluginRootMatch = value.match(/^\$\{(?:CLAUDE_PLUGIN_ROOT|CURSOR_PLUGIN_ROOT|PLUGIN_ROOT)\}[\\/](.+)$/);
+  const pluginRootMatch = value.match(/^\$\{(?:CLAUDE_PLUGIN_ROOT|CURSOR_PLUGIN_ROOT|CODEX_PLUGIN_ROOT|OPENCODE_PLUGIN_ROOT|PLUGIN_ROOT|PLUXX_PLUGIN_ROOT)\}[\\/](.+)$/);
   if (pluginRootMatch) {
     return resolve19(rootDir, pluginRootMatch[1]);
   }
@@ -18719,9 +18790,43 @@ function collectHookCommandStrings(value, commands) {
   }
 }
 function extractBundleCommandTargets(command2) {
-  const matches = command2.match(/\$\{(?:CLAUDE_PLUGIN_ROOT|CURSOR_PLUGIN_ROOT|PLUGIN_ROOT)\}[\\/][^\s"'`;$|&<>]+|\.\.?[\\/][^\s"'`;$|&<>]+/g);
+  const matches = command2.match(/\$\{(?:CLAUDE_PLUGIN_ROOT|CURSOR_PLUGIN_ROOT|CODEX_PLUGIN_ROOT|OPENCODE_PLUGIN_ROOT|PLUGIN_ROOT|PLUXX_PLUGIN_ROOT)\}[\\/][^\s"'`;$|&<>]+|\.\.?[\\/][^\s"'`;$|&<>]+/g);
   return matches ?? [];
 }
+function extractRelativeBundleCommandTargets(command2) {
+  return extractBundleCommandTargets(command2).filter(isRelativeBundlePath);
+}
+function commandChangesToKnownPluginRoot(command2) {
+  return /\bcd\s+["']?\$\{?(?:CLAUDE_PLUGIN_ROOT|CURSOR_PLUGIN_ROOT|CODEX_PLUGIN_ROOT|OPENCODE_PLUGIN_ROOT|PLUGIN_ROOT|PLUXX_PLUGIN_ROOT)\}?/.test(command2);
+}
+function formatBundleRelativePath(rootDir, filePath) {
+  const relativePath = relative11(rootDir, filePath);
+  return relativePath && !relativePath.startsWith("..") ? relativePath : filePath;
+}
+function findHookWrapperPaths(rootDir, command2) {
+  return extractBundleCommandTargets(command2).map((target) => resolveBundleReference(rootDir, target)).filter((target) => {
+    if (!target) return false;
+    return existsSync23(target) && basename6(target).startsWith("pluxx-hook-command-") && target.endsWith(".sh");
+  });
+}
+function findCodexCwdUnsafeHookCommands(rootDir, commands) {
+  const issues = /* @__PURE__ */ new Set();
+  for (const command2 of commands) {
+    const relativeTargets = extractRelativeBundleCommandTargets(command2);
+    if (relativeTargets.length > 0 && !commandChangesToKnownPluginRoot(command2)) {
+      issues.add(`${command2} uses cwd-relative bundle target(s): ${relativeTargets.join(", ")}`);
+    }
+    for (const wrapperPath of findHookWrapperPaths(rootDir, command2)) {
+      const wrapper = readFileSync13(wrapperPath, "utf-8");
+      const hookCommand = wrapper.match(/^PLUXX_HOOK_COMMAND=(.*)$/m)?.[1] ?? "";
+      const wrapperRelativeTargets = extractRelativeBundleCommandTargets(hookCommand);
+      if (wrapperRelativeTargets.length > 0 && !commandChangesToKnownPluginRoot(wrapper)) {
+        issues.add(`${formatBundleRelativePath(rootDir, wrapperPath)} evaluates cwd-relative bundle target(s): ${wrapperRelativeTargets.join(", ")}`);
+      }
+    }
+  }
+  return [...issues].sort();
+}
 function resolveInstalledHooksReference(rootDir, platform, manifest) {
   const manifestReference = typeof manifest.hooks === "string" ? manifest.hooks : void 0;
   if (manifestReference) {
@@ -18759,6 +18864,7 @@ function findInstalledBundleIntegrityIssues(rootDir, platform) {
     return {
       missingManifestPaths: [],
       missingHookTargets: [],
+      cwdUnsafeHookCommands: [],
       invalidRuntimeScripts: []
     };
   }
@@ -18768,6 +18874,7 @@ function findInstalledBundleIntegrityIssues(rootDir, platform) {
       manifestIssue: `missing plugin manifest at ${manifestPath}`,
       missingManifestPaths: [],
       missingHookTargets: [],
+      cwdUnsafeHookCommands: [],
       invalidRuntimeScripts: []
     };
   }
@@ -18779,6 +18886,7 @@ function findInstalledBundleIntegrityIssues(rootDir, platform) {
       manifestIssue: `plugin manifest at ${manifestPath} is not parseable: ${error instanceof Error ? error.message : String(error)}`,
       missingManifestPaths: [],
       missingHookTargets: [],
+      cwdUnsafeHookCommands: [],
       invalidRuntimeScripts: []
     };
   }
@@ -18793,6 +18901,7 @@ function findInstalledBundleIntegrityIssues(rootDir, platform) {
       ...manifestIssue ? { manifestIssue } : {},
       missingManifestPaths,
       missingHookTargets: [],
+      cwdUnsafeHookCommands: [],
       invalidRuntimeScripts: findInstalledRuntimeScriptIssues(rootDir, manifest)
     };
   }
@@ -18801,6 +18910,7 @@ function findInstalledBundleIntegrityIssues(rootDir, platform) {
       ...manifestIssue ? { manifestIssue } : {},
       missingManifestPaths,
       missingHookTargets: [],
+      cwdUnsafeHookCommands: [],
       invalidRuntimeScripts: findInstalledRuntimeScriptIssues(rootDir, manifest)
     };
   }
@@ -18814,10 +18924,12 @@ function findInstalledBundleIntegrityIssues(rootDir, platform) {
         return resolved !== void 0 && !existsSync23(resolved);
       })
     )].sort();
+    const cwdUnsafeHookCommands = platform === "codex" ? findCodexCwdUnsafeHookCommands(rootDir, commands) : [];
     return {
       ...manifestIssue ? { manifestIssue } : {},
       missingManifestPaths,
       missingHookTargets,
+      cwdUnsafeHookCommands,
       invalidRuntimeScripts: findInstalledRuntimeScriptIssues(rootDir, manifest)
     };
   } catch (error) {
@@ -18826,6 +18938,7 @@ function findInstalledBundleIntegrityIssues(rootDir, platform) {
       hookConfigIssue: `hooks config at ${hooksReference} is not parseable: ${error instanceof Error ? error.message : String(error)}`,
       missingManifestPaths,
       missingHookTargets: [],
+      cwdUnsafeHookCommands: [],
       invalidRuntimeScripts: findInstalledRuntimeScriptIssues(rootDir, manifest)
     };
   }
@@ -18875,6 +18988,9 @@ function assertInstalledBundleIntegrity(rootDir, platform, label) {
   if (issues.missingHookTargets.length > 0) {
     details.push(`hook targets missing: ${issues.missingHookTargets.join(", ")}`);
   }
+  if (issues.cwdUnsafeHookCommands.length > 0) {
+    details.push(`hook commands require plugin-root cwd: ${issues.cwdUnsafeHookCommands.join("; ")}`);
+  }
   if (issues.invalidRuntimeScripts.length > 0) {
     details.push(`runtime script issues: ${issues.invalidRuntimeScripts.join(", ")}`);
   }
@@ -19119,6 +19235,13 @@ var LOW_INFO_DESCRIPTION_PATTERNS = [
 var MATERIALIZED_ENV_MARKER = "materialized required config";
 var MIN_NODE_MAJOR = 18;
 var STDIO_LAUNCH_SMOKE_TIMEOUT_MS = 1200;
+var MAX_SECRET_SCAN_FILE_BYTES = 512 * 1024;
+var LEGACY_SECRET_IDENTIFIER_PATTERN = /(^|[-_])(api[-_]?key|secret|token|password|credential)([-_]|$)/i;
+var TEST_SECRET_SENTINELS = [
+  { pattern: /\bshh-secret\b/i, label: "test secret sentinel" },
+  { pattern: /\bsecret-key\b/i, label: "test secret sentinel" },
+  { pattern: /\bliteral-secret-value-that-should-not-copy\b/i, label: "test secret sentinel" }
+];
 var PRIMITIVE_MODE_LEVEL = {
   preserve: "success",
   translate: "info",
@@ -19131,6 +19254,106 @@ function renderInstalledPluginRoot(value, rootDir) {
 function addCheck2(checks, check) {
   checks.push(check);
 }
+function looksLegacySecretIdentifier(value) {
+  return LEGACY_SECRET_IDENTIFIER_PATTERN.test(
+    value.replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/[._/\s]+/g, "-")
+  );
+}
+function walkInstalledBundleFiles(rootDir, currentDir = rootDir) {
+  const files = [];
+  for (const entry of readdirSync10(currentDir, { withFileTypes: true })) {
+    const absolutePath = resolve20(currentDir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...walkInstalledBundleFiles(rootDir, absolutePath));
+      continue;
+    }
+    if (!entry.isFile()) continue;
+    files.push(relative12(rootDir, absolutePath).replace(/\\/g, "/"));
+  }
+  return files.sort();
+}
+function readInstalledTextFile(rootDir, relativePath) {
+  const absolutePath = resolve20(rootDir, relativePath);
+  const content = readFileSync14(absolutePath);
+  if (content.length > MAX_SECRET_SCAN_FILE_BYTES) return null;
+  if (content.includes(0)) return null;
+  return content.toString("utf-8");
+}
+function collectInstalledPlaintextSecretCandidates(rootDir) {
+  const userConfigPath = resolve20(rootDir, ".pluxx-user.json");
+  if (!existsSync24(userConfigPath)) return [];
+  try {
+    const payload = JSON.parse(readFileSync14(userConfigPath, "utf-8"));
+    if (payload.secretStorage === "materialized") return [];
+    const secretKeys = new Set(Array.isArray(payload.secretKeys) ? payload.secretKeys.filter((value) => typeof value === "string") : []);
+    const secretEnv = new Set(Array.isArray(payload.secretEnv) ? payload.secretEnv.filter((value) => typeof value === "string") : []);
+    const hasSecretMetadata = secretKeys.size > 0 || secretEnv.size > 0;
+    const candidateLabels = /* @__PURE__ */ new Map();
+    const recordCandidate = (rawValue, label) => {
+      if (typeof rawValue !== "string") return;
+      const value = rawValue.trim();
+      if (!value) return;
+      if (extractEnvReference(value)) return;
+      if (isPlaceholderSecretValue(value)) return;
+      const labels = candidateLabels.get(value) ?? /* @__PURE__ */ new Set();
+      labels.add(label);
+      candidateLabels.set(value, labels);
+    };
+    for (const [key, value] of Object.entries(payload.values ?? {})) {
+      if (hasSecretMetadata ? !secretKeys.has(key) : !looksLegacySecretIdentifier(key)) continue;
+      recordCandidate(value, `userConfig "${key}"`);
+    }
+    for (const [key, value] of Object.entries(payload.env ?? {})) {
+      if (hasSecretMetadata ? !secretEnv.has(key) : !looksLegacySecretIdentifier(key)) continue;
+      recordCandidate(value, `env "${key}"`);
+    }
+    return [...candidateLabels.entries()].map(([value, labels]) => ({
+      value,
+      labels: [...labels].sort()
+    }));
+  } catch {
+    return [];
+  }
+}
+function checkInstalledPlaintextSecrets(checks, rootDir) {
+  const literalCandidates = collectInstalledPlaintextSecretCandidates(rootDir);
+  const findings = /* @__PURE__ */ new Map();
+  for (const relativePath of walkInstalledBundleFiles(rootDir)) {
+    const content = readInstalledTextFile(rootDir, relativePath);
+    if (!content) continue;
+    const labels = /* @__PURE__ */ new Set();
+    for (const candidate of literalCandidates) {
+      if (!content.includes(candidate.value)) continue;
+      for (const label of candidate.labels) labels.add(label);
+    }
+    for (const sentinel of TEST_SECRET_SENTINELS) {
+      if (sentinel.pattern.test(content)) {
+        labels.add(sentinel.label);
+      }
+    }
+    if (labels.size > 0) {
+      findings.set(relativePath, labels);
+    }
+  }
+  if (findings.size === 0) {
+    addCheck2(checks, {
+      level: "success",
+      code: "consumer-plaintext-secret-absent",
+      title: "Installed bundle does not expose known plaintext secret material",
+      detail: "No known prompted secret values or maintained test-secret sentinels were detected in scanned installed text files.",
+      fix: "No action needed."
+    });
+    return;
+  }
+  const detail = [...findings.entries()].map(([path, labels]) => `${path} (${[...labels].sort().join(", ")})`).join("; ");
+  addCheck2(checks, {
+    level: "error",
+    code: "consumer-plaintext-secret-leak",
+    title: "Installed bundle contains plaintext secret material",
+    detail: `Detected plaintext secret material in installed files: ${detail}.`,
+    fix: "Rotate the affected credential, remove the leaking install, reinstall after the Pluxx secret-reference fix, and rerun pluxx doctor --consumer."
+  });
+}
 function summarizeChecks2(checks) {
   const visibleChecks = checks.filter((check) => !check.code.startsWith("primitive-"));
   const errors = visibleChecks.filter((check) => check.level === "error").length;
@@ -19755,7 +19978,7 @@ function readCodexHooksFeatureFlag(filePath) {
       inFeaturesTable = sectionMatch[1].trim() === "features";
       continue;
     }
-    const dottedFeatureMatch = line.match(/^features\.(plugin_hooks|hooks|codex_hooks)\s*=\s*(.+)$/);
+    const dottedFeatureMatch = line.match(/^features\.(hooks|codex_hooks)\s*=\s*(.+)$/);
     if (dottedFeatureMatch) {
       assignFeatureFlag(dottedFeatureMatch[1], dottedFeatureMatch[2]);
       continue;
@@ -19772,7 +19995,7 @@ function readCodexHooksFeatureFlag(filePath) {
       continue;
     }
     if (!inFeaturesTable) continue;
-    const featureMatch = line.match(/^(plugin_hooks|hooks|codex_hooks)\s*=\s*(.+)$/);
+    const featureMatch = line.match(/^(hooks|codex_hooks)\s*=\s*(.+)$/);
     if (!featureMatch) continue;
     assignFeatureFlag(featureMatch[1], featureMatch[2]);
   }
@@ -19961,7 +20184,7 @@ function listClaudeSettingsCandidates(projectRoot) {
   });
 }
 function readClaudeDisableAllHooks(filePath) {
-  const parsed = readJsonFile2(dirname7(filePath), basename6(filePath));
+  const parsed = readJsonFile2(dirname7(filePath), basename7(filePath));
   return typeof parsed.disableAllHooks === "boolean" ? parsed.disableAllHooks : void 0;
 }
 function probeClaudeDisableAllHooks(projectRoot) {
@@ -20304,6 +20527,9 @@ function checkInstalledBundleIntegrity(checks, rootDir, layout) {
   if (issues.missingHookTargets.length > 0) {
     details.push(`hook commands reference missing bundle target${issues.missingHookTargets.length === 1 ? "" : "s"}: ${issues.missingHookTargets.join(", ")}`);
   }
+  if (issues.cwdUnsafeHookCommands.length > 0) {
+    details.push(`Codex hook command${issues.cwdUnsafeHookCommands.length === 1 ? " depends" : "s depend"} on plugin-root cwd: ${issues.cwdUnsafeHookCommands.join("; ")}`);
+  }
   if (issues.invalidRuntimeScripts.length > 0) {
     details.push(`runtime startup still depends on installer-owned validation: ${issues.invalidRuntimeScripts.join(", ")}`);
   }
@@ -20323,7 +20549,7 @@ function checkInstalledBundleIntegrity(checks, rootDir, layout) {
     code: "consumer-bundle-integrity-invalid",
     title: "Installed bundle integrity is broken",
     detail: details.join("; "),
-    fix: "Reinstall the plugin or rebuild the bundle so every manifest path, hook config, and hook target is valid inside the installed plugin.",
+    fix: "Reinstall the plugin or rebuild the bundle so every manifest path, hook config, and hook command resolves from the installed plugin root.",
     path: layout.manifestPath
   });
 }
@@ -20388,31 +20614,31 @@ function checkInstalledCodexHooksFeatureFlag(checks, rootDir, layout, options) {
   const enabledProbes = probes.filter((probe) => probe.enabled);
   const checkedPaths = probes.map((probe) => `${probe.scope} ${probe.exists ? "config" : "path"}: ${probe.path}${probe.exists ? "" : " (missing)"}`).join("; ");
   const describeEnabledFlags = (probe) => {
-    const enabledFlags = [];
-    if (probe.pluginBundledEnabled) enabledFlags.push(PLUGIN_BUNDLED_CODEX_HOOKS_FEATURE_FLAG);
-    if (probe.recommendedEnabled) enabledFlags.push(RECOMMENDED_CODEX_HOOKS_FEATURE_FLAG);
-    if (probe.alternateEnabled) enabledFlags.push(ALTERNATE_CODEX_HOOKS_FEATURE_FLAG);
-    return enabledFlags.join(" + ");
+    const enabledFlags = /* @__PURE__ */ new Set();
+    if (probe.pluginBundledEnabled) enabledFlags.add(PLUGIN_BUNDLED_CODEX_HOOKS_FEATURE_FLAG);
+    if (probe.recommendedEnabled) enabledFlags.add(RECOMMENDED_CODEX_HOOKS_FEATURE_FLAG);
+    if (probe.alternateEnabled) enabledFlags.add(ALTERNATE_CODEX_HOOKS_FEATURE_FLAG);
+    return [...enabledFlags].join(" + ");
   };
   const generalOnlyProbes = probes.filter((probe) => !probe.pluginBundledEnabled && (probe.recommendedEnabled || probe.alternateEnabled));
   if (generalOnlyProbes.length > 0) {
     addCheck2(checks, {
       level: "warning",
       code: "consumer-codex-plugin-hooks-feature-flag-general-only",
-      title: "Codex config enables only general hook flags, not the plugin-bundled hook gate",
-      detail: `This installed Codex bundle declares plugin-bundled hooks at ${hooksReference}, but ${generalOnlyProbes.map((probe) => `${probe.scope} config ${probe.path}`).join(" and ")} enables only general hook flags (${generalOnlyProbes.map((probe) => describeEnabledFlags(probe)).join(" and ")}). Those general flags do not activate plugin-bundled hooks by themselves.`,
-      fix: `Enable \`${PLUGIN_BUNDLED_CODEX_HOOKS_FEATURE_FLAG} = true\` under \`[features]\` in the active Codex config, reload Codex, and rerun pluxx verify-install.`,
+      title: "Codex config enables only deprecated hook flags",
+      detail: `This installed Codex bundle declares plugin-bundled hooks at ${hooksReference}, but ${generalOnlyProbes.map((probe) => `${probe.scope} config ${probe.path}`).join(" and ")} enables only deprecated hook flags (${generalOnlyProbes.map((probe) => describeEnabledFlags(probe)).join(" and ")}). Current Codex docs use \`${RECOMMENDED_CODEX_HOOKS_FEATURE_FLAG}\` as the canonical feature key.`,
+      fix: `Enable \`${RECOMMENDED_CODEX_HOOKS_FEATURE_FLAG} = true\` under \`[features]\` in the active Codex config, reload Codex, and rerun pluxx verify-install.`,
       path: generalOnlyProbes[0].path
     });
   }
-  const legacyOnlyProbes = probes.filter((probe) => probe.alternateEnabled && !probe.recommendedEnabled);
+  const legacyOnlyProbes = probes.filter((probe) => !probe.pluginBundledEnabled && probe.alternateEnabled && !probe.recommendedEnabled);
   if (legacyOnlyProbes.length > 0) {
     addCheck2(checks, {
       level: "warning",
       code: "consumer-codex-hooks-feature-flag-legacy-only",
       title: "Codex config still uses the deprecated general hook compatibility flag",
-      detail: `This installed Codex bundle declares plugin-bundled hooks at ${hooksReference}, and the checked Codex config enables only the deprecated general hook flag \`${ALTERNATE_CODEX_HOOKS_FEATURE_FLAG} = true\` in ${legacyOnlyProbes.map((probe) => `${probe.scope} config ${probe.path}`).join(" and ")}. That flag is not the plugin-bundled hook gate.`,
-      fix: `Prefer \`${RECOMMENDED_CODEX_HOOKS_FEATURE_FLAG} = true\` only for non-plugin hook config if needed, and use \`${PLUGIN_BUNDLED_CODEX_HOOKS_FEATURE_FLAG} = true\` under \`[features]\` for plugin-bundled hooks. Reload Codex and rerun pluxx verify-install after updating the active config.`,
+      detail: `This installed Codex bundle declares plugin-bundled hooks at ${hooksReference}, and the checked Codex config enables only the deprecated hook flag \`${ALTERNATE_CODEX_HOOKS_FEATURE_FLAG} = true\` in ${legacyOnlyProbes.map((probe) => `${probe.scope} config ${probe.path}`).join(" and ")}. Current Codex docs use \`${RECOMMENDED_CODEX_HOOKS_FEATURE_FLAG}\` as the canonical feature key.`,
+      fix: `Use \`${RECOMMENDED_CODEX_HOOKS_FEATURE_FLAG} = true\` under \`[features]\`, reload Codex, and rerun pluxx verify-install after updating the active config.`,
       path: legacyOnlyProbes[0].path
     });
   }
@@ -20420,8 +20646,8 @@ function checkInstalledCodexHooksFeatureFlag(checks, rootDir, layout, options) {
     addCheck2(checks, {
       level: "success",
       code: "consumer-codex-hooks-feature-flag-enabled",
-      title: "Codex plugin-bundled hook feature flag found for this install",
-      detail: `This installed Codex bundle declares plugin-bundled hooks at ${hooksReference}, and the plugin hook gate was found in ${enabledProbes.map((probe) => `${probe.scope} config ${probe.path} (${describeEnabledFlags(probe)})`).join(" and ")}. Treat that as a prerequisite, not proof of live hook execution.`,
+      title: "Codex hook feature flag found for this install",
+      detail: `This installed Codex bundle declares plugin-bundled hooks at ${hooksReference}, and the canonical hook feature key was found in ${enabledProbes.map((probe) => `${probe.scope} config ${probe.path} (${describeEnabledFlags(probe)})`).join(" and ")}. Treat that as a prerequisite, not proof of live hook execution.`,
       fix: "No action needed.",
       path: enabledProbes[0].path
     });
@@ -20432,8 +20658,8 @@ function checkInstalledCodexHooksFeatureFlag(checks, rootDir, layout, options) {
     level: "warning",
     code: "consumer-codex-hooks-feature-flag-missing",
     title: "Codex plugin-bundled hook activation is missing its known feature-gate prerequisite",
-    detail: `This installed Codex bundle declares plugin-bundled hooks at ${hooksReference}, but \`${PLUGIN_BUNDLED_CODEX_HOOKS_FEATURE_FLAG} = true\` was not found in the checked Codex config layers. The general \`${RECOMMENDED_CODEX_HOOKS_FEATURE_FLAG}\` flag covers non-plugin hook config and defaults on, while \`${ALTERNATE_CODEX_HOOKS_FEATURE_FLAG}\` is deprecated and should not be treated as a plugin-bundled hook fallback. Checked ${checkedPaths}.${parseErrors.length > 0 ? ` Unparseable config: ${parseErrors.join("; ")}.` : ""}`,
-    fix: `Enable \`${PLUGIN_BUNDLED_CODEX_HOOKS_FEATURE_FLAG} = true\` under \`[features]\` in the relevant project or user Codex config, reload Codex, and rerun pluxx verify-install.`,
+    detail: `This installed Codex bundle declares plugin-bundled hooks at ${hooksReference}, but \`${RECOMMENDED_CODEX_HOOKS_FEATURE_FLAG} = true\` was not found in the checked Codex config layers. \`${ALTERNATE_CODEX_HOOKS_FEATURE_FLAG}\` is deprecated and should not be treated as the current hook feature key. Checked ${checkedPaths}.${parseErrors.length > 0 ? ` Unparseable config: ${parseErrors.join("; ")}.` : ""}`,
+    fix: `Enable \`${RECOMMENDED_CODEX_HOOKS_FEATURE_FLAG} = true\` under \`[features]\` in the relevant project or user Codex config, reload Codex, and rerun pluxx verify-install.`,
     path: probes.find((probe) => probe.exists)?.path ?? hooksReference
   });
 }
@@ -20796,7 +21022,7 @@ function isLikelyLocalRuntimePath3(value) {
 function isLikelyOpenCodeInstallPath(rootDir) {
   const parent = dirname7(rootDir);
   const grandparent = dirname7(parent);
-  return basename6(parent) === "plugins" && basename6(grandparent) === "opencode";
+  return basename7(parent) === "plugins" && basename7(grandparent) === "opencode";
 }
 function checkInstalledOpenCodeHostBridge(checks, rootDir) {
   if (!isLikelyOpenCodeInstallPath(rootDir)) {
@@ -20810,7 +21036,7 @@ function checkInstalledOpenCodeHostBridge(checks, rootDir) {
     });
     return;
   }
-  const pluginName = basename6(rootDir);
+  const pluginName = basename7(rootDir);
   const entryPath = `${rootDir}.ts`;
   const entryRelativePath = `${pluginName}.ts`;
   if (!existsSync24(entryPath)) {
@@ -20851,7 +21077,7 @@ function checkInstalledOpenCodeSkills(checks, rootDir) {
   if (!isLikelyOpenCodeInstallPath(rootDir)) {
     return;
   }
-  const pluginName = basename6(rootDir);
+  const pluginName = basename7(rootDir);
   const sourceSkillsDir = resolve20(rootDir, "skills");
   if (!existsSync24(sourceSkillsDir)) {
     addCheck2(checks, {
@@ -20967,6 +21193,7 @@ async function doctorConsumer(rootDir = process.cwd(), options = {}) {
   checkInstalledCodexPermissionCompanion(checks, rootDir, layout, options);
   checkInstalledPermissionHook(checks, rootDir, layout);
   checkInstalledUserConfig(checks, rootDir);
+  checkInstalledPlaintextSecrets(checks, rootDir);
   checkInstalledEnvValidation(checks, rootDir);
   checkInstalledRuntimeScriptRoles(checks, rootDir);
   await checkInstalledMcpConfig(checks, rootDir, layout);
@@ -21079,7 +21306,7 @@ function printDoctorReport(report) {
 
 // src/cli/dev.ts
 import { watch } from "fs";
-import { relative as relative11, resolve as resolve21 } from "path";
+import { relative as relative13, resolve as resolve21 } from "path";
 var WATCH_PATTERNS = [
   /^pluxx\.config\.(ts|js|json)$/,
   /^skills\//,
@@ -21105,7 +21332,7 @@ async function runDev(args2) {
   let pendingFile = null;
   const watcher = watch(rootDir, { recursive: true }, (_event, filename) => {
     if (!filename) return;
-    const rel = relative11(rootDir, resolve21(rootDir, filename));
+    const rel = relative13(rootDir, resolve21(rootDir, filename));
     if (rel.startsWith("dist/") || rel.startsWith(".") || rel.includes("node_modules")) {
       return;
     }
@@ -21160,7 +21387,7 @@ async function runBuild(rootDir, targets) {
 }
 
 // src/cli/migrate.ts
-import { basename as basename7, dirname as dirname8, relative as relative12, resolve as resolve22 } from "path";
+import { basename as basename8, dirname as dirname8, relative as relative14, resolve as resolve22 } from "path";
 import { existsSync as existsSync25, readdirSync as readdirSync11, mkdirSync as mkdirSync5, cpSync as cpSync4, readFileSync as readFileSync15, writeFileSync as writeFileSync5 } from "fs";
 function detectPlatform(pluginDir) {
   const checks = [
@@ -21525,7 +21752,7 @@ function parseCursorRuleFile(pluginDir, filePath) {
   const content = readFileSync15(filePath, "utf-8");
   const { hasFrontmatter, frontmatterLines, body } = splitMarkdownFrontmatter5(content);
   if (!hasFrontmatter) return null;
-  const description = parseTopLevelStringFrontmatter(frontmatterLines, "description") ?? titleCaseFromDirName(basename7(filePath, ".mdc"));
+  const description = parseTopLevelStringFrontmatter(frontmatterLines, "description") ?? titleCaseFromDirName(basename8(filePath, ".mdc"));
   const globs = parseTopLevelStringOrStringArrayFrontmatter(frontmatterLines, "globs");
   const alwaysApply = parseTopLevelBooleanFrontmatter(frontmatterLines, "alwaysApply");
   return {
@@ -21533,7 +21760,7 @@ function parseCursorRuleFile(pluginDir, filePath) {
     ...globs !== void 0 ? { globs } : {},
     ...alwaysApply !== void 0 ? { alwaysApply } : {},
     ...body.trim() ? { content: body.trim() } : {},
-    path: `./${relative12(pluginDir, filePath).replace(/\\/g, "/")}`
+    path: `./${relative14(pluginDir, filePath).replace(/\\/g, "/")}`
   };
 }
 function collectFiles(dir, predicate) {
@@ -21578,7 +21805,7 @@ function findInstructionSources(pluginDir, detection) {
   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);
+    const nestedAgents = collectFiles(pluginDir, (entry) => entry === "AGENTS.md").map((path) => `./${relative14(pluginDir, path).replace(/\\/g, "/")}`).filter((path) => path !== primary);
     if (nestedAgents.length > 0) {
       platformOverrides.cursor = {
         ...platformOverrides.cursor ?? {},
@@ -22241,7 +22468,7 @@ function hasTopLevelFrontmatterKey(frontmatterLines, key) {
 function normalizeMigratedOpenCodeAgentFile(agentPath) {
   const original = readFileSync15(agentPath, "utf-8");
   const parsed = splitMarkdownFrontmatter5(original);
-  const fileStem = toKebabCase2(basename7(agentPath, ".md")) || "agent";
+  const fileStem = toKebabCase2(basename8(agentPath, ".md")) || "agent";
   const fallbackDescription = buildFallbackAgentDescription(fileStem);
   if (!parsed.hasFrontmatter) {
     const rewritten2 = [
@@ -22297,7 +22524,7 @@ function normalizeMigratedOpenCodeAgents(destDir) {
   const normalized = [];
   for (const filePath of walkMarkdownFiles3(destDir)) {
     if (normalizeMigratedOpenCodeAgentFile(filePath)) {
-      normalized.push(relative12(destDir, filePath).replace(/\\/g, "/"));
+      normalized.push(relative14(destDir, filePath).replace(/\\/g, "/"));
     }
   }
   return normalized.sort();
@@ -24135,7 +24362,7 @@ ${c2}
 } }).prompt();
 
 // src/cli/index.ts
-import { basename as basename9, resolve as resolve29 } from "path";
+import { basename as basename10, resolve as resolve29 } from "path";
 import { mkdir as mkdir4, mkdtemp as mkdtemp3, rm as rm4 } from "fs/promises";
 import { tmpdir as tmpdir5 } from "os";
 import { spawn as spawn6, spawnSync as spawnSync4 } from "child_process";
@@ -24444,8 +24671,15 @@ echo
 echo "Installed __DISPLAY_NAME__ across ${installerTargets.join(", ")}."
 `.replaceAll("__REPO__", "REPO_PLACEHOLDER").replaceAll("__DISPLAY_NAME__", "DISPLAY_PLACEHOLDER");
 }
+function collectInstallerUserConfigEntries(config, platforms) {
+  const baseEntries = collectUserConfigEntries(config, platforms);
+  return [
+    ...baseEntries,
+    ...collectNativeMcpAuthUserConfigEntries(config, platforms, baseEntries)
+  ];
+}
 function renderInstallerUserConfigSnippet(config, platform, installDirVariable) {
-  const entries = collectUserConfigEntries(config, [platform]).map((entry) => ({
+  const entries = collectInstallerUserConfigEntries(config, [platform]).map((entry) => ({
     key: entry.key,
     title: entry.title,
     type: entry.type ?? "string",
@@ -24453,6 +24687,7 @@ function renderInstallerUserConfigSnippet(config, platform, installDirVariable)
     envVar: entry.envVar ?? defaultUserConfigEnvVar(entry.key)
   }));
   if (entries.length === 0) return "";
+  const preserveSecretReferences = platform === "codex";
   const promptLines = entries.map((entry) => {
     const functionName = entry.type === "secret" ? "pluxx_prompt_secret_config" : "pluxx_prompt_text_config";
     return `${functionName} ${JSON.stringify(entry.key)} ${JSON.stringify(entry.envVar)} ${JSON.stringify(entry.title)} ${entry.required ? "1" : "0"}`;
@@ -24463,6 +24698,8 @@ ${JSON.stringify(entries)}
 PLUXX_USER_CONFIG_JSON
 )"
 PLUXX_REUSED_USER_CONFIG=0
+PLUXX_PRESERVE_SECRET_REFS="${preserveSecretReferences ? "1" : "0"}"
+export PLUXX_PRESERVE_SECRET_REFS
 
 pluxx_is_placeholder_secret() {
   case "$1" in
@@ -24489,12 +24726,14 @@ const fs = require('fs')
 const filepath = process.env.PLUXX_SAVED_USER_CONFIG_PATH
 const key = process.env.PLUXX_SAVED_CONFIG_KEY
 const envVar = process.env.PLUXX_SAVED_CONFIG_ENV_VAR
+const preserveSecretRefs = process.env.PLUXX_PRESERVE_SECRET_REFS === '1'
 
 try {
   const payload = JSON.parse(fs.readFileSync(filepath, 'utf8'))
   const candidates = [
     payload && payload.env && envVar ? payload.env[envVar] : undefined,
     payload && payload.values && key ? payload.values[key] : undefined,
+    preserveSecretRefs && payload && payload.envRefs && envVar && payload.envRefs[envVar] === envVar ? envVar : undefined,
   ]
 
   for (const candidate of candidates) {
@@ -24590,21 +24829,53 @@ const path = require('path')
 
 const installDir = process.env.PLUXX_INSTALL_DIR
 const spec = JSON.parse(process.env.PLUXX_USER_CONFIG_SPEC || '[]')
+const preserveSecretReferences = ${preserveSecretReferences ? "true" : "false"}
 
 if (installDir && spec.length > 0) {
   const env = {}
   const values = {}
+  const envRefs = {}
+  const secretKeys = []
+  const secretEnv = []
+  let hasSecret = false
+  const secretEnvVars = new Set(
+    spec
+      .filter((entry) => entry && entry.type === 'secret' && typeof entry.envVar === 'string' && entry.envVar !== '')
+      .map((entry) => entry.envVar),
+  )
 
   for (const entry of spec) {
+    if (entry.type === 'secret') {
+      hasSecret = true
+      if (preserveSecretReferences) {
+        if (entry.key) secretKeys.push(entry.key)
+        if (entry.envVar) secretEnv.push(entry.envVar)
+      }
+    }
     const value = process.env[entry.envVar]
     if (value === undefined || value === '') continue
+    if (preserveSecretReferences && entry.type === 'secret') {
+      envRefs[entry.envVar] = entry.envVar
+      continue
+    }
     values[entry.key] = value
     env[entry.envVar] = value
   }
 
   fs.writeFileSync(
     path.join(installDir, '.pluxx-user.json'),
-    JSON.stringify({ values, env }, null, 2) + '\\n',
+    JSON.stringify(
+      {
+        ...(Object.keys(values).length > 0 ? { values } : {}),
+        ...(Object.keys(env).length > 0 ? { env } : {}),
+        ...(Object.keys(envRefs).length > 0 ? { envRefs } : {}),
+        ...(hasSecret ? { secretStorage: preserveSecretReferences ? 'env-ref' : 'materialized' } : {}),
+        ...(preserveSecretReferences && secretKeys.length > 0 ? { secretKeys: [...new Set(secretKeys)].sort() } : {}),
+        ...(preserveSecretReferences && secretEnv.length > 0 ? { secretEnv: [...new Set(secretEnv)].sort() } : {}),
+      },
+      null,
+      2,
+    ) + '\\n',
   )
 
   const envScriptPath = path.join(installDir, 'scripts/check-env.sh')
@@ -24617,7 +24888,10 @@ if (installDir && spec.length > 0) {
 
   const materialize = (value) =>
     typeof value === 'string'
-      ? value.replace(/\\$\\{([A-Za-z_][A-Za-z0-9_]*)\\}/g, (_match, name) => env[name] || '${" + name + "}')
+      ? value.replace(
+        /\\$\\{([A-Za-z_][A-Za-z0-9_]*)\\}/g,
+        (_match, name) => (preserveSecretReferences && secretEnvVars.has(name) ? '${" + name + "}' : (env[name] || '${" + name + "}')),
+      )
       : value
 
   const materializeRecord = (record) => {
@@ -24641,7 +24915,7 @@ if (installDir && spec.length > 0) {
         server.env = materializeRecord(server.env)
       }
 
-      if (server.bearer_token_env_var && env[server.bearer_token_env_var]) {
+      if (!preserveSecretReferences && server.bearer_token_env_var && env[server.bearer_token_env_var]) {
         server.http_headers = {
           ...(server.http_headers || {}),
           Authorization: 'Bearer ' + env[server.bearer_token_env_var],
@@ -24649,7 +24923,7 @@ if (installDir && spec.length > 0) {
         delete server.bearer_token_env_var
       }
 
-      if (server.env_http_headers && typeof server.env_http_headers === 'object') {
+      if (!preserveSecretReferences && server.env_http_headers && typeof server.env_http_headers === 'object') {
         server.http_headers = {
           ...(server.http_headers || {}),
         }
@@ -24674,7 +24948,7 @@ NODE
 `;
 }
 function hasInstallerUserConfig(config, platform) {
-  return collectUserConfigEntries(config, [platform]).length > 0;
+  return collectInstallerUserConfigEntries(config, [platform]).length > 0;
 }
 function renderInstallerSavedUserConfigCaptureSnippet(config, platform, installDirVariable) {
   if (!hasInstallerUserConfig(config, platform)) return "";
@@ -24840,13 +25114,13 @@ for (const line of lines) {
     continue
   }
   if (tableName === '') {
-    const dottedMatch = trimmed.match(/^features\\.plugin_hooks\\s*=\\s*(.+)$/)
+    const dottedMatch = trimmed.match(/^features\\.hooks\\s*=\\s*(.+)$/)
     if (dottedMatch && isTomlTrue(dottedMatch[1])) process.exit(0)
     const inlineMatch = trimmed.match(/^features\\s*=\\s*(.+)$/)
-    if (inlineMatch && /\\bplugin_hooks\\s*=\\s*true\\b/i.test(inlineMatch[1])) process.exit(0)
+    if (inlineMatch && /\\bhooks\\s*=\\s*true\\b/i.test(inlineMatch[1])) process.exit(0)
   }
   if (tableName !== 'features') continue
-  const match = trimmed.match(/^plugin_hooks\\s*=\\s*(.+)$/)
+  const match = trimmed.match(/^hooks\\s*=\\s*(.+)$/)
   if (match && isTomlTrue(match[1])) process.exit(0)
 }
 process.exit(1)
@@ -24865,7 +25139,7 @@ NODE
       *)
         if [[ -r /dev/tty ]]; then
           echo "This Codex plugin bundle includes startup hooks." >/dev/tty
-          echo "Codex requires [features].plugin_hooks = true before plugin-bundled hooks can run." >/dev/tty
+          echo "Codex requires [features].hooks = true before plugin-bundled hooks can run." >/dev/tty
           read -r -p "Enable Codex plugin-bundled hooks in $CODEX_CONFIG_PATH now? [Y/n] " PLUXX_CODEX_HOOKS_REPLY </dev/tty
           case "$PLUXX_CODEX_HOOKS_REPLY" in
             n|N|no|NO)
@@ -24937,7 +25211,7 @@ for (let index = 0; index < lines.length; index += 1) {
     if (/^features\\.[A-Za-z0-9_-]+\\s*=/.test(trimmed) && firstTopLevelFeaturesDotted < 0) {
       firstTopLevelFeaturesDotted = index
     }
-    if (/^features\\.plugin_hooks\\s*=/.test(trimmed)) {
+    if (/^features\\.hooks\\s*=/.test(trimmed)) {
       topLevelPluginHooksDotted = index
     }
     if (/^features\\s*=\\s*\\{/.test(trimmed)) {
@@ -24956,28 +25230,28 @@ if (start >= 0) {
 
   let updated = false
   for (let index = start + 1; index < end; index += 1) {
-    if (/^plugin_hooks\\s*=/.test(stripTomlComment(lines[index]).trim())) {
-      lines[index] = 'plugin_hooks = true'
+    if (/^hooks\\s*=/.test(stripTomlComment(lines[index]).trim())) {
+      lines[index] = 'hooks = true'
       updated = true
     }
   }
-  if (!updated) lines.splice(start + 1, 0, 'plugin_hooks = true')
+  if (!updated) lines.splice(start + 1, 0, 'hooks = true')
 } else if (topLevelPluginHooksDotted >= 0) {
-  lines[topLevelPluginHooksDotted] = 'features.plugin_hooks = true'
+  lines[topLevelPluginHooksDotted] = 'features.hooks = true'
 } else if (firstTopLevelFeaturesDotted >= 0) {
-  lines.splice(firstTopLevelFeaturesDotted + 1, 0, 'features.plugin_hooks = true')
+  lines.splice(firstTopLevelFeaturesDotted + 1, 0, 'features.hooks = true')
 } else if (topLevelInlineFeatures >= 0 && lines[topLevelInlineFeatures].includes('}')) {
-  if (/\\bplugin_hooks\\s*=/.test(lines[topLevelInlineFeatures])) {
+  if (/\\bhooks\\s*=/.test(lines[topLevelInlineFeatures])) {
     lines[topLevelInlineFeatures] = lines[topLevelInlineFeatures].replace(
-      /\\bplugin_hooks\\s*=\\s*(true|false)\\b/i,
-      'plugin_hooks = true',
+      /\\bhooks\\s*=\\s*(true|false)\\b/i,
+      'hooks = true',
     )
   } else {
-    lines[topLevelInlineFeatures] = lines[topLevelInlineFeatures].replace(/}/, ', plugin_hooks = true }')
+    lines[topLevelInlineFeatures] = lines[topLevelInlineFeatures].replace(/}/, ', hooks = true }')
   }
 } else {
   if (lines.length > 0 && lines[lines.length - 1] !== '') lines.push('')
-  lines.push('[features]', 'plugin_hooks = true')
+  lines.push('[features]', 'hooks = true')
 }
 
 fs.mkdirSync(path.dirname(filepath), { recursive: true })
@@ -24988,7 +25262,7 @@ NODE
     else
       echo "Codex plugin-bundled hooks are not enabled. Startup hooks from this plugin will not run until you add this to $CODEX_CONFIG_PATH:" >&2
       echo "[features]" >&2
-      echo "plugin_hooks = true" >&2
+      echo "hooks = true" >&2
       echo "Then restart or refresh Codex before relying on plugin startup hooks." >&2
       echo "Set PLUXX_CODEX_ENABLE_PLUGIN_HOOKS=1 before running this installer to enable it noninteractively." >&2
     fi
@@ -25854,10 +26128,10 @@ import { resolve as resolve27 } from "path";
 import { existsSync as existsSync28, readFileSync as readFileSync19 } from "fs";
 import { mkdtemp as mkdtemp2, rm as rm3 } from "fs/promises";
 import { tmpdir as tmpdir4 } from "os";
-import { basename as basename8, resolve as resolve26 } from "path";
+import { basename as basename9, resolve as resolve26 } from "path";
 import { spawn as spawn4 } from "child_process";
 async function executeCodexExecCommand(command2, options) {
-  if (basename8(command2[0]) !== "codex" || command2[1] !== "exec") {
+  if (basename9(command2[0]) !== "codex" || command2[1] !== "exec") {
     throw new Error("Codex exec runner requires a command beginning with `codex exec`.");
   }
   const outputDir = await mkdtemp2(resolve26(tmpdir4(), options.outputDirPrefix ?? "pluxx-codex-exec-"));
@@ -26182,6 +26456,7 @@ async function executeBehavioralCommand(platform, command2, cwd, timeoutMs) {
     };
   }
   return await new Promise((resolvePromise, reject) => {
+    const startedAt = Date.now();
     const child = spawn5(command2[0], command2.slice(1), {
       cwd,
       detached: process.platform !== "win32",
@@ -26190,15 +26465,30 @@ async function executeBehavioralCommand(platform, command2, cwd, timeoutMs) {
     });
     const stdoutChunks = [];
     const stderrChunks = [];
+    let settled = false;
+    let timedOut = false;
+    const timeout = setTimeout(() => {
+      timedOut = true;
+      signalBehavioralProcess(child, "SIGKILL");
+    }, timeoutMs);
     child.stdout?.on("data", (chunk) => stdoutChunks.push(Buffer.from(chunk)));
     child.stderr?.on("data", (chunk) => stderrChunks.push(Buffer.from(chunk)));
-    child.on("error", reject);
+    child.on("error", (error) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timeout);
+      reject(error);
+    });
     child.on("close", (code) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timeout);
+      const exceededDeadline = timedOut || Date.now() - startedAt > timeoutMs;
       const stdout = Buffer.concat(stdoutChunks).toString("utf-8");
       const stderr = Buffer.concat(stderrChunks).toString("utf-8");
       resolvePromise({
-        exitCode: code ?? 1,
-        response: stdout.trim() || stderr.trim()
+        exitCode: exceededDeadline ? 124 : code ?? 1,
+        response: exceededDeadline ? `behavioral runner timed out after ${timeoutMs}ms` : stdout.trim() || stderr.trim()
       });
     });
   });
@@ -26240,6 +26530,22 @@ async function commandSucceeds2(command2) {
     child.on("error", () => resolvePromise(false));
   });
 }
+function signalBehavioralProcess(child, signal) {
+  if (child.exitCode != null || child.signalCode != null) {
+    return;
+  }
+  if (process.platform !== "win32" && typeof child.pid === "number") {
+    try {
+      process.kill(-child.pid, signal);
+      return;
+    } catch {
+    }
+  }
+  try {
+    child.kill(signal);
+  } catch {
+  }
+}
 function truncate2(value, length) {
   if (value.length <= length) return value;
   return `${value.slice(0, Math.max(0, length - 3))}...`;
@@ -26261,7 +26567,7 @@ function shellQuote2(value) {
 // src/cli/discover-installed-mcp.ts
 import { existsSync as existsSync30, readFileSync as readFileSync21, realpathSync as realpathSync3 } from "fs";
 import { homedir as homedir3 } from "os";
-import { isAbsolute as isAbsolute2, relative as relative13, resolve as resolve28 } from "path";
+import { isAbsolute as isAbsolute2, relative as relative15, resolve as resolve28 } from "path";
 var INSTALLED_MCP_HOSTS = ["claude-code", "cursor", "codex", "opencode"];
 function discoverInstalledMcpServers(options = {}) {
   const rootDir = options.rootDir ?? process.cwd();
@@ -26400,13 +26706,13 @@ function buildClaudeProjectSourceScope(projectPath, rootDir, homeDir) {
   return `projects/absolute/${normalizeScopePath(projectPath)}`;
 }
 function buildRelativeScopePath(baseDir, targetPath) {
-  const relativePath = relative13(baseDir, targetPath);
+  const relativePath = relative15(baseDir, targetPath);
   if (!relativePath.startsWith("..") && !isAbsolute2(relativePath)) {
     return normalizeScopePath(relativePath);
   }
   if (!existsSync30(baseDir) || !existsSync30(targetPath)) return void 0;
   try {
-    const realRelativePath = relative13(realpathSync3(baseDir), realpathSync3(targetPath));
+    const realRelativePath = relative15(realpathSync3(baseDir), realpathSync3(targetPath));
     if (realRelativePath.startsWith("..") || isAbsolute2(realRelativePath)) return void 0;
     return normalizeScopePath(realRelativePath);
   } catch {
@@ -26606,7 +26912,7 @@ function buildInstalledMcpSourceLabel(discovered, rootDir, homeDir) {
   return discovered.sourceScope ? `${base}:${discovered.sourceScope}` : base;
 }
 function buildRelativeSelectorLabel(prefix, baseDir, sourcePath) {
-  const relativePath = relative13(baseDir, sourcePath);
+  const relativePath = relative15(baseDir, sourcePath);
   if (relativePath === "") return `${prefix}:.`;
   if (relativePath.startsWith("..") || isAbsolute2(relativePath)) return void 0;
   return `${prefix}:${relativePath.replace(/\\/g, "/")}`;
@@ -27530,7 +27836,7 @@ async function runInit() {
   if (!runtime.isInteractive) {
     throw new Error("pluxx init requires an interactive terminal unless you use `pluxx init --from-mcp ... --yes`.");
   }
-  const dirName = positionalName ? toKebabCase3(positionalName) : basename9(process.cwd()).toLowerCase().replace(/[^a-z0-9-]/g, "-");
+  const dirName = positionalName ? toKebabCase3(positionalName) : basename10(process.cwd()).toLowerCase().replace(/[^a-z0-9-]/g, "-");
   console.log("");
   console.log("  pluxx init \u2014 Create a new plugin");
   console.log("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");