@adhdev/daemon-standalone 0.9.76-rc.2 → 0.9.76-rc.4

package/dist/index.js

@@ -9591,7 +9591,7 @@ var require_dist = __commonJS({
         };
       }
     };
-    var os6 = __toESM2(require("os"));
+    var os7 = __toESM2(require("os"));
     var path23 = __toESM2(require("path"));
     var net3 = __toESM2(require("net"));
     var import_crypto22 = require("crypto");
@@ -9604,7 +9604,7 @@ var require_dist = __commonJS({
       }
       return {
         kind: "unix",
-        path: path23.join(os6.tmpdir(), `${appName}-session-host.sock`)
+        path: path23.join(os7.tmpdir(), `${appName}-session-host.sock`)
       };
     }
     function serializeEnvelope3(envelope) {
@@ -9745,31 +9745,31 @@ var require_dist = __commonJS({
     var os22 = __toESM2(require("os"));
     var path32 = __toESM2(require("path"));
     function sanitizeSpawnEnv(baseEnv, overrides) {
-      const env = {};
+      const env2 = {};
       const source = { ...baseEnv, ...overrides || {} };
       for (const [key, value] of Object.entries(source)) {
         if (typeof value !== "string") continue;
-        env[key] = value;
+        env2[key] = value;
       }
-      for (const key of Object.keys(env)) {
+      for (const key of Object.keys(env2)) {
         if (key === "INIT_CWD" || key === "npm_command" || key === "npm_execpath" || key === "npm_node_execpath" || key.startsWith("npm_") || key.startsWith("npm_config_") || key.startsWith("npm_package_") || key.startsWith("npm_lifecycle_") || key.startsWith("PNPM_") || key.startsWith("YARN_") || key.startsWith("BUN_") || key.startsWith("VSCODE_") || key.startsWith("ELECTRON_")) {
-          delete env[key];
+          delete env2[key];
         }
       }
-      delete env.CODEX_THREAD_ID;
-      delete env.CODEX_INTERNAL_ORIGINATOR_OVERRIDE;
-      applyTerminalColorEnv(env);
-      return env;
+      delete env2.CODEX_THREAD_ID;
+      delete env2.CODEX_INTERNAL_ORIGINATOR_OVERRIDE;
+      applyTerminalColorEnv(env2);
+      return env2;
     }
-    function applyTerminalColorEnv(env) {
-      if (env.NO_COLOR) return;
-      if (!env.TERM || env.TERM === "xterm-color") {
-        env.TERM = "xterm-256color";
+    function applyTerminalColorEnv(env2) {
+      if (env2.NO_COLOR) return;
+      if (!env2.TERM || env2.TERM === "xterm-color") {
+        env2.TERM = "xterm-256color";
       }
-      if (!env.COLORTERM) env.COLORTERM = "truecolor";
+      if (!env2.COLORTERM) env2.COLORTERM = "truecolor";
       if (process.platform === "win32") {
-        if (!env.FORCE_COLOR) env.FORCE_COLOR = "1";
-        if (!env.CLICOLOR) env.CLICOLOR = "1";
+        if (!env2.FORCE_COLOR) env2.FORCE_COLOR = "1";
+        if (!env2.CLICOLOR) env2.CLICOLOR = "1";
       }
     }
     function ensureNodePtySpawnHelperPermissions(logFn) {
@@ -9792,6 +9792,548 @@ var require_dist = __commonJS({
   }
 });
 
+// ../../node_modules/chalk/source/vendor/ansi-styles/index.js
+function assembleStyles() {
+  const codes = /* @__PURE__ */ new Map();
+  for (const [groupName, group] of Object.entries(styles)) {
+    for (const [styleName, style] of Object.entries(group)) {
+      styles[styleName] = {
+        open: `\x1B[${style[0]}m`,
+        close: `\x1B[${style[1]}m`
+      };
+      group[styleName] = styles[styleName];
+      codes.set(style[0], style[1]);
+    }
+    Object.defineProperty(styles, groupName, {
+      value: group,
+      enumerable: false
+    });
+  }
+  Object.defineProperty(styles, "codes", {
+    value: codes,
+    enumerable: false
+  });
+  styles.color.close = "\x1B[39m";
+  styles.bgColor.close = "\x1B[49m";
+  styles.color.ansi = wrapAnsi16();
+  styles.color.ansi256 = wrapAnsi256();
+  styles.color.ansi16m = wrapAnsi16m();
+  styles.bgColor.ansi = wrapAnsi16(ANSI_BACKGROUND_OFFSET);
+  styles.bgColor.ansi256 = wrapAnsi256(ANSI_BACKGROUND_OFFSET);
+  styles.bgColor.ansi16m = wrapAnsi16m(ANSI_BACKGROUND_OFFSET);
+  Object.defineProperties(styles, {
+    rgbToAnsi256: {
+      value(red, green, blue) {
+        if (red === green && green === blue) {
+          if (red < 8) {
+            return 16;
+          }
+          if (red > 248) {
+            return 231;
+          }
+          return Math.round((red - 8) / 247 * 24) + 232;
+        }
+        return 16 + 36 * Math.round(red / 255 * 5) + 6 * Math.round(green / 255 * 5) + Math.round(blue / 255 * 5);
+      },
+      enumerable: false
+    },
+    hexToRgb: {
+      value(hex3) {
+        const matches = /[a-f\d]{6}|[a-f\d]{3}/i.exec(hex3.toString(16));
+        if (!matches) {
+          return [0, 0, 0];
+        }
+        let [colorString] = matches;
+        if (colorString.length === 3) {
+          colorString = [...colorString].map((character) => character + character).join("");
+        }
+        const integer2 = Number.parseInt(colorString, 16);
+        return [
+          /* eslint-disable no-bitwise */
+          integer2 >> 16 & 255,
+          integer2 >> 8 & 255,
+          integer2 & 255
+          /* eslint-enable no-bitwise */
+        ];
+      },
+      enumerable: false
+    },
+    hexToAnsi256: {
+      value: (hex3) => styles.rgbToAnsi256(...styles.hexToRgb(hex3)),
+      enumerable: false
+    },
+    ansi256ToAnsi: {
+      value(code) {
+        if (code < 8) {
+          return 30 + code;
+        }
+        if (code < 16) {
+          return 90 + (code - 8);
+        }
+        let red;
+        let green;
+        let blue;
+        if (code >= 232) {
+          red = ((code - 232) * 10 + 8) / 255;
+          green = red;
+          blue = red;
+        } else {
+          code -= 16;
+          const remainder = code % 36;
+          red = Math.floor(code / 36) / 5;
+          green = Math.floor(remainder / 6) / 5;
+          blue = remainder % 6 / 5;
+        }
+        const value = Math.max(red, green, blue) * 2;
+        if (value === 0) {
+          return 30;
+        }
+        let result = 30 + (Math.round(blue) << 2 | Math.round(green) << 1 | Math.round(red));
+        if (value === 2) {
+          result += 60;
+        }
+        return result;
+      },
+      enumerable: false
+    },
+    rgbToAnsi: {
+      value: (red, green, blue) => styles.ansi256ToAnsi(styles.rgbToAnsi256(red, green, blue)),
+      enumerable: false
+    },
+    hexToAnsi: {
+      value: (hex3) => styles.ansi256ToAnsi(styles.hexToAnsi256(hex3)),
+      enumerable: false
+    }
+  });
+  return styles;
+}
+var ANSI_BACKGROUND_OFFSET, wrapAnsi16, wrapAnsi256, wrapAnsi16m, styles, modifierNames, foregroundColorNames, backgroundColorNames, colorNames, ansiStyles, ansi_styles_default;
+var init_ansi_styles = __esm({
+  "../../node_modules/chalk/source/vendor/ansi-styles/index.js"() {
+    "use strict";
+    ANSI_BACKGROUND_OFFSET = 10;
+    wrapAnsi16 = (offset = 0) => (code) => `\x1B[${code + offset}m`;
+    wrapAnsi256 = (offset = 0) => (code) => `\x1B[${38 + offset};5;${code}m`;
+    wrapAnsi16m = (offset = 0) => (red, green, blue) => `\x1B[${38 + offset};2;${red};${green};${blue}m`;
+    styles = {
+      modifier: {
+        reset: [0, 0],
+        // 21 isn't widely supported and 22 does the same thing
+        bold: [1, 22],
+        dim: [2, 22],
+        italic: [3, 23],
+        underline: [4, 24],
+        overline: [53, 55],
+        inverse: [7, 27],
+        hidden: [8, 28],
+        strikethrough: [9, 29]
+      },
+      color: {
+        black: [30, 39],
+        red: [31, 39],
+        green: [32, 39],
+        yellow: [33, 39],
+        blue: [34, 39],
+        magenta: [35, 39],
+        cyan: [36, 39],
+        white: [37, 39],
+        // Bright color
+        blackBright: [90, 39],
+        gray: [90, 39],
+        // Alias of `blackBright`
+        grey: [90, 39],
+        // Alias of `blackBright`
+        redBright: [91, 39],
+        greenBright: [92, 39],
+        yellowBright: [93, 39],
+        blueBright: [94, 39],
+        magentaBright: [95, 39],
+        cyanBright: [96, 39],
+        whiteBright: [97, 39]
+      },
+      bgColor: {
+        bgBlack: [40, 49],
+        bgRed: [41, 49],
+        bgGreen: [42, 49],
+        bgYellow: [43, 49],
+        bgBlue: [44, 49],
+        bgMagenta: [45, 49],
+        bgCyan: [46, 49],
+        bgWhite: [47, 49],
+        // Bright color
+        bgBlackBright: [100, 49],
+        bgGray: [100, 49],
+        // Alias of `bgBlackBright`
+        bgGrey: [100, 49],
+        // Alias of `bgBlackBright`
+        bgRedBright: [101, 49],
+        bgGreenBright: [102, 49],
+        bgYellowBright: [103, 49],
+        bgBlueBright: [104, 49],
+        bgMagentaBright: [105, 49],
+        bgCyanBright: [106, 49],
+        bgWhiteBright: [107, 49]
+      }
+    };
+    modifierNames = Object.keys(styles.modifier);
+    foregroundColorNames = Object.keys(styles.color);
+    backgroundColorNames = Object.keys(styles.bgColor);
+    colorNames = [...foregroundColorNames, ...backgroundColorNames];
+    ansiStyles = assembleStyles();
+    ansi_styles_default = ansiStyles;
+  }
+});
+
+// ../../node_modules/chalk/source/vendor/supports-color/index.js
+function hasFlag(flag, argv = globalThis.Deno ? globalThis.Deno.args : import_node_process.default.argv) {
+  const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
+  const position = argv.indexOf(prefix + flag);
+  const terminatorPosition = argv.indexOf("--");
+  return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
+}
+function envForceColor() {
+  if ("FORCE_COLOR" in env) {
+    if (env.FORCE_COLOR === "true") {
+      return 1;
+    }
+    if (env.FORCE_COLOR === "false") {
+      return 0;
+    }
+    return env.FORCE_COLOR.length === 0 ? 1 : Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3);
+  }
+}
+function translateLevel(level) {
+  if (level === 0) {
+    return false;
+  }
+  return {
+    level,
+    hasBasic: true,
+    has256: level >= 2,
+    has16m: level >= 3
+  };
+}
+function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
+  const noFlagForceColor = envForceColor();
+  if (noFlagForceColor !== void 0) {
+    flagForceColor = noFlagForceColor;
+  }
+  const forceColor = sniffFlags ? flagForceColor : noFlagForceColor;
+  if (forceColor === 0) {
+    return 0;
+  }
+  if (sniffFlags) {
+    if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
+      return 3;
+    }
+    if (hasFlag("color=256")) {
+      return 2;
+    }
+  }
+  if ("TF_BUILD" in env && "AGENT_NAME" in env) {
+    return 1;
+  }
+  if (haveStream && !streamIsTTY && forceColor === void 0) {
+    return 0;
+  }
+  const min = forceColor || 0;
+  if (env.TERM === "dumb") {
+    return min;
+  }
+  if (import_node_process.default.platform === "win32") {
+    const osRelease = import_node_os.default.release().split(".");
+    if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
+      return Number(osRelease[2]) >= 14931 ? 3 : 2;
+    }
+    return 1;
+  }
+  if ("CI" in env) {
+    if (["GITHUB_ACTIONS", "GITEA_ACTIONS", "CIRCLECI"].some((key) => key in env)) {
+      return 3;
+    }
+    if (["TRAVIS", "APPVEYOR", "GITLAB_CI", "BUILDKITE", "DRONE"].some((sign) => sign in env) || env.CI_NAME === "codeship") {
+      return 1;
+    }
+    return min;
+  }
+  if ("TEAMCITY_VERSION" in env) {
+    return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
+  }
+  if (env.COLORTERM === "truecolor") {
+    return 3;
+  }
+  if (env.TERM === "xterm-kitty") {
+    return 3;
+  }
+  if (env.TERM === "xterm-ghostty") {
+    return 3;
+  }
+  if (env.TERM === "wezterm") {
+    return 3;
+  }
+  if ("TERM_PROGRAM" in env) {
+    const version2 = Number.parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
+    switch (env.TERM_PROGRAM) {
+      case "iTerm.app": {
+        return version2 >= 3 ? 3 : 2;
+      }
+      case "Apple_Terminal": {
+        return 2;
+      }
+    }
+  }
+  if (/-256(color)?$/i.test(env.TERM)) {
+    return 2;
+  }
+  if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
+    return 1;
+  }
+  if ("COLORTERM" in env) {
+    return 1;
+  }
+  return min;
+}
+function createSupportsColor(stream, options = {}) {
+  const level = _supportsColor(stream, {
+    streamIsTTY: stream && stream.isTTY,
+    ...options
+  });
+  return translateLevel(level);
+}
+var import_node_process, import_node_os, import_node_tty, env, flagForceColor, supportsColor, supports_color_default;
+var init_supports_color = __esm({
+  "../../node_modules/chalk/source/vendor/supports-color/index.js"() {
+    "use strict";
+    import_node_process = __toESM(require("process"), 1);
+    import_node_os = __toESM(require("os"), 1);
+    import_node_tty = __toESM(require("tty"), 1);
+    ({ env } = import_node_process.default);
+    if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) {
+      flagForceColor = 0;
+    } else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
+      flagForceColor = 1;
+    }
+    supportsColor = {
+      stdout: createSupportsColor({ isTTY: import_node_tty.default.isatty(1) }),
+      stderr: createSupportsColor({ isTTY: import_node_tty.default.isatty(2) })
+    };
+    supports_color_default = supportsColor;
+  }
+});
+
+// ../../node_modules/chalk/source/utilities.js
+function stringReplaceAll(string4, substring, replacer) {
+  let index = string4.indexOf(substring);
+  if (index === -1) {
+    return string4;
+  }
+  const substringLength = substring.length;
+  let endIndex = 0;
+  let returnValue = "";
+  do {
+    returnValue += string4.slice(endIndex, index) + substring + replacer;
+    endIndex = index + substringLength;
+    index = string4.indexOf(substring, endIndex);
+  } while (index !== -1);
+  returnValue += string4.slice(endIndex);
+  return returnValue;
+}
+function stringEncaseCRLFWithFirstIndex(string4, prefix, postfix, index) {
+  let endIndex = 0;
+  let returnValue = "";
+  do {
+    const gotCR = string4[index - 1] === "\r";
+    returnValue += string4.slice(endIndex, gotCR ? index - 1 : index) + prefix + (gotCR ? "\r\n" : "\n") + postfix;
+    endIndex = index + 1;
+    index = string4.indexOf("\n", endIndex);
+  } while (index !== -1);
+  returnValue += string4.slice(endIndex);
+  return returnValue;
+}
+var init_utilities = __esm({
+  "../../node_modules/chalk/source/utilities.js"() {
+    "use strict";
+  }
+});
+
+// ../../node_modules/chalk/source/index.js
+var source_exports = {};
+__export(source_exports, {
+  Chalk: () => Chalk,
+  backgroundColorNames: () => backgroundColorNames,
+  backgroundColors: () => backgroundColorNames,
+  chalkStderr: () => chalkStderr,
+  colorNames: () => colorNames,
+  colors: () => colorNames,
+  default: () => source_default,
+  foregroundColorNames: () => foregroundColorNames,
+  foregroundColors: () => foregroundColorNames,
+  modifierNames: () => modifierNames,
+  modifiers: () => modifierNames,
+  supportsColor: () => stdoutColor,
+  supportsColorStderr: () => stderrColor
+});
+function createChalk(options) {
+  return chalkFactory(options);
+}
+var stdoutColor, stderrColor, GENERATOR, STYLER, IS_EMPTY, levelMapping, styles2, applyOptions, Chalk, chalkFactory, getModelAnsi, usedModels, proto, createStyler, createBuilder, applyStyle, chalk, chalkStderr, source_default;
+var init_source = __esm({
+  "../../node_modules/chalk/source/index.js"() {
+    "use strict";
+    init_ansi_styles();
+    init_supports_color();
+    init_utilities();
+    init_ansi_styles();
+    ({ stdout: stdoutColor, stderr: stderrColor } = supports_color_default);
+    GENERATOR = /* @__PURE__ */ Symbol("GENERATOR");
+    STYLER = /* @__PURE__ */ Symbol("STYLER");
+    IS_EMPTY = /* @__PURE__ */ Symbol("IS_EMPTY");
+    levelMapping = [
+      "ansi",
+      "ansi",
+      "ansi256",
+      "ansi16m"
+    ];
+    styles2 = /* @__PURE__ */ Object.create(null);
+    applyOptions = (object2, options = {}) => {
+      if (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) {
+        throw new Error("The `level` option should be an integer from 0 to 3");
+      }
+      const colorLevel = stdoutColor ? stdoutColor.level : 0;
+      object2.level = options.level === void 0 ? colorLevel : options.level;
+    };
+    Chalk = class {
+      constructor(options) {
+        return chalkFactory(options);
+      }
+    };
+    chalkFactory = (options) => {
+      const chalk2 = (...strings) => strings.join(" ");
+      applyOptions(chalk2, options);
+      Object.setPrototypeOf(chalk2, createChalk.prototype);
+      return chalk2;
+    };
+    Object.setPrototypeOf(createChalk.prototype, Function.prototype);
+    for (const [styleName, style] of Object.entries(ansi_styles_default)) {
+      styles2[styleName] = {
+        get() {
+          const builder = createBuilder(this, createStyler(style.open, style.close, this[STYLER]), this[IS_EMPTY]);
+          Object.defineProperty(this, styleName, { value: builder });
+          return builder;
+        }
+      };
+    }
+    styles2.visible = {
+      get() {
+        const builder = createBuilder(this, this[STYLER], true);
+        Object.defineProperty(this, "visible", { value: builder });
+        return builder;
+      }
+    };
+    getModelAnsi = (model, level, type, ...arguments_) => {
+      if (model === "rgb") {
+        if (level === "ansi16m") {
+          return ansi_styles_default[type].ansi16m(...arguments_);
+        }
+        if (level === "ansi256") {
+          return ansi_styles_default[type].ansi256(ansi_styles_default.rgbToAnsi256(...arguments_));
+        }
+        return ansi_styles_default[type].ansi(ansi_styles_default.rgbToAnsi(...arguments_));
+      }
+      if (model === "hex") {
+        return getModelAnsi("rgb", level, type, ...ansi_styles_default.hexToRgb(...arguments_));
+      }
+      return ansi_styles_default[type][model](...arguments_);
+    };
+    usedModels = ["rgb", "hex", "ansi256"];
+    for (const model of usedModels) {
+      styles2[model] = {
+        get() {
+          const { level } = this;
+          return function(...arguments_) {
+            const styler = createStyler(getModelAnsi(model, levelMapping[level], "color", ...arguments_), ansi_styles_default.color.close, this[STYLER]);
+            return createBuilder(this, styler, this[IS_EMPTY]);
+          };
+        }
+      };
+      const bgModel = "bg" + model[0].toUpperCase() + model.slice(1);
+      styles2[bgModel] = {
+        get() {
+          const { level } = this;
+          return function(...arguments_) {
+            const styler = createStyler(getModelAnsi(model, levelMapping[level], "bgColor", ...arguments_), ansi_styles_default.bgColor.close, this[STYLER]);
+            return createBuilder(this, styler, this[IS_EMPTY]);
+          };
+        }
+      };
+    }
+    proto = Object.defineProperties(() => {
+    }, {
+      ...styles2,
+      level: {
+        enumerable: true,
+        get() {
+          return this[GENERATOR].level;
+        },
+        set(level) {
+          this[GENERATOR].level = level;
+        }
+      }
+    });
+    createStyler = (open2, close, parent) => {
+      let openAll;
+      let closeAll;
+      if (parent === void 0) {
+        openAll = open2;
+        closeAll = close;
+      } else {
+        openAll = parent.openAll + open2;
+        closeAll = close + parent.closeAll;
+      }
+      return {
+        open: open2,
+        close,
+        openAll,
+        closeAll,
+        parent
+      };
+    };
+    createBuilder = (self, _styler, _isEmpty) => {
+      const builder = (...arguments_) => applyStyle(builder, arguments_.length === 1 ? "" + arguments_[0] : arguments_.join(" "));
+      Object.setPrototypeOf(builder, proto);
+      builder[GENERATOR] = self;
+      builder[STYLER] = _styler;
+      builder[IS_EMPTY] = _isEmpty;
+      return builder;
+    };
+    applyStyle = (self, string4) => {
+      if (self.level <= 0 || !string4) {
+        return self[IS_EMPTY] ? "" : string4;
+      }
+      let styler = self[STYLER];
+      if (styler === void 0) {
+        return string4;
+      }
+      const { openAll, closeAll } = styler;
+      if (string4.includes("\x1B")) {
+        while (styler !== void 0) {
+          string4 = stringReplaceAll(string4, styler.close, styler.open);
+          styler = styler.parent;
+        }
+      }
+      const lfIndex = string4.indexOf("\n");
+      if (lfIndex !== -1) {
+        string4 = stringEncaseCRLFWithFirstIndex(string4, closeAll, openAll, lfIndex);
+      }
+      return openAll + string4 + closeAll;
+    };
+    Object.defineProperties(createChalk.prototype, styles2);
+    chalk = createChalk();
+    chalkStderr = createChalk({ level: stderrColor ? stderrColor.level : 0 });
+    source_default = chalk;
+  }
+});
+
 // ../../node_modules/zod/v4/core/core.js
 // @__NO_SIDE_EFFECTS__
 function $constructor(name, initializer3, params) {
@@ -9811,12 +10353,12 @@ function $constructor(name, initializer3, params) {
     }
     inst._zod.traits.add(name);
     initializer3(inst, def);
-    const proto = _.prototype;
-    const keys = Object.keys(proto);
+    const proto2 = _.prototype;
+    const keys = Object.keys(proto2);
     for (let i = 0; i < keys.length; i++) {
       const k = keys[i];
       if (!(k in inst)) {
-        inst[k] = proto[k].bind(inst);
+        inst[k] = proto2[k].bind(inst);
       }
     }
   }
