morphix-env 0.7.1 → 0.8.0

package/dist/cli.js

@@ -831,8 +831,8 @@ var require_react_development = __commonJS({
       function lazyInitializer(payload) {
         if (-1 === payload._status) {
           var resolveDebugValue = null, rejectDebugValue = null, ioInfo = payload._ioInfo;
-          null != ioInfo && (ioInfo.start = ioInfo.end = performance.now(), ioInfo.value = new Promise(function(resolve6, reject) {
-            resolveDebugValue = resolve6;
+          null != ioInfo && (ioInfo.start = ioInfo.end = performance.now(), ioInfo.value = new Promise(function(resolve7, reject) {
+            resolveDebugValue = resolve7;
             rejectDebugValue = reject;
           }));
           ioInfo = payload._result;
@@ -948,21 +948,21 @@ var require_react_development = __commonJS({
         );
         actScopeDepth = prevActScopeDepth;
       }
-      function recursivelyFlushAsyncActWork(returnValue, resolve6, reject) {
+      function recursivelyFlushAsyncActWork(returnValue, resolve7, reject) {
         var queue = ReactSharedInternals.actQueue;
         if (null !== queue)
           if (0 !== queue.length)
             try {
               flushActQueue(queue);
               enqueueTask(function() {
-                return recursivelyFlushAsyncActWork(returnValue, resolve6, reject);
+                return recursivelyFlushAsyncActWork(returnValue, resolve7, reject);
               });
               return;
             } catch (error) {
               ReactSharedInternals.thrownErrors.push(error);
             }
           else ReactSharedInternals.actQueue = null;
-        0 < ReactSharedInternals.thrownErrors.length ? (queue = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, reject(queue)) : resolve6(returnValue);
+        0 < ReactSharedInternals.thrownErrors.length ? (queue = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, reject(queue)) : resolve7(returnValue);
       }
       function flushActQueue(queue) {
         if (!isFlushing) {
@@ -1150,7 +1150,7 @@ var require_react_development = __commonJS({
             ));
           });
           return {
-            then: function(resolve6, reject) {
+            then: function(resolve7, reject) {
               didAwaitActCall = true;
               thenable.then(
                 function(returnValue) {
@@ -1160,7 +1160,7 @@ var require_react_development = __commonJS({
                       flushActQueue(queue), enqueueTask(function() {
                         return recursivelyFlushAsyncActWork(
                           returnValue,
-                          resolve6,
+                          resolve7,
                           reject
                         );
                       });
@@ -1174,7 +1174,7 @@ var require_react_development = __commonJS({
                       ReactSharedInternals.thrownErrors.length = 0;
                       reject(_thrownError);
                     }
-                  } else resolve6(returnValue);
+                  } else resolve7(returnValue);
                 },
                 function(error) {
                   popActScope(prevActQueue, prevActScopeDepth);
@@ -1196,15 +1196,15 @@ var require_react_development = __commonJS({
         if (0 < ReactSharedInternals.thrownErrors.length)
           throw callback = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, callback;
         return {
-          then: function(resolve6, reject) {
+          then: function(resolve7, reject) {
             didAwaitActCall = true;
             0 === prevActScopeDepth ? (ReactSharedInternals.actQueue = queue, enqueueTask(function() {
               return recursivelyFlushAsyncActWork(
                 returnValue$jscomp$0,
-                resolve6,
+                resolve7,
                 reject
               );
-            })) : resolve6(returnValue$jscomp$0);
+            })) : resolve7(returnValue$jscomp$0);
           }
         };
       };
@@ -12991,7 +12991,7 @@ A.finished.finally(function(){document.__reactViewTransition===A&&(document.__re
       };
     }
     exports2.prerender = function(children, options) {
-      return new Promise(function(resolve6, reject) {
+      return new Promise(function(resolve7, reject) {
         var onHeaders = options ? options.onHeaders : void 0, onHeadersImpl;
         onHeaders && (onHeadersImpl = function(headersDescriptor) {
           onHeaders(new Headers(headersDescriptor));
@@ -13035,7 +13035,7 @@ A.finished.finally(function(){document.__reactViewTransition===A&&(document.__re
               { highWaterMark: 0 }
             );
             stream2 = { postponed: getPostponedState(request), prelude: stream2 };
-            resolve6(stream2);
+            resolve7(stream2);
           },
           void 0,
           void 0,
@@ -13046,7 +13046,7 @@ A.finished.finally(function(){document.__reactViewTransition===A&&(document.__re
       });
     };
     exports2.prerenderToNodeStream = function(children, options) {
-      return new Promise(function(resolve6, reject) {
+      return new Promise(function(resolve7, reject) {
         var resumableState = createResumableState(
           options ? options.identifierPrefix : void 0,
           options ? options.unstable_externalRuntimeSrc : void 0,
@@ -13078,7 +13078,7 @@ A.finished.finally(function(){document.__reactViewTransition===A&&(document.__re
               postponed: getPostponedState(request),
               prelude: readable
             };
-            resolve6(readable);
+            resolve7(readable);
           },
           void 0,
           void 0,
@@ -13123,7 +13123,7 @@ A.finished.finally(function(){document.__reactViewTransition===A&&(document.__re
       };
     };
     exports2.renderToReadableStream = function(children, options) {
-      return new Promise(function(resolve6, reject) {
+      return new Promise(function(resolve7, reject) {
         var onFatalError, onAllReady, allReady = new Promise(function(res, rej) {
           onAllReady = res;
           onFatalError = rej;
@@ -13173,7 +13173,7 @@ A.finished.finally(function(){document.__reactViewTransition===A&&(document.__re
               { highWaterMark: 0 }
             );
             stream2.allReady = allReady;
-            resolve6(stream2);
+            resolve7(stream2);
           },
           function(error) {
             allReady.catch(function() {
@@ -13188,7 +13188,7 @@ A.finished.finally(function(){document.__reactViewTransition===A&&(document.__re
       });
     };
     exports2.resume = function(children, postponedState, options) {
-      return new Promise(function(resolve6, reject) {
+      return new Promise(function(resolve7, reject) {
         var onFatalError, onAllReady, allReady = new Promise(function(res, rej) {
           onAllReady = res;
           onFatalError = rej;
@@ -13226,7 +13226,7 @@ A.finished.finally(function(){document.__reactViewTransition===A&&(document.__re
               { highWaterMark: 0 }
             );
             stream2.allReady = allReady;
-            resolve6(stream2);
+            resolve7(stream2);
           },
           function(error) {
             allReady.catch(function() {
@@ -13240,7 +13240,7 @@ A.finished.finally(function(){document.__reactViewTransition===A&&(document.__re
       });
     };
     exports2.resumeAndPrerender = function(children, postponedState, options) {
-      return new Promise(function(resolve6, reject) {
+      return new Promise(function(resolve7, reject) {
         var request = resumeAndPrerenderRequest(
           children,
           postponedState,
@@ -13272,7 +13272,7 @@ A.finished.finally(function(){document.__reactViewTransition===A&&(document.__re
               { highWaterMark: 0 }
             );
             stream2 = { postponed: getPostponedState(request), prelude: stream2 };
-            resolve6(stream2);
+            resolve7(stream2);
           },
           void 0,
           void 0,
@@ -13283,7 +13283,7 @@ A.finished.finally(function(){document.__reactViewTransition===A&&(document.__re
       });
     };
     exports2.resumeAndPrerenderToNodeStream = function(children, postponedState, options) {
-      return new Promise(function(resolve6, reject) {
+      return new Promise(function(resolve7, reject) {
         var request = resumeAndPrerenderRequest(
           children,
           postponedState,
@@ -13304,7 +13304,7 @@ A.finished.finally(function(){document.__reactViewTransition===A&&(document.__re
               }
             }), writable = createFakeWritableFromReadable(readable);
             readable = { postponed: getPostponedState(request), prelude: readable };
-            resolve6(readable);
+            resolve7(readable);
           },
           void 0,
           void 0,
@@ -28776,7 +28776,7 @@ A.finished.finally(function(){document.__reactViewTransition===A&&(document.__re
       ensureCorrectIsomorphicReactVersion();
       ensureCorrectIsomorphicReactVersion();
       exports2.prerender = function(children, options) {
-        return new Promise(function(resolve6, reject) {
+        return new Promise(function(resolve7, reject) {
           var onHeaders = options ? options.onHeaders : void 0, onHeadersImpl;
           onHeaders && (onHeadersImpl = function(headersDescriptor) {
             onHeaders(new Headers(headersDescriptor));
@@ -28825,7 +28825,7 @@ A.finished.finally(function(){document.__reactViewTransition===A&&(document.__re
                 postponed: getPostponedState(request),
                 prelude: stream2
               };
-              resolve6(stream2);
+              resolve7(stream2);
             },
             void 0,
             void 0,
@@ -28836,7 +28836,7 @@ A.finished.finally(function(){document.__reactViewTransition===A&&(document.__re
         });
       };
       exports2.prerenderToNodeStream = function(children, options) {
-        return new Promise(function(resolve6, reject) {
+        return new Promise(function(resolve7, reject) {
           var resumableState = createResumableState(
             options ? options.identifierPrefix : void 0,
             options ? options.unstable_externalRuntimeSrc : void 0,
@@ -28868,7 +28868,7 @@ A.finished.finally(function(){document.__reactViewTransition===A&&(document.__re
                 postponed: getPostponedState(request),
                 prelude: readable
               };
-              resolve6(readable);
+              resolve7(readable);
             },
             void 0,
             void 0,
@@ -28913,7 +28913,7 @@ A.finished.finally(function(){document.__reactViewTransition===A&&(document.__re
         };
       };
       exports2.renderToReadableStream = function(children, options) {
-        return new Promise(function(resolve6, reject) {
+        return new Promise(function(resolve7, reject) {
           var onFatalError, onAllReady, allReady = new Promise(function(res, rej) {
             onAllReady = res;
             onFatalError = rej;
@@ -28963,7 +28963,7 @@ A.finished.finally(function(){document.__reactViewTransition===A&&(document.__re
                 { highWaterMark: 0 }
               );
               stream2.allReady = allReady;
-              resolve6(stream2);
+              resolve7(stream2);
             },
             function(error) {
               allReady.catch(function() {
@@ -28978,7 +28978,7 @@ A.finished.finally(function(){document.__reactViewTransition===A&&(document.__re
         });
       };
       exports2.resume = function(children, postponedState, options) {
-        return new Promise(function(resolve6, reject) {
+        return new Promise(function(resolve7, reject) {
           var onFatalError, onAllReady, allReady = new Promise(function(res, rej) {
             onAllReady = res;
             onFatalError = rej;
@@ -29016,7 +29016,7 @@ A.finished.finally(function(){document.__reactViewTransition===A&&(document.__re
                 { highWaterMark: 0 }
               );
               stream2.allReady = allReady;
-              resolve6(stream2);
+              resolve7(stream2);
             },
             function(error) {
               allReady.catch(function() {
@@ -29030,7 +29030,7 @@ A.finished.finally(function(){document.__reactViewTransition===A&&(document.__re
         });
       };
       exports2.resumeAndPrerender = function(children, postponedState, options) {
-        return new Promise(function(resolve6, reject) {
+        return new Promise(function(resolve7, reject) {
           var request = resumeAndPrerenderRequest(
             children,
             postponedState,
@@ -29064,7 +29064,7 @@ A.finished.finally(function(){document.__reactViewTransition===A&&(document.__re
                 { highWaterMark: 0 }
               );
               stream2 = { postponed: getPostponedState(request), prelude: stream2 };
-              resolve6(stream2);
+              resolve7(stream2);
             },
             void 0,
             void 0,
@@ -29075,7 +29075,7 @@ A.finished.finally(function(){document.__reactViewTransition===A&&(document.__re
         });
       };
       exports2.resumeAndPrerenderToNodeStream = function(children, postponedState, options) {
-        return new Promise(function(resolve6, reject) {
+        return new Promise(function(resolve7, reject) {
           var request = resumeAndPrerenderRequest(
             children,
             postponedState,
@@ -29099,7 +29099,7 @@ A.finished.finally(function(){document.__reactViewTransition===A&&(document.__re
                 postponed: getPostponedState(request),
                 prelude: readable
               };
-              resolve6(readable);
+              resolve7(readable);
             },
             void 0,
             void 0,
@@ -29482,9 +29482,9 @@ var require_jsx_runtime = __commonJS({
 
 // src/cli.ts
 var import_cross_spawn = __toESM(require("cross-spawn"));
-var import_fs8 = require("fs");
-var import_os5 = require("os");
-var import_path8 = require("path");
+var import_fs9 = require("fs");
+var import_os6 = require("os");
+var import_path9 = require("path");
 
 // src/audit.ts
 var import_fs = require("fs");
@@ -29502,11 +29502,12 @@ function writeAudit(event, homeDir = (0, import_os.homedir)()) {
 }
 
 // src/composition.ts
-var import_os2 = require("os");
+var import_os3 = require("os");
 
 // src/config.ts
 var import_fs2 = require("fs");
 var import_path2 = require("path");
+var import_os2 = require("os");
 var CONFIG_FILE = "mx-env.config.json";
 var GLOBAL_CONFIG_DIR = ".mx-env";
 var GLOBAL_CONFIG_FILE = "config.json";
@@ -29534,7 +29535,7 @@ function loadConfigAt(path) {
 }
 function loadConfigLayers(options = {}) {
   const cwd = options.cwd || process.cwd();
-  const homeDir = options.homeDir || (0, import_path2.homedir)();
+  const homeDir = options.homeDir || (0, import_os2.homedir)();
   const globalDir = (0, import_path2.resolve)(homeDir, GLOBAL_CONFIG_DIR);
   return {
     global: loadConfigAt((0, import_path2.resolve)(globalDir, GLOBAL_CONFIG_FILE)),
@@ -29549,7 +29550,7 @@ function normalizeProfile(input) {
     ...input?.extends ? { extends: input.extends } : {}
   };
 }
-function expandHomePath(path, homeDir = (0, import_path2.homedir)()) {
+function expandHomePath(path, homeDir = (0, import_os2.homedir)()) {
   if (path === "~") return homeDir;
   if (path.startsWith("~/")) return (0, import_path2.resolve)(homeDir, path.slice(2));
   return path;
@@ -29580,6 +29581,14 @@ function validateConfig(config, label = CONFIG_FILE) {
         if (!source.project || !source.config) errors.push(`${label}: Doppler source "${name}" needs project and config`);
         if (source.optional) errors.push(`${label}: remote source "${name}" cannot be optional`);
         break;
+      case "plugin":
+        if (typeof source.plugin !== "string" || !/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(source.plugin)) {
+          errors.push(`${label}: plugin source "${name}" needs a plugin name (letters, digits, ".", "_", "-")`);
+        }
+        if (!Array.isArray(source.keys) || !source.keys.length || source.keys.some((key) => typeof key !== "string" || !key)) {
+          errors.push(`${label}: plugin source "${name}" needs at least one key`);
+        }
+        break;
       default:
         errors.push(`${label}: source "${name}" has an unsupported provider`);
     }
@@ -29910,6 +29919,31 @@ function resolveDoppler(entry, source, context) {
 function parseDotenvText(text) {
   return (0, import_dotenv3.parse)(text);
 }
+var PLUGIN_TIMEOUT_MS = 3e4;
+function resolvePlugin(entry, source, context) {
+  const command = `mx-env-provider-${source.plugin}`;
+  const values = {};
+  for (const key of source.keys) {
+    let output;
+    try {
+      output = (0, import_child_process2.execFileSync)(command, [key], {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "pipe"],
+        env: { ...process.env, ...context.environment },
+        timeout: PLUGIN_TIMEOUT_MS
+      });
+    } catch (error) {
+      if (error?.code === "ENOENT") {
+        if (source.optional) return { name: entry.name, provider: source.provider, values: {}, availability: "missing-optional" };
+        throw new SourceError(entry.name, source.provider, `[morphix-env] plugin source "${entry.name}" needs ${command} on PATH.`);
+      }
+      const reason = typeof error?.code === "string" ? error.code : `exit ${error?.status ?? "unknown"}`;
+      throw new SourceError(entry.name, source.provider, `[morphix-env] plugin source "${entry.name}" failed for key "${key}" (${reason}).`);
+    }
+    values[key] = output.endsWith("\r\n") ? output.slice(0, -2) : output.endsWith("\n") ? output.slice(0, -1) : output;
+  }
+  return { name: entry.name, provider: source.provider, values, availability: "loaded" };
+}
 async function loadSource(entry, context) {
   switch (entry.source.provider) {
     case "local":
@@ -29922,6 +29956,8 @@ async function loadSource(entry, context) {
       return resolveKeychain(entry, entry.source);
     case "doppler":
       return resolveDoppler(entry, entry.source, context);
+    case "plugin":
+      return resolvePlugin(entry, entry.source, context);
   }
 }
 
@@ -29936,6 +29972,9 @@ var CompositionError = class extends Error {
     this.name = "CompositionError";
   }
 };
+function collectRedactionValues(environment, provenance) {
+  return [...new Set(Object.entries(provenance).filter(([key]) => !isPublicKey(key) && Boolean(environment[key])).map(([key]) => environment[key]).filter(Boolean))];
+}
 function declaredEntries(loaded) {
   return new Map(Object.entries(loaded.config.sources || {}).map(([name, source]) => [name, {
     name,
@@ -30045,7 +30084,7 @@ async function composeEnvironment(layers, options = {}) {
   const environment = { ...options.baseEnvironment || process.env };
   const owner = /* @__PURE__ */ new Map();
   const sourceStatuses = [];
-  const homeDir = options.homeDir || (0, import_os2.homedir)();
+  const homeDir = options.homeDir || (0, import_os3.homedir)();
   for (let precedence = 0; precedence < entries.length; precedence++) {
     const entry = entries[precedence];
     const loaded = await loadSource(entry, {
@@ -30078,13 +30117,14 @@ async function composeEnvironment(layers, options = {}) {
       });
     }
   }
+  const provenance = Object.fromEntries(owner);
   return {
     environment,
     profileName,
     sourceStatuses,
-    provenance: Object.fromEntries(owner),
+    provenance,
     sourceEntries: entries,
-    redactionValues: [...new Set([...owner.entries()].filter(([key]) => !isPublicKey(key) && Boolean(environment[key])).map(([key]) => environment[key]).filter(Boolean))]
+    redactionValues: collectRedactionValues(environment, provenance)
   };
 }
 
@@ -30092,7 +30132,7 @@ async function composeEnvironment(layers, options = {}) {
 var import_child_process3 = require("child_process");
 var import_http = require("http");
 var import_fs6 = require("fs");
-var import_os3 = require("os");
+var import_os4 = require("os");
 var import_path6 = require("path");
 var import_crypto = require("crypto");
 
@@ -36909,7 +36949,7 @@ function localFile(entry, fileIndex = 0) {
   const source = entry.source;
   if (source.provider !== "local" && source.provider !== "dotenvx") throw new Error("Source does not use files");
   const raw = source.files[fileIndex];
-  const expanded = expandHomePath(raw, (0, import_os3.homedir)());
+  const expanded = expandHomePath(raw, (0, import_os4.homedir)());
   return (0, import_path6.isAbsolute)(expanded) ? expanded : (0, import_path6.resolve)(entry.baseDir, expanded);
 }
 function sourceUrl(entry) {
@@ -37061,14 +37101,14 @@ async function startEditorServer(encodedState) {
   });
   const closeTimer = setTimeout(() => server.close(), EDITOR_LIFETIME_MS);
   closeTimer.unref();
-  await new Promise((resolve6, reject) => {
+  await new Promise((resolve7, reject) => {
     server.once("error", reject);
     server.listen(0, "127.0.0.1", () => {
       const address = server.address();
       if (!address || typeof address === "string") return reject(new Error("Editor did not receive a loopback port"));
       process.stdout.write(`http://127.0.0.1:${address.port}${editorPath(state)}
 `);
-      resolve6();
+      resolve7();
     });
   });
 }
@@ -37089,7 +37129,7 @@ async function launchEditor(entryScript, composition, selectedSource) {
     detached: true,
     stdio: ["ignore", "pipe", "ignore"]
   });
-  const url = await new Promise((resolve6, reject) => {
+  const url = await new Promise((resolve7, reject) => {
     const timer = setTimeout(() => reject(new Error("[morphix-env] Timed out starting local editor.")), 5e3);
     child.once("error", () => {
       clearTimeout(timer);
@@ -37099,7 +37139,7 @@ async function launchEditor(entryScript, composition, selectedSource) {
       clearTimeout(timer);
       const url2 = chunk.toString("utf8").trim();
       child.stdout?.destroy();
-      resolve6(url2);
+      resolve7(url2);
     });
   });
   child.unref();
@@ -37182,15 +37222,86 @@ var StreamingRedactor = class {
   }
 };
 
+// src/refs.ts
+var MX_ENV_REFERENCE_SOURCE = "mx-env:\\/\\/([A-Za-z0-9][A-Za-z0-9_-]*)\\/([A-Za-z0-9_][A-Za-z0-9_.-]*)";
+function referencePattern() {
+  return new RegExp(MX_ENV_REFERENCE_SOURCE, "g");
+}
+function findMxEnvReferences(text) {
+  const found = /* @__PURE__ */ new Map();
+  for (const match of text.matchAll(referencePattern())) {
+    const reference = { profile: match[1], key: match[2] };
+    found.set(`${reference.profile}/${reference.key}`, reference);
+  }
+  return [...found.values()];
+}
+function hasMxEnvReference(text) {
+  return referencePattern().test(text);
+}
+var ReferenceResolver = class {
+  constructor(layers, composeOptions2) {
+    this.layers = layers;
+    this.composeOptions = composeOptions2;
+    this.compositions = /* @__PURE__ */ new Map();
+  }
+  compose(profile) {
+    let pending = this.compositions.get(profile);
+    if (!pending) {
+      pending = composeEnvironment(this.layers, { ...this.composeOptions, profile });
+      this.compositions.set(profile, pending);
+    }
+    return pending;
+  }
+  /**
+   * The value of KEY as `profile` composes it, resolving nested references.
+   * The chain carries `profile/key` tokens of the current resolution path so
+   * only a genuine loop (the same key re-entered) is a cycle — a nested lookup
+   * of a different key in the same profile stays legal.
+   */
+  async valueOf(profile, key, chain = []) {
+    const token = `${profile}/${key}`;
+    if (chain.includes(token)) return { missing: { profile, key, reason: "cycle" } };
+    let composition;
+    try {
+      composition = await this.compose(profile);
+    } catch {
+      return { missing: { profile, key, reason: "missing" } };
+    }
+    const raw = composition.environment[key];
+    if (raw === void 0 || raw === null) return { missing: { profile, key, reason: "missing" } };
+    if (!hasMxEnvReference(raw)) return { value: raw };
+    const resolved = await this.resolveText(raw, [...chain, token]);
+    if (resolved.missing.length) return { missing: resolved.missing[0] };
+    return { value: resolved.text };
+  }
+  /** Substitutes every resolvable reference; unresolvable ones stay literal. */
+  async resolveText(text, chain = []) {
+    const references = findMxEnvReferences(text);
+    if (!references.length) return { text, missing: [] };
+    const resolved = await Promise.all(references.map(async (reference) => ({
+      reference,
+      result: await this.valueOf(reference.profile, reference.key, chain)
+    })));
+    const values = /* @__PURE__ */ new Map();
+    const missing = [];
+    for (const { reference, result } of resolved) {
+      if (result.value !== void 0) values.set(`${reference.profile}/${reference.key}`, result.value);
+      else if (result.missing) missing.push(result.missing);
+    }
+    const output = text.replace(referencePattern(), (match, profile, key) => values.get(`${profile}/${key}`) ?? match);
+    return { text: output, missing };
+  }
+};
+
 // src/skill.ts
 var import_fs7 = require("fs");
-var import_os4 = require("os");
+var import_os5 = require("os");
 var import_path7 = require("path");
 var SKILL_TARGETS = ["global", "project", "trellis"];
 function resolveSkillPath(target) {
   if (target === "project") return (0, import_path7.join)(process.cwd(), ".claude", "skills", "morphix-env", "SKILL.md");
-  if (target === "trellis") return (0, import_path7.join)((0, import_os4.homedir)(), ".trellis", "skills", "morphix-env", "SKILL.md");
-  return (0, import_path7.join)((0, import_os4.homedir)(), ".claude", "skills", "morphix-env", "SKILL.md");
+  if (target === "trellis") return (0, import_path7.join)((0, import_os5.homedir)(), ".trellis", "skills", "morphix-env", "SKILL.md");
+  return (0, import_path7.join)((0, import_os5.homedir)(), ".claude", "skills", "morphix-env", "SKILL.md");
 }
 function targetHint(target) {
   if (target === "project") {
@@ -37252,10 +37363,161 @@ function cmdSkill(subcommand, options) {
   return 0;
 }
 
+// src/serve.ts
+var import_http2 = require("http");
+var import_crypto2 = require("crypto");
+function authorized(req, token) {
+  const header = req.headers.authorization;
+  const presented = typeof header === "string" && header.startsWith("Bearer ") ? Buffer.from(header.slice("Bearer ".length)) : Buffer.alloc(0);
+  return presented.length === token.length && (0, import_crypto2.timingSafeEqual)(presented, token);
+}
+async function startSecretServer(values) {
+  const token = (0, import_crypto2.randomBytes)(24).toString("base64url");
+  const tokenBuffer = Buffer.from(token);
+  const server = (0, import_http2.createServer)((req, res) => {
+    if (!authorized(req, tokenBuffer)) {
+      res.writeHead(401, { "Content-Type": "text/plain; charset=utf-8", "Cache-Control": "no-store" });
+      res.end("unauthorized");
+      return;
+    }
+    const path = (req.url || "").split("?")[0];
+    if (req.method !== "GET") {
+      res.writeHead(405, { "Content-Type": "text/plain; charset=utf-8", "Cache-Control": "no-store" });
+      res.end("method not allowed");
+      return;
+    }
+    const match = /^\/key\/(.+)$/.exec(path);
+    if (!match) {
+      res.writeHead(404, { "Content-Type": "text/plain; charset=utf-8", "Cache-Control": "no-store" });
+      res.end("not found");
+      return;
+    }
+    let key;
+    try {
+      key = decodeURIComponent(match[1]);
+    } catch {
+      res.writeHead(400, { "Content-Type": "text/plain; charset=utf-8", "Cache-Control": "no-store" });
+      res.end("bad request");
+      return;
+    }
+    if (!Object.prototype.hasOwnProperty.call(values, key)) {
+      res.writeHead(404, { "Content-Type": "text/plain; charset=utf-8", "Cache-Control": "no-store" });
+      res.end("unknown key");
+      return;
+    }
+    res.writeHead(200, { "Content-Type": "text/plain; charset=utf-8", "Cache-Control": "no-store" });
+    res.end(values[key]);
+  });
+  await new Promise((resolvePromise, reject) => {
+    server.once("error", reject);
+    server.listen(0, "127.0.0.1", () => {
+      server.removeListener("error", reject);
+      server.on("error", (error) => {
+        console.error(`[morphix-env] Secret server error: ${error instanceof Error ? error.message : "unknown"}`);
+      });
+      resolvePromise();
+    });
+  });
+  const address = server.address();
+  if (!address || typeof address === "string") {
+    server.close();
+    throw new Error("[morphix-env] Secret server did not receive a loopback port.");
+  }
+  let closed = false;
+  return {
+    endpoint: `http://127.0.0.1:${address.port}`,
+    token,
+    close: () => {
+      if (closed) return;
+      closed = true;
+      server.close();
+      const withConnections = server;
+      if (typeof withConnections.closeAllConnections === "function") withConnections.closeAllConnections();
+    }
+  };
+}
+
+// src/template.ts
+var import_child_process4 = require("child_process");
+var import_fs8 = require("fs");
+var import_path8 = require("path");
+function shellQuote(value) {
+  return `'${value.replace(/'/g, "'\\''")}'`;
+}
+function isShellIdentifier(key) {
+  return /^[A-Za-z_][A-Za-z0-9_]*$/.test(key);
+}
+function findTemplateAnomalies(text) {
+  const anomalies = [];
+  const dollarDollar = text.indexOf("$$");
+  if (dollarDollar >= 0) {
+    anomalies.push(`Escaped dollar $$ at offset ${dollarDollar} is not interpolated; left literal.`);
+  }
+  let index2 = text.indexOf("${");
+  while (index2 >= 0) {
+    const rest = text.slice(index2);
+    if (/^\$\{[A-Za-z_][A-Za-z0-9_]*\}/.test(rest)) {
+    } else if (/^\$\{[A-Za-z_][A-Za-z0-9_]*[:+=-]/.test(rest)) {
+      anomalies.push(`Unsupported \${...} modifier or default at offset ${index2}; only \${NAME} is substituted \u2014 left literal.`);
+    } else {
+      anomalies.push(`Unclosed or invalid \${ at offset ${index2}; left literal.`);
+    }
+    index2 = text.indexOf("${", index2 + 2);
+  }
+  return anomalies;
+}
+function templateVariablePattern() {
+  return /\$\{([A-Za-z_][A-Za-z0-9_]*)\}/g;
+}
+function findTemplateVariables(text) {
+  const names = /* @__PURE__ */ new Set();
+  for (const match of text.matchAll(templateVariablePattern())) names.add(match[1]);
+  return [...names];
+}
+function renderTemplate(text, environment) {
+  const missing = /* @__PURE__ */ new Set();
+  const output = text.replace(templateVariablePattern(), (match, name) => {
+    const value = environment[name];
+    if (value === void 0 || value === null) {
+      missing.add(name);
+      return match;
+    }
+    return value;
+  });
+  return { output, missing: [...missing] };
+}
+function writePrivateFile(path, content) {
+  const absolute = (0, import_path8.resolve)(path);
+  (0, import_fs8.mkdirSync)((0, import_path8.dirname)(absolute), { recursive: true, mode: 448 });
+  (0, import_fs8.writeFileSync)(absolute, content, { mode: 384 });
+  (0, import_fs8.chmodSync)(absolute, 384);
+}
+function gitOutputStatus(path) {
+  const absolute = (0, import_path8.resolve)(path);
+  const cwd = (0, import_path8.dirname)(absolute);
+  const name = (0, import_path8.basename)(absolute);
+  const inside = (0, import_child_process4.spawnSync)("git", ["rev-parse", "--is-inside-work-tree"], { cwd, encoding: "utf8" });
+  if (inside.status !== 0) return "outside-repo";
+  const tracked = (0, import_child_process4.spawnSync)("git", ["ls-files", "--error-unmatch", "--", name], { cwd, encoding: "utf8" });
+  if (tracked.status === 0) return "tracked";
+  const ignored = (0, import_child_process4.spawnSync)("git", ["check-ignore", "-q", "--", name], { cwd, encoding: "utf8" });
+  if (ignored.status === 0) return "ignored";
+  if (ignored.status === 1) return "untracked";
+  return "outside-repo";
+}
+function warnOutputGitRisk(path) {
+  const status = gitOutputStatus(path);
+  if (status === "tracked") {
+    console.warn(`[morphix-env] Warning: ${path} is tracked by git; a rendered value could be committed. Add it to .gitignore and untrack it.`);
+  } else if (status === "untracked") {
+    console.warn(`[morphix-env] Warning: ${path} is not git-ignored; add it to .gitignore before committing.`);
+  }
+}
+
 // package.json
 var package_default = {
   name: "morphix-env",
-  version: "0.7.1",
+  version: "0.8.0",
   description: "Secret composition CLI \u2014 Infisical, Doppler, macOS Keychain, dotenvx, and local files stay value owners; composes them into one value-safe child environment and ships a built-in Agent Skill (mx-env skill install).",
   author: "MorphixAI <dev@morphixai.com>",
   homepage: "https://github.com/Morphicai/morphix-env#readme",
@@ -37270,9 +37532,22 @@ var package_default = {
     "morphix-env": "./dist/cli.js",
     "mx-env": "./dist/cli.js"
   },
+  main: "./dist/index.js",
+  types: "./dist/index.d.ts",
+  exports: {
+    ".": {
+      types: "./dist/index.d.ts",
+      default: "./dist/index.js"
+    },
+    "./cli": {
+      types: "./dist/cli.d.ts",
+      default: "./dist/cli.js"
+    },
+    "./package.json": "./package.json"
+  },
   scripts: {
-    build: "node scripts/build-editor-ui.mjs && tsup src/cli.ts --format cjs --dts --clean --external keytar && node scripts/copy-skill.mjs",
-    dev: "node scripts/build-editor-ui.mjs && tsup src/cli.ts --format cjs --watch",
+    build: "node scripts/build-editor-ui.mjs && tsup src/cli.ts src/index.ts --format cjs --dts --clean --external keytar && node scripts/copy-skill.mjs",
+    dev: "node scripts/build-editor-ui.mjs && tsup src/cli.ts src/index.ts --format cjs --watch",
     pretest: "pnpm build",
     test: "vitest run",
     "test:watch": "vitest",
@@ -37334,6 +37609,7 @@ function parseArgs(argv) {
   const args = {
     command: "",
     subArgs: [],
+    positionals: [],
     envFiles: [],
     outFile: null,
     verbose: false,
@@ -37346,7 +37622,9 @@ function parseArgs(argv) {
     printEditorUrl: false,
     source: null,
     target: null,
-    force: false
+    force: false,
+    dryRun: false,
+    serve: false
   };
   let i = 2;
   const command = argv[i];
@@ -37385,28 +37663,39 @@ function parseArgs(argv) {
       if (argv[++i]) args.target = argv[i];
     } else if (arg === "--force") {
       args.force = true;
+    } else if (arg === "--dry-run") {
+      args.dryRun = true;
+    } else if (arg === "--serve") {
+      args.serve = true;
     } else if (args.command === "run") {
       args.subArgs = argv.slice(i);
       break;
+    } else if (!arg.startsWith("-")) {
+      args.positionals.push(arg);
     }
     i++;
   }
   return args;
 }
-function resolveComposition(args) {
-  const layers = loadConfigLayers({ cwd: process.cwd(), homeDir: (0, import_os5.homedir)() });
-  return composeEnvironment(layers, {
+function configLayers() {
+  return loadConfigLayers({ cwd: process.cwd(), homeDir: (0, import_os6.homedir)() });
+}
+function composeOptions(args) {
+  return {
     profile: args.profile,
     noGlobal: args.noGlobal,
     noInfisical: args.noInfisical,
     envName: args.env,
     allowInsecureGlobal: args.allowInsecureGlobal,
     envFiles: args.envFiles,
-    homeDir: (0, import_os5.homedir)()
-  });
+    homeDir: (0, import_os6.homedir)()
+  };
+}
+function resolveComposition(args) {
+  return composeEnvironment(configLayers(), composeOptions(args));
 }
 function generatedOptions(args) {
-  const config = loadConfigLayers({ cwd: process.cwd(), homeDir: (0, import_os5.homedir)() }).project.config;
+  const config = loadConfigLayers({ cwd: process.cwd(), homeDir: (0, import_os6.homedir)() }).project.config;
   return {
     outFile: args.outFile || config.generate?.out || "public/__env.js",
     filter: args.filter || config.generate?.filter || null
@@ -37415,12 +37704,12 @@ function generatedOptions(args) {
 function generateClientEnv(outFile, filter, environment) {
   let vars = extractPublicVars(environment);
   if (filter) vars = Object.fromEntries(Object.entries(vars).filter(([key]) => key.startsWith(filter)));
-  (0, import_fs8.mkdirSync)((0, import_path8.dirname)(outFile), { recursive: true });
-  (0, import_fs8.writeFileSync)(outFile, `window.__ENV=${JSON.stringify(vars)};`);
+  (0, import_fs9.mkdirSync)((0, import_path9.dirname)(outFile), { recursive: true });
+  (0, import_fs9.writeFileSync)(outFile, `window.__ENV=${JSON.stringify(vars)};`);
   console.log(`[morphix-env] Generated ${outFile} (${Object.keys(vars).length} client vars)`);
 }
 async function runChild(command, commandArgs, composition) {
-  return new Promise((resolve6) => {
+  return new Promise((resolve7) => {
     const child = (0, import_cross_spawn.default)(command, commandArgs, { env: composition.environment, stdio: ["inherit", "pipe", "pipe"] });
     const stdout = new StreamingRedactor(composition.redactionValues);
     const stderr = new StreamingRedactor(composition.redactionValues);
@@ -37428,14 +37717,14 @@ async function runChild(command, commandArgs, composition) {
     child.stderr?.on("data", (chunk) => process.stderr.write(stderr.write(chunk)));
     child.on("error", () => {
       console.error(`[morphix-env] Failed to execute: ${command}`);
-      resolve6(1);
+      resolve7(1);
     });
     child.on("close", (code) => {
       const stdoutFinal = stdout.flush();
       const stderrFinal = stderr.flush();
       if (stdoutFinal) process.stdout.write(stdoutFinal);
       if (stderrFinal) process.stderr.write(stderrFinal);
-      resolve6(code ?? 1);
+      resolve7(code ?? 1);
     });
   });
 }
@@ -37450,6 +37739,49 @@ function writeRunAudit(composition, startedAt, outcome, exitCode) {
     durationMs: Date.now() - startedAt
   });
 }
+async function startServeFor(composition, verbose) {
+  const values = {};
+  for (const key of Object.keys(composition.provenance)) {
+    const value = composition.environment[key];
+    if (value !== void 0) values[key] = value;
+  }
+  const server = await startSecretServer(values);
+  for (const key of Object.keys(values)) {
+    if (!isPublicKey(key)) delete composition.environment[key];
+  }
+  composition.environment.MXENV_ENDPOINT = server.endpoint;
+  composition.environment.MXENV_TOKEN = server.token;
+  composition.redactionValues = [.../* @__PURE__ */ new Set([...composition.redactionValues, server.token])];
+  if (verbose) {
+    console.error(`[morphix-env] Secret server listening on ${server.endpoint} (${Object.keys(values).length} keys; token is visible to the child only).`);
+  }
+  return server;
+}
+function warnUnresolvedReference(reference, context) {
+  console.warn(`[morphix-env] Unresolved mx-env://${reference.profile}/${reference.key} reference ${context} (${reference.reason}); left as-is.`);
+}
+async function resolveEnvironmentReferences(composition, args) {
+  const targets = Object.entries(composition.environment).filter((entry) => typeof entry[1] === "string" && hasMxEnvReference(entry[1]));
+  if (!targets.length) return;
+  const resolver = new ReferenceResolver(configLayers(), composeOptions(args));
+  const changed = [];
+  for (const [key, value] of targets) {
+    const resolved = await resolver.resolveText(value);
+    if (resolved.missing.length) {
+      for (const reference of resolved.missing) warnUnresolvedReference(reference, `in key "${key}"`);
+      continue;
+    }
+    composition.environment[key] = resolved.text;
+    changed.push(key);
+  }
+  if (changed.length) {
+    const extra = changed.map((key) => composition.environment[key]).filter((value) => Boolean(value));
+    composition.redactionValues = [.../* @__PURE__ */ new Set([
+      ...collectRedactionValues(composition.environment, composition.provenance),
+      ...extra
+    ])];
+  }
+}
 async function cmdRun(args) {
   if (!args.subArgs.length) {
     console.error("[morphix-env] No command specified. Usage: mx-env run -- <command>");
@@ -37462,18 +37794,72 @@ async function cmdRun(args) {
       console.log(`[morphix-env] ${source.name}: ${source.availability} (${source.keyCount} keys)`);
     }
   }
+  if (args.dryRun) {
+    console.log(`profile: ${composition.profileName}`);
+    for (const key of Object.keys(composition.provenance).sort()) console.log(`  ${key}`);
+    return 0;
+  }
+  await resolveEnvironmentReferences(composition, args);
   if (args.outFile || generatedOptions(args).outFile) {
     const { outFile, filter } = generatedOptions(args);
-    const configured = Boolean(args.outFile || loadConfigLayers({ cwd: process.cwd(), homeDir: (0, import_os5.homedir)() }).project.config.generate);
+    const configured = Boolean(args.outFile || loadConfigLayers({ cwd: process.cwd(), homeDir: (0, import_os6.homedir)() }).project.config.generate);
     if (configured) generateClientEnv(outFile, filter, composition.environment);
   }
   const [command, ...commandArgs] = args.subArgs;
-  const exitCode = await runChild(command, commandArgs, composition);
-  writeRunAudit(composition, startedAt, exitCode === 0 ? "success" : "failure", exitCode);
-  return exitCode;
+  const secretServer = args.serve ? await startServeFor(composition, args.verbose) : null;
+  try {
+    const exitCode = await runChild(command, commandArgs, composition);
+    writeRunAudit(composition, startedAt, exitCode === 0 ? "success" : "failure", exitCode);
+    return exitCode;
+  } finally {
+    secretServer?.close();
+  }
+}
+async function cmdFetch(args) {
+  const key = args.positionals[0];
+  if (!key) {
+    console.error("[morphix-env] Usage: mx-env fetch <key-name>");
+    return 1;
+  }
+  const endpoint = process.env.MXENV_ENDPOINT;
+  const token = process.env.MXENV_TOKEN;
+  if (!endpoint || !token) {
+    console.error('[morphix-env] mx-env fetch needs MXENV_ENDPOINT and MXENV_TOKEN; run it inside "mx-env run --serve -- <command>".');
+    return 1;
+  }
+  let endpointUrl;
+  try {
+    endpointUrl = new URL(endpoint);
+  } catch {
+    console.error("[morphix-env] MXENV_ENDPOINT is not a valid URL.");
+    return 1;
+  }
+  if (!["127.0.0.1", "localhost", "[::1]"].includes(endpointUrl.hostname)) {
+    console.error("[morphix-env] MXENV_ENDPOINT is not a loopback address; refusing to send the fetch token off-machine.");
+    return 1;
+  }
+  try {
+    const response = await fetch(`${endpoint}/key/${encodeURIComponent(key)}`, {
+      headers: { Authorization: `Bearer ${token}` }
+    });
+    if (response.ok) {
+      process.stdout.write(await response.text());
+      return 0;
+    }
+    if (response.status === 404) {
+      console.error(`[morphix-env] Unknown key on the secret server: ${key}`);
+      return 1;
+    }
+    console.error(`[morphix-env] Secret server rejected the request (HTTP ${response.status}).`);
+    return 1;
+  } catch {
+    console.error("[morphix-env] Secret server is unreachable; the parent process may have exited.");
+    return 1;
+  }
 }
 async function cmdGenerate(args) {
   const composition = await resolveComposition(args);
+  await resolveEnvironmentReferences(composition, args);
   const { outFile, filter } = generatedOptions(args);
   generateClientEnv(outFile, filter, composition.environment);
   if (args.verbose) {
@@ -37495,6 +37881,92 @@ async function cmdInspect(args) {
   }
   return 0;
 }
+async function cmdExport(args) {
+  const startedAt = Date.now();
+  const composition = await resolveComposition(args);
+  const keys = Object.keys(composition.provenance).sort();
+  if (args.dryRun) {
+    for (const key of keys) console.log(key);
+    return 0;
+  }
+  await resolveEnvironmentReferences(composition, args);
+  for (const key of keys) {
+    if (!isShellIdentifier(key)) {
+      console.warn(`[morphix-env] Warning: key "${key}" is not a valid shell identifier; skipped in export output.`);
+      continue;
+    }
+    console.log(`export ${key}=${shellQuote(composition.environment[key] ?? "")}`);
+  }
+  writeRunAudit(composition, startedAt, "success", 0);
+  return 0;
+}
+async function cmdRender(args) {
+  const startedAt = Date.now();
+  const [templatePath, outPath] = args.positionals;
+  if (!templatePath || !outPath) {
+    console.error("[morphix-env] Usage: mx-env render <template-file> <output-file> [options]");
+    return 1;
+  }
+  if (!(0, import_fs9.existsSync)(templatePath)) {
+    console.error(`[morphix-env] Template not found: ${templatePath}`);
+    return 1;
+  }
+  const template = (0, import_fs9.readFileSync)(templatePath, "utf8");
+  const composition = await resolveComposition(args);
+  const names = findTemplateVariables(template);
+  const missing = names.filter((name) => composition.environment[name] === void 0 || composition.environment[name] === null);
+  if (missing.length) console.warn(`[morphix-env] Missing variables: ${missing.join(", ")} (left unresolved)`);
+  for (const anomaly of findTemplateAnomalies(template)) console.warn(`[morphix-env] ${anomaly}`);
+  if (args.dryRun) {
+    for (const name of names) console.log(`${name}: ${missing.includes(name) ? "missing" : "resolved"}`);
+    return 0;
+  }
+  await resolveEnvironmentReferences(composition, args);
+  const { output } = renderTemplate(template, composition.environment);
+  warnOutputGitRisk(outPath);
+  writePrivateFile(outPath, output);
+  writeRunAudit(composition, startedAt, "success", 0);
+  console.log(`[morphix-env] Rendered ${templatePath} -> ${outPath} (${names.length} variables, ${missing.length} unresolved)`);
+  return 0;
+}
+async function cmdInject(args) {
+  const startedAt = Date.now();
+  const [templatePath, outPath] = args.positionals;
+  if (!templatePath || !outPath) {
+    console.error("[morphix-env] Usage: mx-env inject <template-file> <output-file> [options]");
+    return 1;
+  }
+  if (!(0, import_fs9.existsSync)(templatePath)) {
+    console.error(`[morphix-env] Template not found: ${templatePath}`);
+    return 1;
+  }
+  const template = (0, import_fs9.readFileSync)(templatePath, "utf8");
+  const resolver = new ReferenceResolver(configLayers(), composeOptions(args));
+  const references = findMxEnvReferences(template);
+  if (args.dryRun) {
+    for (const reference of references) {
+      const result = await resolver.valueOf(reference.profile, reference.key);
+      const status = result.value !== void 0 ? "resolved" : result.missing?.reason ?? "missing";
+      console.log(`${reference.profile}/${reference.key}: ${status}`);
+    }
+    return 0;
+  }
+  const resolved = await resolver.resolveText(template);
+  for (const reference of resolved.missing) warnUnresolvedReference(reference, `in ${templatePath}`);
+  warnOutputGitRisk(outPath);
+  writePrivateFile(outPath, resolved.text);
+  writeAudit({
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    profile: [...new Set(references.map((reference) => reference.profile))].join(",") || "none",
+    sources: [],
+    keys: [...new Set(references.map((reference) => reference.key))].sort(),
+    outcome: "success",
+    exitCode: 0,
+    durationMs: Date.now() - startedAt
+  });
+  console.log(`[morphix-env] Injected ${templatePath} -> ${outPath} (${references.length} references, ${resolved.missing.length} unresolved)`);
+  return 0;
+}
 async function cmdEdit(args) {
   if (!args.profile && !args.source) {
     console.error("[morphix-env] Specify --profile <name> or --source <name> to open the editor.");
@@ -37502,7 +37974,7 @@ async function cmdEdit(args) {
   }
   const composition = await resolveComposition(args);
   if (args.source && !composition.sourceEntries.some((entry) => entry.name === args.source)) {
-    const layers = loadConfigLayers({ cwd: process.cwd(), homeDir: (0, import_os5.homedir)() });
+    const layers = loadConfigLayers({ cwd: process.cwd(), homeDir: (0, import_os6.homedir)() });
     const declared = layers.project.config.sources?.[args.source] ? { source: layers.project.config.sources[args.source], baseDir: layers.project.baseDir } : !args.noGlobal && layers.global.config.sources?.[args.source] ? { source: layers.global.config.sources[args.source], baseDir: layers.global.baseDir } : null;
     if (!declared) {
       console.error(`[morphix-env] Unknown source "${args.source}".`);
@@ -37520,7 +37992,7 @@ async function cmdEdit(args) {
 }
 async function cmdDoc(args) {
   const composition = await resolveComposition(args);
-  const outFile = args.outFile || (0, import_path8.join)(process.cwd(), ".agents", "skills", "morphix-env", "SKILL.md");
+  const outFile = args.outFile || (0, import_path9.join)(process.cwd(), ".agents", "skills", "morphix-env", "SKILL.md");
   const keyRows = Object.entries(composition.provenance).sort(([a], [b]) => a.localeCompare(b)).map(([key, provenance]) => `| \`${key}\` | ${provenance.source} (${provenance.provider}) |`).join("\n") || "| _No resolved keys_ | \u2014 |";
   const skill = `---
 name: morphix-env
@@ -37554,18 +38026,18 @@ ${keyRows}
 
 Secret values and value prefixes do not belong in this Skill, command output, audit records, or conversation context.
 `;
-  (0, import_fs8.mkdirSync)((0, import_path8.dirname)(outFile), { recursive: true });
-  (0, import_fs8.writeFileSync)(outFile, skill, { mode: 384 });
+  (0, import_fs9.mkdirSync)((0, import_path9.dirname)(outFile), { recursive: true });
+  (0, import_fs9.writeFileSync)(outFile, skill, { mode: 384 });
   console.log(`[morphix-env] Generated value-free workflow Skill: ${outFile}`);
   return 0;
 }
 function cmdAudit(args) {
-  const file = (0, import_path8.join)((0, import_os5.homedir)(), ".mx-env", "audit", `${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}.jsonl`);
-  if (!(0, import_fs8.existsSync)(file)) {
+  const file = (0, import_path9.join)((0, import_os6.homedir)(), ".mx-env", "audit", `${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}.jsonl`);
+  if (!(0, import_fs9.existsSync)(file)) {
     console.log("[morphix-env] No audit events for today.");
     return 0;
   }
-  const lines = (0, import_fs8.readFileSync)(file, "utf8").trim().split("\n").filter(Boolean);
+  const lines = (0, import_fs9.readFileSync)(file, "utf8").trim().split("\n").filter(Boolean);
   const selected = args.subArgs[0] === "tail" ? lines.slice(-20) : lines;
   for (const line of selected) console.log(line);
   return 0;
@@ -37576,6 +38048,10 @@ morphix-env v${VERSION} \u2014 secret composition and environment delivery
 
 Usage:
   mx-env run [options] -- <command>       Compose env + execute command
+  mx-env fetch <key-name>                 Print one value from a run --serve secret server
+  mx-env export [options]                 Print eval-able export KEY='value' lines
+  mx-env render <template> <output>       Substitute \${VAR} into a file (mode 0600)
+  mx-env inject <template> <output>       Resolve mx-env:// references into a file (mode 0600)
   mx-env generate [options]               Generate public __env.js
   mx-env inspect [options]                Print key names, sources, and status only
   mx-env doc [options]                    Generate a value-free project Skill
@@ -37592,6 +38068,8 @@ Options:
   -e, --env <name>         Infisical environment override
   -o, --out <path>         Client __env.js output
   --filter <prefix>        Include public keys with this prefix
+  --serve                  Keep composed values out of env; serve them to the child over loopback
+  --dry-run                Report key/variable names only, never values
   --no-infisical           Do not load Infisical sources
   --no-global              Ignore ~/.mx-env/.env and ~/.mx-env/config.json
   --allow-insecure-global  Allow a global .env with permissive file mode
@@ -37608,6 +38086,14 @@ async function main() {
   switch (args.command) {
     case "run":
       return cmdRun(args);
+    case "fetch":
+      return cmdFetch(args);
+    case "export":
+      return cmdExport(args);
+    case "render":
+      return cmdRender(args);
+    case "inject":
+      return cmdInject(args);
     case "generate":
     case "gen":
       return cmdGenerate(args);