@@ -20658,7 +21200,7 @@ function initializeContext(params) {
     external: params?.external ?? void 0
   };
 }
-function process2(schema, ctx, _params = { path: [], schemaPath: [] }) {
+function process3(schema, ctx, _params = { path: [], schemaPath: [] }) {
   var _a2;
   const def = schema._zod.def;
   const seen = ctx.seen.get(schema);
@@ -20695,7 +21237,7 @@ function process2(schema, ctx, _params = { path: [], schemaPath: [] }) {
     if (parent) {
       if (!result.ref)
         result.ref = parent;
-      process2(parent, ctx, params);
+      process3(parent, ctx, params);
       ctx.seen.get(parent).isParent = true;
     }
   }
@@ -20981,14 +21523,14 @@ var init_to_json_schema = __esm({
     init_registries();
     createToJSONSchemaMethod = (schema, processors = {}) => (params) => {
       const ctx = initializeContext({ ...params, processors });
-      process2(schema, ctx);
+      process3(schema, ctx);
       extractDefs(ctx, schema);
       return finalize(ctx, schema);
     };
     createStandardJSONSchemaMethod = (schema, io, processors = {}) => (params) => {
       const { libraryOptions, target } = params ?? {};
       const ctx = initializeContext({ ...libraryOptions ?? {}, target, io, processors });
-      process2(schema, ctx);
+      process3(schema, ctx);
       extractDefs(ctx, schema);
       return finalize(ctx, schema);
     };
@@ -21003,7 +21545,7 @@ function toJSONSchema(input, params) {
     const defs = {};
     for (const entry of registry2._idmap.entries()) {
       const [_, schema] = entry;
-      process2(schema, ctx2);
+      process3(schema, ctx2);
     }
     const schemas = {};
     const external = {
@@ -21026,7 +21568,7 @@ function toJSONSchema(input, params) {
     return { schemas };
   }
   const ctx = initializeContext({ ...params, processors: allProcessors });
-  process2(input, ctx);
+  process3(input, ctx);
   extractDefs(ctx, input);
   return finalize(ctx, input);
 }
@@ -21287,7 +21829,7 @@ var init_json_schema_processors = __esm({
       if (typeof maximum === "number")
         json2.maxItems = maximum;
       json2.type = "array";
-      json2.items = process2(def.element, ctx, { ...params, path: [...params.path, "items"] });
+      json2.items = process3(def.element, ctx, { ...params, path: [...params.path, "items"] });
     };
     objectProcessor = (schema, ctx, _json, params) => {
       const json2 = _json;
@@ -21296,7 +21838,7 @@ var init_json_schema_processors = __esm({
       json2.properties = {};
       const shape = def.shape;
       for (const key in shape) {
-        json2.properties[key] = process2(shape[key], ctx, {
+        json2.properties[key] = process3(shape[key], ctx, {
           ...params,
           path: [...params.path, "properties", key]
         });
@@ -21319,7 +21861,7 @@ var init_json_schema_processors = __esm({
         if (ctx.io === "output")
           json2.additionalProperties = false;
       } else if (def.catchall) {
-        json2.additionalProperties = process2(def.catchall, ctx, {
+        json2.additionalProperties = process3(def.catchall, ctx, {
           ...params,
           path: [...params.path, "additionalProperties"]
         });
@@ -21328,7 +21870,7 @@ var init_json_schema_processors = __esm({
     unionProcessor = (schema, ctx, json2, params) => {
       const def = schema._zod.def;
       const isExclusive = def.inclusive === false;
-      const options = def.options.map((x, i) => process2(x, ctx, {
+      const options = def.options.map((x, i) => process3(x, ctx, {
         ...params,
         path: [...params.path, isExclusive ? "oneOf" : "anyOf", i]
       }));
@@ -21340,11 +21882,11 @@ var init_json_schema_processors = __esm({
     };
     intersectionProcessor = (schema, ctx, json2, params) => {
       const def = schema._zod.def;
-      const a = process2(def.left, ctx, {
+      const a = process3(def.left, ctx, {
         ...params,
         path: [...params.path, "allOf", 0]
       });
-      const b2 = process2(def.right, ctx, {
+      const b2 = process3(def.right, ctx, {
         ...params,
         path: [...params.path, "allOf", 1]
       });
@@ -21361,11 +21903,11 @@ var init_json_schema_processors = __esm({
       json2.type = "array";
       const prefixPath = ctx.target === "draft-2020-12" ? "prefixItems" : "items";
       const restPath = ctx.target === "draft-2020-12" ? "items" : ctx.target === "openapi-3.0" ? "items" : "additionalItems";
-      const prefixItems = def.items.map((x, i) => process2(x, ctx, {
+      const prefixItems = def.items.map((x, i) => process3(x, ctx, {
         ...params,
         path: [...params.path, prefixPath, i]
       }));
-      const rest = def.rest ? process2(def.rest, ctx, {
+      const rest = def.rest ? process3(def.rest, ctx, {
         ...params,
         path: [...params.path, restPath, ...ctx.target === "openapi-3.0" ? [def.items.length] : []]
       }) : null;
@@ -21405,7 +21947,7 @@ var init_json_schema_processors = __esm({
       const keyBag = keyType._zod.bag;
       const patterns = keyBag?.patterns;
       if (def.mode === "loose" && patterns && patterns.size > 0) {
-        const valueSchema = process2(def.valueType, ctx, {
+        const valueSchema = process3(def.valueType, ctx, {
           ...params,
           path: [...params.path, "patternProperties", "*"]
         });
@@ -21415,12 +21957,12 @@ var init_json_schema_processors = __esm({
         }
       } else {
         if (ctx.target === "draft-07" || ctx.target === "draft-2020-12") {
-          json2.propertyNames = process2(def.keyType, ctx, {
+          json2.propertyNames = process3(def.keyType, ctx, {
             ...params,
             path: [...params.path, "propertyNames"]
           });
         }
-        json2.additionalProperties = process2(def.valueType, ctx, {
+        json2.additionalProperties = process3(def.valueType, ctx, {
           ...params,
           path: [...params.path, "additionalProperties"]
         });
@@ -21435,7 +21977,7 @@ var init_json_schema_processors = __esm({
     };
     nullableProcessor = (schema, ctx, json2, params) => {
       const def = schema._zod.def;
-      const inner = process2(def.innerType, ctx, params);
+      const inner = process3(def.innerType, ctx, params);
       const seen = ctx.seen.get(schema);
       if (ctx.target === "openapi-3.0") {
         seen.ref = def.innerType;
@@ -21446,20 +21988,20 @@ var init_json_schema_processors = __esm({
     };
     nonoptionalProcessor = (schema, ctx, _json, params) => {
       const def = schema._zod.def;
-      process2(def.innerType, ctx, params);
+      process3(def.innerType, ctx, params);
       const seen = ctx.seen.get(schema);
       seen.ref = def.innerType;
     };
     defaultProcessor = (schema, ctx, json2, params) => {
       const def = schema._zod.def;
-      process2(def.innerType, ctx, params);
+      process3(def.innerType, ctx, params);
       const seen = ctx.seen.get(schema);
       seen.ref = def.innerType;
       json2.default = JSON.parse(JSON.stringify(def.defaultValue));
     };
     prefaultProcessor = (schema, ctx, json2, params) => {
       const def = schema._zod.def;
-      process2(def.innerType, ctx, params);
+      process3(def.innerType, ctx, params);
       const seen = ctx.seen.get(schema);
       seen.ref = def.innerType;
       if (ctx.io === "input")
@@ -21467,7 +22009,7 @@ var init_json_schema_processors = __esm({
     };
     catchProcessor = (schema, ctx, json2, params) => {
       const def = schema._zod.def;
-      process2(def.innerType, ctx, params);
+      process3(def.innerType, ctx, params);
       const seen = ctx.seen.get(schema);
       seen.ref = def.innerType;
       let catchValue;
@@ -21481,32 +22023,32 @@ var init_json_schema_processors = __esm({
     pipeProcessor = (schema, ctx, _json, params) => {
       const def = schema._zod.def;
       const innerType = ctx.io === "input" ? def.in._zod.def.type === "transform" ? def.out : def.in : def.out;
-      process2(innerType, ctx, params);
+      process3(innerType, ctx, params);
       const seen = ctx.seen.get(schema);
       seen.ref = innerType;
     };
     readonlyProcessor = (schema, ctx, json2, params) => {
       const def = schema._zod.def;
-      process2(def.innerType, ctx, params);
+      process3(def.innerType, ctx, params);
       const seen = ctx.seen.get(schema);
       seen.ref = def.innerType;
       json2.readOnly = true;
     };
     promiseProcessor = (schema, ctx, _json, params) => {
       const def = schema._zod.def;
-      process2(def.innerType, ctx, params);
+      process3(def.innerType, ctx, params);
       const seen = ctx.seen.get(schema);
       seen.ref = def.innerType;
     };
     optionalProcessor = (schema, ctx, _json, params) => {
       const def = schema._zod.def;
-      process2(def.innerType, ctx, params);
+      process3(def.innerType, ctx, params);
       const seen = ctx.seen.get(schema);
       seen.ref = def.innerType;
     };
     lazyProcessor = (schema, ctx, _json, params) => {
       const innerType = schema._zod.innerType;
-      process2(innerType, ctx, params);
+      process3(innerType, ctx, params);
       const seen = ctx.seen.get(schema);
       seen.ref = innerType;
     };
@@ -21613,7 +22155,7 @@ var init_json_schema_generator = __esm({
        * This must be called before emit().
        */
       process(schema, _params = { path: [], schemaPath: [] }) {
-        return process2(schema, this.ctx, _params);
+        return process3(schema, this.ctx, _params);
       }
       /**
        * Emit the final JSON Schema after processing.
@@ -21907,7 +22449,7 @@ __export(core_exports2, {
   parse: () => parse,
   parseAsync: () => parseAsync,
   prettifyError: () => prettifyError,
-  process: () => process2,
+  process: () => process3,
   regexes: () => regexes_exports,
   registry: () => registry,
   safeDecode: () => safeDecode,
@@ -26350,13 +26892,13 @@ function createFsWatchInstance(path5, options, listener, errHandler, emitRaw) {
     return void 0;
   }
 }
-var import_node_fs, import_promises2, import_node_os, sp, STR_DATA, STR_END, STR_CLOSE, EMPTY_FN, pl, isWindows, isMacos, isLinux, isFreeBSD, isIBMi, EVENTS, EV, THROTTLE_MODE_WATCH, statMethods, KEY_LISTENERS, KEY_ERR, KEY_RAW, HANDLER_KEYS, binaryExtensions, isBinaryPath, foreach, addAndConvert, clearItem, delFromSet, isEmptySet, FsWatchInstances, fsWatchBroadcast, setFsWatchListener, FsWatchFileInstances, setFsWatchFileListener, NodeFsHandler;
+var import_node_fs, import_promises2, import_node_os2, sp, STR_DATA, STR_END, STR_CLOSE, EMPTY_FN, pl, isWindows, isMacos, isLinux, isFreeBSD, isIBMi, EVENTS, EV, THROTTLE_MODE_WATCH, statMethods, KEY_LISTENERS, KEY_ERR, KEY_RAW, HANDLER_KEYS, binaryExtensions, isBinaryPath, foreach, addAndConvert, clearItem, delFromSet, isEmptySet, FsWatchInstances, fsWatchBroadcast, setFsWatchListener, FsWatchFileInstances, setFsWatchFileListener, NodeFsHandler;
 var init_handler = __esm({
   "../daemon-core/node_modules/chokidar/handler.js"() {
     "use strict";
     import_node_fs = require("fs");
     import_promises2 = require("fs/promises");
-    import_node_os = require("os");
+    import_node_os2 = require("os");
     sp = __toESM(require("path"), 1);
     STR_DATA = "data";
     STR_END = "end";
@@ -26368,7 +26910,7 @@ var init_handler = __esm({
     isMacos = pl === "darwin";
     isLinux = pl === "linux";
     isFreeBSD = pl === "freebsd";
-    isIBMi = (0, import_node_os.type)() === "OS400";
+    isIBMi = (0, import_node_os2.type)() === "OS400";
     EVENTS = {
       ALL: "all",
       READY: "ready",
@@ -29379,8 +29921,8 @@ ${rules.join("\n")}`;
         shellCmd = binaryPath;
         shellArgs = allArgs;
       }
-      const env = buildCliSpawnEnv(process.env, spawnConfig.env);
-      env.TERMINAL_CWD = workingDir;
+      const env2 = buildCliSpawnEnv(process.env, spawnConfig.env);
+      env2.TERMINAL_CWD = workingDir;
       return {
         binaryPath,
         allArgs,
@@ -29392,7 +29934,7 @@ ${rules.join("\n")}`;
           cols: import_session_host_core22.DEFAULT_SESSION_HOST_COLS,
           rows: import_session_host_core22.DEFAULT_SESSION_HOST_ROWS,
           cwd: workingDir,
-          env
+          env: env2
         }
       };
     }
@@ -33027,14 +33569,14 @@ ${lastSnapshot}`;
     };
     init_config();
     var fs5 = __toESM2(require("fs"));
-    var os6 = __toESM2(require("os"));
+    var os7 = __toESM2(require("os"));
     var path42 = __toESM2(require("path"));
     var import_crypto22 = require("crypto");
     var MAX_WORKSPACES = 50;
     function expandPath(p) {
       const t = (p || "").trim();
       if (!t) return "";
-      if (t.startsWith("~")) return path42.join(os6.homedir(), t.slice(1).replace(/^\//, ""));
+      if (t.startsWith("~")) return path42.join(os7.homedir(), t.slice(1).replace(/^\//, ""));
       return path42.resolve(t);
     }
     function validateWorkspacePath(absPath) {
@@ -33107,7 +33649,7 @@ ${lastSnapshot}`;
         };
       }
       if (a.useHome === true) {
-        return { ok: true, path: os6.homedir(), source: "home" };
+        return { ok: true, path: os7.homedir(), source: "home" };
       }
       return {
         ok: false,
@@ -40979,7 +41521,7 @@ ${effect.notification.body || ""}`.trim();
     }
     var fs52 = __toESM2(require("fs"));
     var path12 = __toESM2(require("path"));
-    var os7 = __toESM2(require("os"));
+    var os72 = __toESM2(require("os"));
     var KEY_TO_VK = {
       Backspace: 8,
       Tab: 9,
@@ -41233,7 +41775,7 @@ ${effect.notification.body || ""}`.trim();
     function resolveSafePath(requestedPath) {
       const rawPath = typeof requestedPath === "string" ? requestedPath.trim() : "";
       const inputPath = rawPath || ".";
-      const home = os7.homedir();
+      const home = os72.homedir();
       if (inputPath.startsWith("~")) {
         return path12.resolve(path12.join(home, inputPath.slice(1)));
       }
@@ -42416,7 +42958,7 @@ ${effect.notification.body || ""}`.trim();
     var crypto4 = __toESM2(require("crypto"));
     var import_fs6 = require("fs");
     var import_child_process6 = require("child_process");
-    var import_chalk = __toESM2(require("chalk"));
+    var import_chalk = __toESM2((init_source(), __toCommonJS(source_exports)));
     init_provider_cli_adapter();
     init_config();
     var os12 = __toESM2(require("os"));
@@ -43846,7 +44388,7 @@ ${effect.notification.body || ""}`.trim();
           baseArgs = this.provider.spawnArgBuilder(this.selectedConfig);
         }
         const args = [...baseArgs, ...this.cliArgs];
-        const env = { ...process.env, ...spawnConfig.env || {} };
+        const env2 = { ...process.env, ...spawnConfig.env || {} };
         this.log.info(`[${this.type}] Spawning: ${command} ${args.join(" ")} in ${this.workingDir}`);
         this.spawnedAt = Date.now();
         this.errorMessage = null;
@@ -43854,7 +44396,7 @@ ${effect.notification.body || ""}`.trim();
         this.stderrBuffer = [];
         this.process = (0, import_child_process5.spawn)(command, args, {
           cwd: this.workingDir,
-          env,
+          env: env2,
           stdio: ["pipe", "pipe", "pipe"],
           shell: spawnConfig.shell || false,
           ...process.platform === "win32" ? { windowsHide: true } : {}
@@ -48412,13 +48954,13 @@ Run 'adhdev doctor' for detailed diagnostics.`
       }
     }
     function spawnDetachedDaemonUpgradeHelper(payload) {
-      const env = { ...process.env, [UPGRADE_HELPER_ENV]: JSON.stringify(payload) };
+      const env2 = { ...process.env, [UPGRADE_HELPER_ENV]: JSON.stringify(payload) };
       const child = (0, import_child_process9.spawn)(process.execPath, process.argv.slice(1), {
         detached: true,
         stdio: "ignore",
         windowsHide: true,
         cwd: payload.cwd || process.cwd(),
-        env
+        env: env2
       });
       child.unref();
     }
@@ -48462,15 +49004,15 @@ Run 'adhdev doctor' for detailed diagnostics.`
         appendUpgradeLog("Post-install staging cleanup complete");
       }
       if (restartArgv.length > 0) {
-        const env = { ...process.env };
-        delete env[UPGRADE_HELPER_ENV];
+        const env2 = { ...process.env };
+        delete env2[UPGRADE_HELPER_ENV];
         appendUpgradeLog(`Restarting daemon with args: ${restartArgv.join(" ")}`);
         const child = (0, import_child_process9.spawn)(process.execPath, restartArgv, {
           detached: true,
           stdio: "ignore",
           windowsHide: true,
           cwd: payload.cwd || process.cwd(),
-          env
+          env: env2
         });
         child.unref();
       } else {
@@ -48492,6 +49034,10 @@ Run 'adhdev doctor' for detailed diagnostics.`
     }
     var fs10 = __toESM2(require("fs"));
     var CHANNEL_NPM_TAG = { stable: "latest", preview: "next" };
+    var CHANNEL_SERVER_URL = {
+      stable: "https://api.adhf.dev",
+      preview: "https://api-preview.adhf.dev"
+    };
     function normalizeReleaseChannel(value) {
       if (typeof value !== "string") return null;
       const normalized = value.trim().toLowerCase();
@@ -49188,6 +49734,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
               const npmTag = CHANNEL_NPM_TAG[channel];
               const latest = String(execNpmCommandSync(["view", `${pkgName}@${npmTag}`, "version"], { encoding: "utf-8", timeout: 1e4 }, npmSurface)).trim();
               LOG2.info("Upgrade", `Latest ${pkgName}@${npmTag}: v${latest}`);
+              updateConfig({ updateChannel: channel, serverUrl: CHANNEL_SERVER_URL[channel] });
               let currentInstalled = null;
               try {
                 const currentJson = String(execNpmCommandSync(["ls", "-g", pkgName, "--depth=0", "--json"], {
@@ -56778,8 +57325,8 @@ data: ${JSON.stringify(msg.data)}
       return `Standalone session-host namespace '${DEFAULT_SESSION_HOST_APP_NAME}' is reserved for the global daemon. Falling back to '${DEFAULT_STANDALONE_SESSION_HOST_APP_NAME}' for this standalone run.`;
     }
     function resolveSessionHostAppNameResolution2(options = {}) {
-      const env = options.env || process.env;
-      const explicit = typeof env.ADHDEV_SESSION_HOST_NAME === "string" ? env.ADHDEV_SESSION_HOST_NAME.trim() : "";
+      const env2 = options.env || process.env;
+      const explicit = typeof env2.ADHDEV_SESSION_HOST_NAME === "string" ? env2.ADHDEV_SESSION_HOST_NAME.trim() : "";
       if (explicit) {
         if (options.standalone && explicit === DEFAULT_SESSION_HOST_APP_NAME) {
           return {
@@ -56857,8 +57404,8 @@ data: ${JSON.stringify(msg.data)}
         });
       }
     }
-    function shouldAutoRestoreHostedSessionsOnStartup2(env = process.env) {
-      const raw = typeof env.ADHDEV_RESTORE_HOSTED_SESSIONS_ON_STARTUP === "string" ? env.ADHDEV_RESTORE_HOSTED_SESSIONS_ON_STARTUP.trim().toLowerCase() : "";
+    function shouldAutoRestoreHostedSessionsOnStartup2(env2 = process.env) {
+      const raw = typeof env2.ADHDEV_RESTORE_HOSTED_SESSIONS_ON_STARTUP === "string" ? env2.ADHDEV_RESTORE_HOSTED_SESSIONS_ON_STARTUP.trim().toLowerCase() : "";
       if (!raw) return true;
       if (raw === "0" || raw === "false" || raw === "no") return false;
       return raw === "1" || raw === "true" || raw === "yes";
@@ -57383,7 +57930,7 @@ var import_http = require("http");
 var import_ws = require("ws");
 var path4 = __toESM(require("path"));
 var fs4 = __toESM(require("fs"));
-var os5 = __toESM(require("os"));
+var os6 = __toESM(require("os"));
 var import_crypto2 = require("crypto");
 
 // src/standalone-preferences.ts
@@ -57465,7 +58012,7 @@ var import_daemon_core2 = __toESM(require_dist2());
 // src/session-host.ts
 var childProcess = __toESM(require("child_process"));
 var fs3 = __toESM(require("fs"));
-var os2 = __toESM(require("os"));
+var os3 = __toESM(require("os"));
 var path2 = __toESM(require("path"));
 var import_daemon_core = __toESM(require_dist2());
 
@@ -57488,26 +58035,26 @@ function getStandaloneSessionHostAppNameWarning() {
   return SESSION_HOST_APP_NAME_RESOLUTION.warning;
 }
 function buildSessionHostEnv(baseEnv) {
-  const env = {};
+  const env2 = {};
   for (const [key, value] of Object.entries(baseEnv)) {
     if (typeof value !== "string") continue;
-    env[key] = value;
+    env2[key] = value;
   }
-  for (const key of Object.keys(env)) {
+  for (const key of Object.keys(env2)) {
     if (key === "INIT_CWD" || key === "npm_command" || key === "npm_execpath" || key === "npm_node_execpath" || key.startsWith("npm_") || key.startsWith("npm_config_") || key.startsWith("npm_package_") || key.startsWith("npm_lifecycle_") || key.startsWith("PNPM_") || key.startsWith("YARN_") || key.startsWith("BUN_")) {
-      delete env[key];
+      delete env2[key];
     }
   }
-  if (!env.NO_COLOR) {
-    if (!env.TERM || env.TERM === "xterm-color") env.TERM = "xterm-256color";
-    if (!env.COLORTERM) env.COLORTERM = "truecolor";
+  if (!env2.NO_COLOR) {
+    if (!env2.TERM || env2.TERM === "xterm-color") env2.TERM = "xterm-256color";
+    if (!env2.COLORTERM) env2.COLORTERM = "truecolor";
     if (process.platform === "win32") {
-      if (!env.FORCE_COLOR) env.FORCE_COLOR = "1";
-      if (!env.CLICOLOR) env.CLICOLOR = "1";
+      if (!env2.FORCE_COLOR) env2.FORCE_COLOR = "1";
+      if (!env2.CLICOLOR) env2.CLICOLOR = "1";
     }
   }
-  env.ADHDEV_SESSION_HOST_NAME = SESSION_HOST_APP_NAME;
-  return env;
+  env2.ADHDEV_SESSION_HOST_NAME = SESSION_HOST_APP_NAME;
+  return env2;
 }
 function resolveSessionHostEntry() {
   const localCandidates = [
@@ -57522,7 +58069,7 @@ function resolveSessionHostEntry() {
   return require.resolve("@adhdev/session-host-daemon");
 }
 function getSessionHostPidFile() {
-  return path2.join(os2.homedir(), ".adhdev", `${SESSION_HOST_APP_NAME}-session-host.pid`);
+  return path2.join(os3.homedir(), ".adhdev", `${SESSION_HOST_APP_NAME}-session-host.pid`);
 }
 function killPid(pid) {
   try {
@@ -57615,15 +58162,15 @@ async function proxySessionHostAttach(target, options = {}) {
 }
 
 // src/startup-restore-policy.ts
-function shouldAutoRestoreHostedSessionsOnStartup(env = process.env) {
-  const raw = typeof env.ADHDEV_RESTORE_HOSTED_SESSIONS_ON_STARTUP === "string" ? env.ADHDEV_RESTORE_HOSTED_SESSIONS_ON_STARTUP.trim().toLowerCase() : "";
+function shouldAutoRestoreHostedSessionsOnStartup(env2 = process.env) {
+  const raw = typeof env2.ADHDEV_RESTORE_HOSTED_SESSIONS_ON_STARTUP === "string" ? env2.ADHDEV_RESTORE_HOSTED_SESSIONS_ON_STARTUP.trim().toLowerCase() : "";
   if (!raw) return true;
   if (raw === "0" || raw === "false" || raw === "no") return false;
   return raw === "1" || raw === "true" || raw === "yes";
 }
 
 // ../session-host-core/dist/index.mjs
-var os3 = __toESM(require("os"), 1);
+var os4 = __toESM(require("os"), 1);
 var path22 = __toESM(require("path"), 1);
 var net = __toESM(require("net"), 1);
 var import_crypto = require("crypto");
@@ -57637,7 +58184,7 @@ function getDefaultSessionHostEndpoint(appName = "adhdev") {
   }
   return {
     kind: "unix",
-    path: path22.join(os3.tmpdir(), `${appName}-session-host.sock`)
+    path: path22.join(os4.tmpdir(), `${appName}-session-host.sock`)
   };
 }
 function serializeEnvelope(envelope) {
@@ -57991,14 +58538,14 @@ var STANDALONE_BIND_HOST_DEFAULT = "127.0.0.1";
 var PASSWORD_KEYLEN = 64;
 var DEFAULT_SESSION_TTL_MS = 1e3 * 60 * 60 * 24 * 30;
 function getStandalonePasswordConfigPath() {
-  const dir = path4.join(os5.homedir(), ".adhdev");
+  const dir = path4.join(os6.homedir(), ".adhdev");
   if (!fs4.existsSync(dir)) {
     fs4.mkdirSync(dir, { recursive: true, mode: 448 });
   }
   return path4.join(dir, STANDALONE_PASSWORD_CONFIG_FILE);
 }
 function getStandaloneConfigJsonPath() {
-  const dir = path4.join(os5.homedir(), ".adhdev");
+  const dir = path4.join(os6.homedir(), ".adhdev");
   if (!fs4.existsSync(dir)) {
     fs4.mkdirSync(dir, { recursive: true, mode: 448 });
   }
@@ -59447,7 +59994,7 @@ var StandaloneServer = class {
         availableMem: snapshot.machine.availableMem ?? machineRuntime.availableMem ?? 0,
         loadavg: snapshot.machine.loadavg ?? machineRuntime.loadavg ?? [],
         uptime: snapshot.machine.uptime ?? machineRuntime.uptime ?? 0,
-        arch: snapshot.machine.arch ?? machineRuntime.arch ?? os5.arch()
+        arch: snapshot.machine.arch ?? machineRuntime.arch ?? os6.arch()
       }
     };
   }
@@ -59547,7 +60094,7 @@ var StandaloneServer = class {
   }
   // ─── Network ───
   getLanIPs() {
-    const interfaces = os5.networkInterfaces();
+    const interfaces = os6.networkInterfaces();
     const ips = [];
     for (const iface of Object.values(interfaces)) {
       if (!iface) continue;