elit 3.6.7 → 3.6.8

package/dist/pm.js

@@ -1677,7 +1677,7 @@ is not a problem with esbuild. You need to fix your environment instead.
           let latestResultPromise;
           let provideLatestResult;
           if (isContext)
-            requestCallbacks["on-end"] = (id, request2) => new Promise((resolve6) => {
+            requestCallbacks["on-end"] = (id, request2) => new Promise((resolve7) => {
               buildResponseToResult(request2, (err, result, onEndErrors, onEndWarnings) => {
                 const response = {
                   errors: onEndErrors,
@@ -1687,7 +1687,7 @@ is not a problem with esbuild. You need to fix your environment instead.
                 latestResultPromise = void 0;
                 provideLatestResult = void 0;
                 sendResponse(id, response);
-                resolve6();
+                resolve7();
               });
             });
           sendRequest(refs, request, (error, response) => {
@@ -1704,10 +1704,10 @@ is not a problem with esbuild. You need to fix your environment instead.
             let didDispose = false;
             const result = {
               rebuild: () => {
-                if (!latestResultPromise) latestResultPromise = new Promise((resolve6, reject) => {
+                if (!latestResultPromise) latestResultPromise = new Promise((resolve7, reject) => {
                   let settlePromise;
                   provideLatestResult = (err, result2) => {
-                    if (!settlePromise) settlePromise = () => err ? reject(err) : resolve6(result2);
+                    if (!settlePromise) settlePromise = () => err ? reject(err) : resolve7(result2);
                   };
                   const triggerAnotherBuild = () => {
                     const request2 = {
@@ -1728,7 +1728,7 @@ is not a problem with esbuild. You need to fix your environment instead.
                 });
                 return latestResultPromise;
               },
-              watch: (options2 = {}) => new Promise((resolve6, reject) => {
+              watch: (options2 = {}) => new Promise((resolve7, reject) => {
                 if (!streamIn.hasFS) throw new Error(`Cannot use the "watch" API in this environment`);
                 const keys = {};
                 const delay2 = getFlag(options2, keys, "delay", mustBeInteger);
@@ -1740,10 +1740,10 @@ is not a problem with esbuild. You need to fix your environment instead.
                 if (delay2) request2.delay = delay2;
                 sendRequest(refs, request2, (error2) => {
                   if (error2) reject(new Error(error2));
-                  else resolve6(void 0);
+                  else resolve7(void 0);
                 });
               }),
-              serve: (options2 = {}) => new Promise((resolve6, reject) => {
+              serve: (options2 = {}) => new Promise((resolve7, reject) => {
                 if (!streamIn.hasFS) throw new Error(`Cannot use the "serve" API in this environment`);
                 const keys = {};
                 const port = getFlag(options2, keys, "port", mustBeValidPortNumber);
@@ -1781,28 +1781,28 @@ is not a problem with esbuild. You need to fix your environment instead.
                       sendResponse(id, {});
                     };
                   }
-                  resolve6(response2);
+                  resolve7(response2);
                 });
               }),
-              cancel: () => new Promise((resolve6) => {
-                if (didDispose) return resolve6();
+              cancel: () => new Promise((resolve7) => {
+                if (didDispose) return resolve7();
                 const request2 = {
                   command: "cancel",
                   key: buildKey
                 };
                 sendRequest(refs, request2, () => {
-                  resolve6();
+                  resolve7();
                 });
               }),
-              dispose: () => new Promise((resolve6) => {
-                if (didDispose) return resolve6();
+              dispose: () => new Promise((resolve7) => {
+                if (didDispose) return resolve7();
                 didDispose = true;
                 const request2 = {
                   command: "dispose",
                   key: buildKey
                 };
                 sendRequest(refs, request2, () => {
-                  resolve6();
+                  resolve7();
                   scheduleOnDisposeCallbacks();
                   refs.unref();
                 });
@@ -1841,7 +1841,7 @@ is not a problem with esbuild. You need to fix your environment instead.
               onLoad: []
             };
             i++;
-            let resolve6 = (path3, options = {}) => {
+            let resolve7 = (path3, options = {}) => {
               if (!isSetupDone) throw new Error('Cannot call "resolve" before plugin setup has completed');
               if (typeof path3 !== "string") throw new Error(`The path to resolve must be a string`);
               let keys2 = /* @__PURE__ */ Object.create(null);
@@ -1885,7 +1885,7 @@ is not a problem with esbuild. You need to fix your environment instead.
             };
             let promise = setup({
               initialOptions,
-              resolve: resolve6,
+              resolve: resolve7,
               onStart(callback) {
                 let registeredText = `This error came from the "onStart" callback registered here:`;
                 let registeredNote = extractCallerV8(new Error(registeredText), streamIn, "onStart");
@@ -2772,46 +2772,46 @@ More information: The file containing the code for esbuild's JavaScript API (${_
           }
         };
         longLivedService = {
-          build: (options) => new Promise((resolve6, reject) => {
+          build: (options) => new Promise((resolve7, reject) => {
             service.buildOrContext({
               callName: "build",
               refs,
               options,
               isTTY: isTTY(),
               defaultWD,
-              callback: (err, res) => err ? reject(err) : resolve6(res)
+              callback: (err, res) => err ? reject(err) : resolve7(res)
             });
           }),
-          context: (options) => new Promise((resolve6, reject) => service.buildOrContext({
+          context: (options) => new Promise((resolve7, reject) => service.buildOrContext({
             callName: "context",
             refs,
             options,
             isTTY: isTTY(),
             defaultWD,
-            callback: (err, res) => err ? reject(err) : resolve6(res)
+            callback: (err, res) => err ? reject(err) : resolve7(res)
           })),
-          transform: (input, options) => new Promise((resolve6, reject) => service.transform({
+          transform: (input, options) => new Promise((resolve7, reject) => service.transform({
             callName: "transform",
             refs,
             input,
             options: options || {},
             isTTY: isTTY(),
             fs: fsAsync,
-            callback: (err, res) => err ? reject(err) : resolve6(res)
+            callback: (err, res) => err ? reject(err) : resolve7(res)
           })),
-          formatMessages: (messages, options) => new Promise((resolve6, reject) => service.formatMessages({
+          formatMessages: (messages, options) => new Promise((resolve7, reject) => service.formatMessages({
             callName: "formatMessages",
             refs,
             messages,
             options,
-            callback: (err, res) => err ? reject(err) : resolve6(res)
+            callback: (err, res) => err ? reject(err) : resolve7(res)
           })),
-          analyzeMetafile: (metafile, options) => new Promise((resolve6, reject) => service.analyzeMetafile({
+          analyzeMetafile: (metafile, options) => new Promise((resolve7, reject) => service.analyzeMetafile({
             callName: "analyzeMetafile",
             refs,
             metafile: typeof metafile === "string" ? metafile : JSON.stringify(metafile),
             options,
-            callback: (err, res) => err ? reject(err) : resolve6(res)
+            callback: (err, res) => err ? reject(err) : resolve7(res)
           }))
         };
         return longLivedService;
@@ -2889,13 +2889,13 @@ error: ${text}`);
           worker.postMessage(msg);
           let status = Atomics.wait(sharedBufferView, 0, 0);
           if (status !== "ok" && status !== "not-equal") throw new Error("Internal error: Atomics.wait() failed: " + status);
-          let { message: { id: id2, resolve: resolve6, reject, properties } } = worker_threads2.receiveMessageOnPort(mainPort);
+          let { message: { id: id2, resolve: resolve7, reject, properties } } = worker_threads2.receiveMessageOnPort(mainPort);
           if (id !== id2) throw new Error(`Internal error: Expected id ${id} but got id ${id2}`);
           if (reject) {
             applyProperties(reject, properties);
             throw reject;
           }
-          return resolve6;
+          return resolve7;
         };
         worker.unref();
         return {
@@ -2986,6 +2986,7 @@ error: ${text}`);
   var DEFAULT_MAX_RESTARTS = 10;
   var DEFAULT_WATCH_DEBOUNCE = 250;
   var DEFAULT_MIN_UPTIME = 0;
+  var DEFAULT_PM_LISTEN_TIMEOUT = 3e3;
   var DEFAULT_HEALTHCHECK_GRACE_PERIOD = 5e3;
   var DEFAULT_HEALTHCHECK_INTERVAL = 1e4;
   var DEFAULT_HEALTHCHECK_TIMEOUT = 3e3;
@@ -2993,6 +2994,11 @@ error: ${text}`);
   var DEFAULT_LOG_LINES = 40;
   var DEFAULT_PM_STOP_POLL_MS = 100;
   var DEFAULT_PM_STOP_GRACE_PERIOD_MS = 5e3;
+  var DEFAULT_PM_KILL_TIMEOUT = DEFAULT_PM_STOP_GRACE_PERIOD_MS;
+  var DEFAULT_PM_EXP_BACKOFF_MAX_DELAY = 15e3;
+  var DEFAULT_PM_MEMORY_CHECK_INTERVAL = 500;
+  var DEFAULT_PM_RESTART_WINDOW = 0;
+  var DEFAULT_PM_PROXY_STRATEGY = "proxy";
   var PM_WAPK_ONLINE_STDIN_SHUTDOWN_ENV = "ELIT_PM_WAPK_ONLINE_STDIN_SHUTDOWN";
   var PM_WAPK_ONLINE_SHUTDOWN_COMMAND = "__ELIT_PM_WAPK_ONLINE_SHUTDOWN__";
   var PM_WAPK_ONLINE_SHUTDOWN_TIMEOUT_MS = 8e3;
@@ -3030,6 +3036,32 @@ error: ${text}`);
     }
     throw new Error(`${optionName} must be one of: always, on-failure, never`);
   }
+  function normalizePmMemoryAction(value, optionName = "--memory-action") {
+    if (value === void 0 || value === null || value === "") {
+      return void 0;
+    }
+    if (typeof value !== "string") {
+      throw new Error(`${optionName} must be one of: restart, stop`);
+    }
+    const action = value.trim().toLowerCase();
+    if (action === "restart" || action === "stop") {
+      return action;
+    }
+    throw new Error(`${optionName} must be one of: restart, stop`);
+  }
+  function normalizePmProxyStrategy(value, optionName = "--proxy-strategy") {
+    if (value === void 0 || value === null || value === "") {
+      return void 0;
+    }
+    if (typeof value !== "string") {
+      throw new Error(`${optionName} must be one of: proxy, inherit`);
+    }
+    const strategy = value.trim().toLowerCase();
+    if (strategy === "proxy" || strategy === "inherit") {
+      return strategy;
+    }
+    throw new Error(`${optionName} must be one of: proxy, inherit`);
+  }
   function normalizeIntegerOption(value, optionName, min = 0) {
     const parsed = Number.parseInt(value, 10);
     if (!Number.isFinite(parsed) || parsed < min) {
@@ -3037,6 +3069,30 @@ error: ${text}`);
     }
     return parsed;
   }
+  function normalizePmMemoryLimit(value, optionName = "--max-memory") {
+    if (value === void 0 || value === null || value === "") {
+      return void 0;
+    }
+    if (typeof value === "number") {
+      const normalized2 = Math.trunc(value);
+      if (!Number.isFinite(normalized2) || normalized2 < 1) {
+        throw new Error(`${optionName} must be a number >= 1 or a size like 256M.`);
+      }
+      return normalized2;
+    }
+    if (typeof value !== "string") {
+      throw new Error(`${optionName} must be a number >= 1 or a size like 256M.`);
+    }
+    const normalized = value.trim();
+    const match = /^(\d+)(b|kb|mb|gb|tb|k|m|g|t)?$/i.exec(normalized);
+    if (!match) {
+      throw new Error(`${optionName} must be a number >= 1 or a size like 256M.`);
+    }
+    const amount = normalizeIntegerOption(match[1] ?? "", optionName, 1);
+    const unit = (match[2] ?? "b").toLowerCase();
+    const multiplier = unit === "b" ? 1 : unit === "k" || unit === "kb" ? 1024 : unit === "m" || unit === "mb" ? 1024 ** 2 : unit === "g" || unit === "gb" ? 1024 ** 3 : 1024 ** 4;
+    return amount * multiplier;
+  }
   function normalizeNonEmptyString(value) {
     if (typeof value !== "string") {
       return void 0;
@@ -3313,6 +3369,30 @@ error: ${text}`);
     }
     return value;
   }
+  function normalizePmProxyConfig(value, optionName = "pm proxy") {
+    if (value === void 0 || value === null) {
+      return void 0;
+    }
+    if (typeof value !== "object") {
+      throw new Error(`${optionName} must be an object with at least a port.`);
+    }
+    const candidate = value;
+    const hasAnyValue = candidate.port !== void 0 || candidate.host !== void 0 || candidate.targetHost !== void 0 || candidate.envVar !== void 0;
+    if (!hasAnyValue) {
+      return void 0;
+    }
+    if (candidate.port === void 0 || candidate.port === null || candidate.port === "") {
+      throw new Error(`${optionName}.port is required.`);
+    }
+    const port = typeof candidate.port === "number" ? normalizeIntegerOption(String(Math.trunc(candidate.port)), `${optionName}.port`, 1) : normalizeIntegerOption(String(candidate.port), `${optionName}.port`, 1);
+    return {
+      port,
+      strategy: normalizePmProxyStrategy(candidate.strategy, `${optionName}.strategy`) ?? DEFAULT_PM_PROXY_STRATEGY,
+      host: normalizeNonEmptyString(candidate.host),
+      targetHost: normalizeNonEmptyString(candidate.targetHost),
+      envVar: normalizeNonEmptyString(candidate.envVar)
+    };
+  }
 
   // src/cli/pm/records.ts
   var import_node_fs2 = __require("fs");
@@ -3345,18 +3425,31 @@ error: ${text}`);
   function toSavedAppDefinition(record) {
     return {
       name: record.name,
+      baseName: record.baseName,
+      instanceIndex: record.instanceIndex,
+      instances: record.instances,
       type: record.type,
       cwd: record.cwd,
       runtime: record.runtime,
       env: record.env,
+      proxy: record.proxy,
       script: record.script,
       file: record.file,
       wapk: record.wapk,
       password: record.password,
       wapkRun: record.wapkRun,
       restartPolicy: record.restartPolicy,
+      maxMemoryBytes: record.maxMemoryBytes,
+      memoryAction: record.memoryAction,
+      cronRestart: record.cronRestart,
+      expBackoffRestartDelay: record.expBackoffRestartDelay,
+      expBackoffRestartMaxDelay: record.expBackoffRestartMaxDelay,
+      restartWindow: record.restartWindow,
+      waitReady: record.waitReady,
+      listenTimeout: record.listenTimeout,
       autorestart: record.autorestart,
       restartDelay: record.restartDelay,
+      killTimeout: record.killTimeout,
       maxRestarts: record.maxRestarts,
       minUptime: record.minUptime,
       watch: record.watch,
@@ -3423,6 +3516,9 @@ error: ${text}`);
     }
     return listPmRecordMatches(paths).find((match) => match.record.name === nameOrId);
   }
+  function findPmGroupMatches(paths, baseName) {
+    return listPmRecordMatches(paths).filter((match) => match.record.baseName === baseName).sort((left, right) => left.record.instanceIndex - right.record.instanceIndex);
+  }
   function isProcessAlive(pid) {
     if (!pid || pid <= 0) {
       return false;
@@ -3472,11 +3568,22 @@ error: ${text}`);
       runtime: record.runtime,
       cwd: record.cwd,
       env: record.env,
+      proxy: record.proxy,
+      instances: record.instances,
       autorestart: record.autorestart,
       restartDelay: record.restartDelay,
+      killTimeout: record.killTimeout,
       maxRestarts: record.maxRestarts,
       password: record.password,
       restartPolicy: record.restartPolicy,
+      maxMemory: record.maxMemoryBytes,
+      memoryAction: record.memoryAction,
+      cronRestart: record.cronRestart,
+      expBackoffRestartDelay: record.expBackoffRestartDelay,
+      expBackoffRestartMaxDelay: record.expBackoffRestartMaxDelay,
+      restartWindow: record.restartWindow,
+      waitReady: record.waitReady,
+      listenTimeout: record.listenTimeout,
       minUptime: record.minUptime,
       watch: record.watch,
       watchPaths: record.watchPaths,
@@ -3495,11 +3602,22 @@ error: ${text}`);
       runtime: app.runtime,
       cwd: app.cwd,
       env: app.env,
+      proxy: app.proxy,
+      instances: app.instances,
       autorestart: app.autorestart,
       restartDelay: app.restartDelay,
+      killTimeout: app.killTimeout,
       maxRestarts: app.maxRestarts,
       password: app.password,
       restartPolicy: app.restartPolicy,
+      maxMemory: app.maxMemoryBytes,
+      memoryAction: app.memoryAction,
+      cronRestart: app.cronRestart,
+      expBackoffRestartDelay: app.expBackoffRestartDelay,
+      expBackoffRestartMaxDelay: app.expBackoffRestartMaxDelay,
+      restartWindow: app.restartWindow,
+      waitReady: app.waitReady,
+      listenTimeout: app.listenTimeout,
       minUptime: app.minUptime,
       watch: app.watch,
       watchPaths: app.watchPaths,
@@ -3511,6 +3629,170 @@ error: ${text}`);
 
   // src/cli/pm/config.ts
   var import_node_path4 = __require("path");
+
+  // src/cli/pm/schedule.ts
+  var PM_EVERY_PATTERN = /^@every\s+(\d+)(ms|s|m|h|d)$/i;
+  function parsePositiveInteger(value, optionName, min = 0) {
+    const parsed = Number.parseInt(value, 10);
+    if (!Number.isFinite(parsed) || parsed < min) {
+      throw new Error(`${optionName} must be a number >= ${min}`);
+    }
+    return parsed;
+  }
+  function fillRange(values, start, end, step, min, max, optionName) {
+    if (!Number.isInteger(start) || !Number.isInteger(end) || start < min || end > max || start > end) {
+      throw new Error(`${optionName} contains an invalid range: ${start}-${end}`);
+    }
+    if (!Number.isInteger(step) || step < 1) {
+      throw new Error(`${optionName} contains an invalid step: ${step}`);
+    }
+    for (let current = start; current <= end; current += step) {
+      values.add(current);
+    }
+  }
+  function parseCronSegment(segment, values, min, max, optionName) {
+    const normalized = segment.trim();
+    if (!normalized) {
+      throw new Error(`${optionName} contains an empty field segment.`);
+    }
+    const [rangeToken, stepToken] = normalized.split("/");
+    if (normalized.split("/").length > 2) {
+      throw new Error(`${optionName} contains an invalid step segment: ${normalized}`);
+    }
+    const step = stepToken === void 0 ? 1 : parsePositiveInteger(stepToken, optionName, 1);
+    if (rangeToken === "*") {
+      fillRange(values, min, max, step, min, max, optionName);
+      return;
+    }
+    if (rangeToken.includes("-")) {
+      const [startToken, endToken] = rangeToken.split("-");
+      if (!startToken || !endToken) {
+        throw new Error(`${optionName} contains an invalid range: ${normalized}`);
+      }
+      const start2 = parsePositiveInteger(startToken, optionName, min);
+      const end = parsePositiveInteger(endToken, optionName, min);
+      fillRange(values, start2, end, step, min, max, optionName);
+      return;
+    }
+    const start = parsePositiveInteger(rangeToken, optionName, min);
+    fillRange(values, start, stepToken === void 0 ? start : max, step, min, max, optionName);
+  }
+  function parseCronField(token, min, max, optionName) {
+    const normalized = token.trim();
+    if (!normalized) {
+      throw new Error(`${optionName} contains an empty field.`);
+    }
+    if (normalized === "*") {
+      const values2 = /* @__PURE__ */ new Set();
+      fillRange(values2, min, max, 1, min, max, optionName);
+      return {
+        values: values2,
+        wildcard: true
+      };
+    }
+    const values = /* @__PURE__ */ new Set();
+    for (const segment of normalized.split(",")) {
+      parseCronSegment(segment, values, min, max, optionName);
+    }
+    if (values.size === 0) {
+      throw new Error(`${optionName} must match at least one value.`);
+    }
+    return {
+      values,
+      wildcard: false
+    };
+  }
+  function matchesCronField(field, value) {
+    if (!field) {
+      return true;
+    }
+    return field.wildcard || field.values.has(value);
+  }
+  function matchesCronDate(schedule, candidate) {
+    if (schedule.kind !== "cron") {
+      return false;
+    }
+    const secondMatches = schedule.hasSeconds ? matchesCronField(schedule.seconds, candidate.getSeconds()) : true;
+    const minuteMatches = matchesCronField(schedule.minutes, candidate.getMinutes());
+    const hourMatches = matchesCronField(schedule.hours, candidate.getHours());
+    const monthMatches = matchesCronField(schedule.months, candidate.getMonth() + 1);
+    const dayOfMonthMatches = matchesCronField(schedule.daysOfMonth, candidate.getDate());
+    const dayOfWeekMatches = matchesCronField(schedule.daysOfWeek, candidate.getDay());
+    const domWildcard = schedule.daysOfMonth?.wildcard ?? true;
+    const dowWildcard = schedule.daysOfWeek?.wildcard ?? true;
+    const dayMatches = domWildcard && dowWildcard ? true : domWildcard ? dayOfWeekMatches : dowWildcard ? dayOfMonthMatches : dayOfMonthMatches || dayOfWeekMatches;
+    return secondMatches && minuteMatches && hourMatches && monthMatches && dayMatches;
+  }
+  function parsePmRestartSchedule(expression, optionName = "--cron-restart") {
+    const normalized = expression.trim();
+    const everyMatch = PM_EVERY_PATTERN.exec(normalized);
+    if (everyMatch) {
+      const [, valueText, unit] = everyMatch;
+      const value = parsePositiveInteger(valueText ?? "", optionName, 1);
+      const multiplier = unit?.toLowerCase() === "ms" ? 1 : unit?.toLowerCase() === "s" ? 1e3 : unit?.toLowerCase() === "m" ? 6e4 : unit?.toLowerCase() === "h" ? 36e5 : 864e5;
+      return {
+        expression: normalized,
+        kind: "every",
+        intervalMs: value * multiplier,
+        hasSeconds: true
+      };
+    }
+    const fields = normalized.split(/\s+/).filter((field) => field.length > 0);
+    if (fields.length !== 5 && fields.length !== 6) {
+      throw new Error(`${optionName} must be a 5-field cron expression or @every <duration>.`);
+    }
+    const hasSeconds = fields.length === 6;
+    const offset = hasSeconds ? 1 : 0;
+    return {
+      expression: normalized,
+      kind: "cron",
+      hasSeconds,
+      seconds: hasSeconds ? parseCronField(fields[0] ?? "", 0, 59, optionName) : void 0,
+      minutes: parseCronField(fields[0 + offset] ?? "", 0, 59, optionName),
+      hours: parseCronField(fields[1 + offset] ?? "", 0, 23, optionName),
+      daysOfMonth: parseCronField(fields[2 + offset] ?? "", 1, 31, optionName),
+      months: parseCronField(fields[3 + offset] ?? "", 1, 12, optionName),
+      daysOfWeek: parseCronField(fields[4 + offset] ?? "", 0, 6, optionName)
+    };
+  }
+  function normalizePmRestartSchedule(value, optionName = "--cron-restart") {
+    if (value === void 0 || value === null || value === "") {
+      return void 0;
+    }
+    if (typeof value !== "string") {
+      throw new Error(`${optionName} must be a cron string or @every <duration>.`);
+    }
+    const normalized = value.trim();
+    if (!normalized) {
+      throw new Error(`${optionName} must be a non-empty cron string or @every <duration>.`);
+    }
+    parsePmRestartSchedule(normalized, optionName);
+    return normalized;
+  }
+  function resolveNextPmScheduleOccurrence(schedule, after = /* @__PURE__ */ new Date()) {
+    if (schedule.kind === "every") {
+      return new Date(after.getTime() + (schedule.intervalMs ?? 0));
+    }
+    const stepMs = schedule.hasSeconds ? 1e3 : 6e4;
+    const candidate = new Date(after.getTime());
+    if (schedule.hasSeconds) {
+      candidate.setMilliseconds(0);
+      candidate.setSeconds(candidate.getSeconds() + 1);
+    } else {
+      candidate.setSeconds(0, 0);
+      candidate.setMinutes(candidate.getMinutes() + 1);
+    }
+    const maxIterations = schedule.hasSeconds ? 2678400 : 527040;
+    for (let index = 0; index < maxIterations; index++) {
+      if (matchesCronDate(schedule, candidate)) {
+        return new Date(candidate.getTime());
+      }
+      candidate.setTime(candidate.getTime() + stepMs);
+    }
+    return void 0;
+  }
+
+  // src/cli/pm/config.ts
   function parsePmTarget(parsed, workspaceRoot) {
     if (parsed.script) {
       return { script: parsed.script };
@@ -3553,6 +3835,20 @@ error: ${text}`);
     }
     return "process";
   }
+  function formatPmInstanceName(baseName, instanceIndex) {
+    return instanceIndex <= 1 ? baseName : `${baseName}:${instanceIndex}`;
+  }
+  function expandPmInstanceDefinitions(definition, targetInstances = definition.instances) {
+    return Array.from({ length: targetInstances }, (_, index) => {
+      const instanceIndex = index + 1;
+      return {
+        ...definition,
+        name: formatPmInstanceName(definition.baseName, instanceIndex),
+        instanceIndex,
+        instances: targetInstances
+      };
+    });
+  }
   function countDefinedTargets(app) {
     return [app.script, app.file, app.wapk].filter(Boolean).length;
   }
@@ -3590,8 +3886,25 @@ error: ${text}`);
       throw new Error("A pm app must define exactly one of script, file, or wapk.");
     }
     const name = defaultProcessName({ script, file, wapk }, parsed.name ?? base?.name);
+    const instances = parsed.instances ?? base?.instances ?? 1;
+    if (!Number.isInteger(instances) || instances < 1) {
+      throw new Error("pm instances must be a number >= 1.");
+    }
+    const proxy = normalizePmProxyConfig(
+      parsed.proxy ? { ...base?.proxy ?? {}, ...parsed.proxy } : base?.proxy,
+      parsed.proxy ? "pm proxy" : "pm.apps[].proxy"
+    );
+    if (proxy?.strategy === "inherit" && instances > 1) {
+      throw new Error('pm proxy strategy "inherit" currently supports only one managed instance per app.');
+    }
     const mergedWapkRun = mergePmWapkRunConfig(base?.wapkRun, parsed.wapkRun);
     const runtime2 = normalizePmRuntime(parsed.runtime ?? mergedWapkRun?.runtime ?? base?.runtime, "--runtime");
+    const maxMemoryBytes = parsed.maxMemoryBytes ?? normalizePmMemoryLimit(base?.maxMemory, "pm.apps[].maxMemory");
+    const memoryAction = parsed.memoryAction ?? normalizePmMemoryAction(base?.memoryAction, "pm.apps[].memoryAction") ?? "restart";
+    const cronRestart = parsed.cronRestart ?? normalizePmRestartSchedule(base?.cronRestart, "pm.apps[].cronRestart");
+    const expBackoffRestartDelay = parsed.expBackoffRestartDelay ?? (base?.expBackoffRestartDelay === void 0 ? void 0 : normalizeIntegerOption(String(base.expBackoffRestartDelay), "pm.apps[].expBackoffRestartDelay", 1));
+    const expBackoffRestartMaxDelay = parsed.expBackoffRestartMaxDelay ?? (base?.expBackoffRestartMaxDelay === void 0 ? void 0 : normalizeIntegerOption(String(base.expBackoffRestartMaxDelay), "pm.apps[].expBackoffRestartMaxDelay", 1));
+    const restartWindow = parsed.restartWindow ?? (base?.restartWindow === void 0 ? void 0 : normalizeIntegerOption(String(base.restartWindow), "pm.apps[].restartWindow", 1));
     let restartPolicy = normalizePmRestartPolicy(parsed.restartPolicy ?? base?.restartPolicy, "--restart-policy") ?? (base?.autorestart ?? true ? "always" : "never");
     if (parsed.autorestart === false) {
       restartPolicy = "never";
@@ -3611,6 +3924,7 @@ error: ${text}`);
       timeout: parsed.healthCheckTimeout,
       maxFailures: parsed.healthCheckMaxFailures
     } : base?.healthCheck);
+    const waitReady = parsed.waitReady ?? base?.waitReady ?? false;
     const password = parsed.password ?? mergedWapkRun?.password ?? base?.password;
     const wapkRun = stripPmWapkSourceFromRunConfig(mergedWapkRun);
     if (password && !wapk) {
@@ -3619,8 +3933,14 @@ error: ${text}`);
     if (wapkRun && !wapk) {
       throw new Error("WAPK run options are only supported when starting a WAPK app.");
     }
+    if (waitReady && !healthCheck) {
+      throw new Error("--wait-ready requires --health-url or pm.apps[].healthCheck.");
+    }
     return {
-      name,
+      name: formatPmInstanceName(name, 1),
+      baseName: name,
+      instanceIndex: 1,
+      instances,
       type: script ? "script" : wapk ? "wapk" : "file",
       source,
       cwd: resolvedCwd,
@@ -3635,9 +3955,19 @@ error: ${text}`);
       wapkRun,
       autorestart,
       restartDelay: parsed.restartDelay ?? base?.restartDelay ?? DEFAULT_RESTART_DELAY,
+      proxy,
+      killTimeout: parsed.killTimeout ?? base?.killTimeout ?? DEFAULT_PM_KILL_TIMEOUT,
       maxRestarts: parsed.maxRestarts ?? base?.maxRestarts ?? DEFAULT_MAX_RESTARTS,
       password,
       restartPolicy,
+      maxMemoryBytes,
+      memoryAction,
+      cronRestart,
+      expBackoffRestartDelay,
+      expBackoffRestartMaxDelay,
+      restartWindow,
+      waitReady,
+      listenTimeout: parsed.listenTimeout ?? base?.listenTimeout ?? DEFAULT_PM_LISTEN_TIMEOUT,
       minUptime: parsed.minUptime ?? base?.minUptime ?? DEFAULT_MIN_UPTIME,
       watch: watch2,
       watchPaths: watch2 ? normalizeResolvedWatchPaths(configuredWatchPaths, resolvedCwd, script ? "script" : wapk ? "wapk" : "file", file, wapk) : [],
@@ -3649,16 +3979,17 @@ error: ${text}`);
   function resolvePmStartDefinitions(parsed, config, workspaceRoot) {
     const configApps = getConfiguredPmApps(config);
     const selection = resolveStartSelection(configApps, parsed, workspaceRoot);
+    const expandDefinitions = (definitions) => definitions.flatMap((definition) => expandPmInstanceDefinitions(definition));
     if (selection.startAll) {
       if (configApps.length === 0) {
         throw new Error("No pm apps configured in elit.config.* and no start target was provided.");
       }
-      return configApps.map((app) => resolvePmAppDefinition(app, { ...parsed, name: app.name }, workspaceRoot, "config"));
+      return expandDefinitions(configApps.map((app) => resolvePmAppDefinition(app, { ...parsed, name: app.name }, workspaceRoot, "config")));
     }
     if (selection.selected) {
-      return [resolvePmAppDefinition(selection.selected, parsed, workspaceRoot, "config")];
+      return expandDefinitions([resolvePmAppDefinition(selection.selected, parsed, workspaceRoot, "config")]);
     }
-    return [resolvePmAppDefinition(void 0, parsed, workspaceRoot, "cli")];
+    return expandDefinitions([resolvePmAppDefinition(void 0, parsed, workspaceRoot, "cli")]);
   }
   function parsePmStartArgs(args) {
     const parsed = {
@@ -3731,6 +4062,39 @@ error: ${text}`);
           parsed.env[key] = value;
           break;
         }
+        case "--instances":
+          parsed.instances = normalizeIntegerOption(readRequiredValue(args, ++index, "--instances"), "--instances", 1);
+          break;
+        case "--proxy-port":
+          parsed.proxy = {
+            ...parsed.proxy,
+            port: normalizeIntegerOption(readRequiredValue(args, ++index, "--proxy-port"), "--proxy-port", 1)
+          };
+          break;
+        case "--proxy-strategy":
+          parsed.proxy = {
+            ...parsed.proxy,
+            strategy: normalizePmProxyStrategy(readRequiredValue(args, ++index, "--proxy-strategy"), "--proxy-strategy")
+          };
+          break;
+        case "--proxy-host":
+          parsed.proxy = {
+            ...parsed.proxy,
+            host: readRequiredValue(args, ++index, "--proxy-host")
+          };
+          break;
+        case "--proxy-target-host":
+          parsed.proxy = {
+            ...parsed.proxy,
+            targetHost: readRequiredValue(args, ++index, "--proxy-target-host")
+          };
+          break;
+        case "--proxy-env":
+          parsed.proxy = {
+            ...parsed.proxy,
+            envVar: readRequiredValue(args, ++index, "--proxy-env")
+          };
+          break;
         case "--password":
           parsed.password = readRequiredValue(args, ++index, "--password");
           break;
@@ -3781,6 +4145,30 @@ error: ${text}`);
         case "--restart-policy":
           parsed.restartPolicy = normalizePmRestartPolicy(readRequiredValue(args, ++index, "--restart-policy"));
           break;
+        case "--max-memory":
+          parsed.maxMemoryBytes = normalizePmMemoryLimit(readRequiredValue(args, ++index, "--max-memory"), "--max-memory");
+          break;
+        case "--memory-action":
+          parsed.memoryAction = normalizePmMemoryAction(readRequiredValue(args, ++index, "--memory-action"), "--memory-action");
+          break;
+        case "--cron-restart":
+          parsed.cronRestart = normalizePmRestartSchedule(readRequiredValue(args, ++index, "--cron-restart"), "--cron-restart");
+          break;
+        case "--exp-backoff-restart-delay":
+          parsed.expBackoffRestartDelay = normalizeIntegerOption(readRequiredValue(args, ++index, "--exp-backoff-restart-delay"), "--exp-backoff-restart-delay", 1);
+          break;
+        case "--exp-backoff-restart-max-delay":
+          parsed.expBackoffRestartMaxDelay = normalizeIntegerOption(readRequiredValue(args, ++index, "--exp-backoff-restart-max-delay"), "--exp-backoff-restart-max-delay", 1);
+          break;
+        case "--restart-window":
+          parsed.restartWindow = normalizeIntegerOption(readRequiredValue(args, ++index, "--restart-window"), "--restart-window", 1);
+          break;
+        case "--wait-ready":
+          parsed.waitReady = true;
+          break;
+        case "--listen-timeout":
+          parsed.listenTimeout = normalizeIntegerOption(readRequiredValue(args, ++index, "--listen-timeout"), "--listen-timeout", 1);
+          break;
         case "--min-uptime":
           parsed.minUptime = normalizeIntegerOption(readRequiredValue(args, ++index, "--min-uptime"), "--min-uptime");
           break;
@@ -3820,6 +4208,9 @@ error: ${text}`);
         case "--restart-delay":
           parsed.restartDelay = normalizeIntegerOption(readRequiredValue(args, ++index, "--restart-delay"), "--restart-delay");
           break;
+        case "--kill-timeout":
+          parsed.killTimeout = normalizeIntegerOption(readRequiredValue(args, ++index, "--kill-timeout"), "--kill-timeout", 1);
+          break;
         case "--max-restarts":
           parsed.maxRestarts = normalizeIntegerOption(readRequiredValue(args, ++index, "--max-restarts"), "--max-restarts");
           break;
@@ -3861,8 +4252,15 @@ error: ${text}`);
       "  elit pm start my-app",
       "  elit pm start",
       "  elit pm list",
+      "  elit pm list --json",
+      "  elit pm show <name>",
+      "  elit pm describe <name> --json",
       "  elit pm stop <name|all>",
       "  elit pm restart <name|all>",
+      "  elit pm reload <name|all>",
+      "  elit pm scale <name> <count>",
+      "  elit pm reset <name|all>",
+      "  elit pm send-signal <signal> <name|all>",
       "  elit pm delete <name|all>",
       "  elit pm save",
       "  elit pm resurrect",
@@ -3878,6 +4276,12 @@ error: ${text}`);
       "  --google-drive-shared-drive Forward supportsAllDrives=true for shared drives",
       "  --runtime, -r <name>        Runtime override: node, bun, deno",
       "  --name, -n <name>           Process name used by list/stop/restart",
+      "  --instances <count>         Start multiple managed instances for the same app name",
+      "  --proxy-port <port>         Own a public HTTP port through a PM proxy for single-instance reload handoff",
+      "  --proxy-strategy <mode>     Public socket mode: proxy or inherit (default: proxy)",
+      "  --proxy-host <host>         Public host bound by the PM proxy (default: 0.0.0.0)",
+      "  --proxy-target-host <host>  Internal host used for upstream child traffic (default: 127.0.0.1)",
+      "  --proxy-env <name>          Env var populated with the child private port (default: PORT)",
       "  --cwd <dir>                 Working directory for the managed process",
       "  --env KEY=VALUE             Add or override an environment variable",
       "  --password <value>          Password for locked WAPK archives",
@@ -3889,6 +4293,14 @@ error: ${text}`);
       "  --no-archive-watch          Disable archive-source read sync for WAPK apps",
       "  --archive-sync-interval <ms>  Forward WAPK archive read-sync interval (>= 50ms)",
       "  --restart-policy <mode>     Restart policy: always, on-failure, never",
+      "  --max-memory <bytes|size>   Trigger a memory action after a limit like 268435456 or 256M",
+      "  --memory-action <mode>      Action on max-memory: restart, stop",
+      "  --cron-restart <expr>       Restart on a cron schedule or @every <duration>",
+      "  --exp-backoff-restart-delay <ms>  Exponential unstable-restart backoff base delay",
+      "  --exp-backoff-restart-max-delay <ms>  Maximum unstable-restart backoff delay (default 15000)",
+      "  --restart-window <ms>       Rolling time window used when counting restart attempts",
+      "  --wait-ready                Keep the process in starting state until its health check succeeds",
+      "  --listen-timeout <ms>       Startup wait limit when --wait-ready is enabled (default 3000)",
       "  --min-uptime <ms>           Reset crash counter after this healthy uptime",
       "  --watch                     Restart when watched files change",
       "  --watch-path <path>         Add a file or directory to watch",
@@ -3901,6 +4313,7 @@ error: ${text}`);
       "  --health-max-failures <n>   Consecutive failures before restart (default 3)",
       "  --no-autorestart            Disable automatic restart",
       "  --restart-delay <ms>        Delay between restart attempts (default 1000)",
+      "  --kill-timeout <ms>         Grace period before force-killing a stop or restart (default 5000)",
       "  --max-restarts <count>      Maximum restart attempts (default 10)",
       "",
       "Config:",
@@ -3924,6 +4337,17 @@ error: ${text}`);
       "  - elit pm save persists running apps to pm.dumpFile or ./.elit/pm/dump.json.",
       "  - elit pm resurrect restarts whatever was last saved by elit pm save.",
       "  - elit pm start <name> starts a configured app by name.",
+      "  - elit pm reload <name|all> performs a rolling stop/start and waits for each instance to return online before continuing.",
+      "  - elit pm scale <name> <count> changes the number of managed instances for a running app group.",
+      "  - elit pm reset <name|all> clears restart count, last exit code, and saved error metadata.",
+      "  - elit pm send-signal <signal> <name|all> forwards a POSIX-style signal such as SIGUSR2 or TERM.",
+      "  - maxMemory works with memoryAction=restart|stop, cronRestart accepts cron or @every schedules, expBackoffRestartDelay doubles unstable restart delays, expBackoffRestartMaxDelay caps them, and restartWindow limits how long restart attempts keep counting toward maxRestarts.",
+      "  - killTimeout controls how long PM waits before force-killing an app that ignores stop or restart requests.",
+      "  - waitReady uses the configured health check as a startup gate and errors if it never becomes healthy within listenTimeout.",
+      "  - elit pm list shows live cpu, memory, and uptime columns when the child process is running.",
+      "  - elit pm list --json and elit pm jlist print machine-readable process state.",
+      "  - elit pm list --json, elit pm show --json, and elit pm describe --json include liveMetrics when available.",
+      "  - elit pm show <name> and elit pm describe <name> expose the full saved process record.",
       "  - TypeScript files with runtime node require tsx, otherwise use --runtime bun.",
       "  - WAPK processes are executed through elit wapk run inside the manager.",
       "  - WAPK PM apps can use local archives, gdrive://<fileId>, or pm.apps[].wapkRun.googleDrive.",
@@ -3979,16 +4403,94 @@ error: ${text}`);
     const globalCommand = process.platform === "win32" ? "tsx.cmd" : "tsx";
     return commandExists(globalCommand) ? globalCommand : void 0;
   }
+  function resolvePmNodeSharedListenerBootstrapPath() {
+    const cliEntry = process.argv[1];
+    const candidates = [
+      (0, import_node_path5.join)(__dirname, "node-shared-listener-bootstrap.cjs"),
+      (0, import_node_path5.join)(__dirname, "..", "..", "..", "dist", "pm-node-shared-listener-bootstrap.cjs")
+    ];
+    if (cliEntry) {
+      const resolvedCliEntry = (0, import_node_path5.resolve)(cliEntry);
+      const baseDir = (0, import_node_path5.dirname)(resolvedCliEntry);
+      candidates.push(
+        (0, import_node_path5.join)(baseDir, "cli", "pm", "node-shared-listener-bootstrap.cjs"),
+        (0, import_node_path5.join)(baseDir, "pm-node-shared-listener-bootstrap.cjs")
+      );
+    }
+    return candidates.find((candidate) => (0, import_node_fs3.existsSync)(candidate));
+  }
+  function appendNodeOption(existing, option) {
+    return existing && existing.trim().length > 0 ? `${existing.trim()} ${option}` : option;
+  }
+  function supportsPmInheritedListener(record, runtime2) {
+    return (record.proxy?.strategy ?? DEFAULT_PM_PROXY_STRATEGY) === "inherit" && record.type === "file" && runtime2 === "node" && !isTypescriptFile(record.file);
+  }
   function inferRuntimeFromFile(filePath) {
     if (isTypescriptFile(filePath) && commandExists("bun")) {
       return "bun";
     }
     return "node";
   }
+  function sampleWindowsPmProcessMetrics(pid) {
+    const script = [
+      '$ErrorActionPreference = "Stop"',
+      `$sample = Get-CimInstance -ClassName Win32_PerfFormattedData_PerfProc_Process -Filter "IDProcess = ${pid}" | Select-Object -First 1`,
+      "if (-not $sample) { exit 2 }",
+      "$cpu = [double]$sample.PercentProcessorTime",
+      `$memory = if ($sample.PSObject.Properties.Match('WorkingSetPrivate').Count -gt 0) { [int64]$sample.WorkingSetPrivate } else { [int64](Get-Process -Id ${pid} -ErrorAction Stop).WorkingSet64 }`,
+      'Write-Output ($cpu.ToString([System.Globalization.CultureInfo]::InvariantCulture) + "," + $memory)'
+    ].join("; ");
+    const result = (0, import_node_child_process.spawnSync)(
+      "powershell.exe",
+      ["-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-Command", script],
+      {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"],
+        windowsHide: true
+      }
+    );
+    if (result.error || result.status !== 0) {
+      return {};
+    }
+    const [cpuText, memoryText] = result.stdout.trim().split(",");
+    const cpuPercent = Number.parseFloat((cpuText ?? "").replace(",", "."));
+    const memoryRssBytes = Number.parseInt(memoryText ?? "", 10);
+    return {
+      cpuPercent: Number.isFinite(cpuPercent) ? cpuPercent : void 0,
+      memoryRssBytes: Number.isFinite(memoryRssBytes) ? memoryRssBytes : void 0
+    };
+  }
+  function samplePosixPmProcessMetrics(pid) {
+    const result = (0, import_node_child_process.spawnSync)(
+      "ps",
+      ["-p", String(pid), "-o", "%cpu=", "-o", "rss="],
+      {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"],
+        windowsHide: true
+      }
+    );
+    if (result.error || result.status !== 0) {
+      return {};
+    }
+    const [cpuText, memoryText] = result.stdout.trim().split(/\s+/, 2);
+    const cpuPercent = Number.parseFloat((cpuText ?? "").replace(",", "."));
+    const rssKilobytes = Number.parseInt(memoryText ?? "", 10);
+    return {
+      cpuPercent: Number.isFinite(cpuPercent) ? cpuPercent : void 0,
+      memoryRssBytes: Number.isFinite(rssKilobytes) ? rssKilobytes * 1024 : void 0
+    };
+  }
+  function samplePmProcessMetrics(pid) {
+    return process.platform === "win32" ? sampleWindowsPmProcessMetrics(pid) : samplePosixPmProcessMetrics(pid);
+  }
   function isPmOnlineWapkRecord(record) {
     return record.type === "wapk" && isPmWapkOnlineRunConfig(record.wapkRun);
   }
   function buildPmCommand(record) {
+    if ((record.proxy?.strategy ?? DEFAULT_PM_PROXY_STRATEGY) === "inherit" && record.type !== "file") {
+      throw new Error('pm proxy strategy "inherit" currently supports only Node .js/.mjs/.cjs file targets.');
+    }
     if (record.type === "script") {
       return {
         command: record.script,
@@ -4060,9 +4562,23 @@ error: ${text}`);
     }
     const executable = preferCurrentExecutable("node");
     ensureCommandAvailable(executable, "Node.js runtime");
+    const wantsInheritedListener = (record.proxy?.strategy ?? DEFAULT_PM_PROXY_STRATEGY) === "inherit";
+    if (wantsInheritedListener && !supportsPmInheritedListener(record, runtime2)) {
+      throw new Error('pm proxy strategy "inherit" currently supports only Node .js/.mjs/.cjs file targets.');
+    }
+    const bootstrapPath = wantsInheritedListener ? resolvePmNodeSharedListenerBootstrapPath() : void 0;
+    if (wantsInheritedListener && !bootstrapPath) {
+      throw new Error("Unable to resolve the PM shared-listener bootstrap module.");
+    }
     return {
       command: executable,
       args: [record.file],
+      env: bootstrapPath ? {
+        NODE_OPTIONS: appendNodeOption(process.env.NODE_OPTIONS, `--require=${bootstrapPath}`),
+        ELIT_PM_LISTEN_MODE: "ipc",
+        ELIT_PM_PUBLIC_PORT: String(record.proxy?.port ?? record.env.PORT ?? "")
+      } : void 0,
+      ipc: Boolean(bootstrapPath),
       runtime: runtime2,
       preview: `${(0, import_node_path5.basename)(executable)} ${quoteCommandSegment(record.file)}`
     };
@@ -4074,20 +4590,33 @@ error: ${text}`);
     return {
       id,
       name: definition.name,
+      baseName: definition.baseName,
+      instanceIndex: definition.instanceIndex,
+      instances: definition.instances,
       type: definition.type,
       source: definition.source,
       cwd: definition.cwd,
       runtime: definition.runtime,
       env: definition.env,
+      proxy: definition.proxy,
       script: definition.script,
       file: definition.file,
       wapk: definition.wapk,
       wapkRun: definition.wapkRun,
       autorestart: definition.autorestart,
       restartDelay: definition.restartDelay,
+      killTimeout: definition.killTimeout,
       maxRestarts: definition.maxRestarts,
       password: definition.password,
       restartPolicy: definition.restartPolicy,
+      maxMemoryBytes: definition.maxMemoryBytes,
+      memoryAction: definition.memoryAction,
+      cronRestart: definition.cronRestart,
+      expBackoffRestartDelay: definition.expBackoffRestartDelay,
+      expBackoffRestartMaxDelay: definition.expBackoffRestartMaxDelay,
+      restartWindow: definition.restartWindow,
+      waitReady: definition.waitReady,
+      listenTimeout: definition.listenTimeout,
       minUptime: definition.minUptime,
       watch: definition.watch,
       watchPaths: definition.watchPaths,
@@ -4103,16 +4632,20 @@ error: ${text}`);
       stoppedAt: void 0,
       runnerPid: void 0,
       childPid: void 0,
+      proxyTargetPort: void 0,
       restartCount: existing?.restartCount ?? 0,
+      reloadRequestedAt: void 0,
+      lastRestartAt: existing?.lastRestartAt,
       lastExitCode: existing?.lastExitCode,
       error: void 0,
+      proxyReadyAt: void 0,
       logFiles: existing?.logFiles ?? {
         out: (0, import_node_path5.join)(paths.logsDir, `${id}.out.log`),
         err: (0, import_node_path5.join)(paths.logsDir, `${id}.err.log`)
       }
     };
   }
-  function terminateProcessTree(pid) {
+  function terminateProcessTree(pid, options) {
     if (process.platform === "win32") {
       const result = (0, import_node_child_process.spawnSync)("taskkill", ["/PID", String(pid), "/T", "/F"], {
         stdio: "ignore",
@@ -4124,7 +4657,17 @@ error: ${text}`);
       return;
     }
     try {
-      process.kill(pid, "SIGTERM");
+      process.kill(pid, options?.force ? "SIGKILL" : "SIGTERM");
+    } catch (error) {
+      const code = error.code;
+      if (code !== "ESRCH") {
+        throw error;
+      }
+    }
+  }
+  function sendPmSignal(pid, signal) {
+    try {
+      process.kill(pid, signal);
     } catch (error) {
       const code = error.code;
       if (code !== "ESRCH") {
@@ -4176,6 +4719,7 @@ error: ${text}`);
 
   // src/cli/pm/runner.ts
   var import_node_child_process2 = __require("child_process");
+  var import_node_http2 = __require("http");
   var import_node_fs4 = __require("fs");
   var import_node_os = __require("os");
   var import_node_path6 = __require("path");
@@ -4409,13 +4953,13 @@ error: ${text}`);
   function join5(...paths) {
     return joinPaths(paths, isWindows);
   }
-  function resolve4(...paths) {
+  function resolve5(...paths) {
     return resolvePaths(paths, isWindows);
   }
   function relative(from, to) {
     return relativePath(from, to, isWindows);
   }
-  function dirname2(path) {
+  function dirname3(path) {
     return getDirname(path, isWindows);
   }
 
@@ -4453,14 +4997,14 @@ error: ${text}`);
     }
     if (normalizedPattern && existsSync4(normalizedPattern)) {
       try {
-        return statSync2(normalizedPattern).isDirectory() ? normalizedPattern : normalizePath2(dirname2(normalizedPattern)) || ".";
+        return statSync2(normalizedPattern).isDirectory() ? normalizedPattern : normalizePath2(dirname3(normalizedPattern)) || ".";
       } catch {
-        return normalizePath2(dirname2(normalizedPattern)) || ".";
+        return normalizePath2(dirname3(normalizedPattern)) || ".";
       }
     }
     const lastSegment = parts[parts.length - 1] || "";
     if (lastSegment.includes(".") && !lastSegment.startsWith(".")) {
-      return normalizePath2(dirname2(normalizedPattern)) || ".";
+      return normalizePath2(dirname3(normalizedPattern)) || ".";
     }
     return normalizedPattern || ".";
   }
@@ -4655,9 +5199,210 @@ error: ${text}`);
     return watcher;
   }
 
+  // src/cli/pm/proxy.ts
+  var import_node_http = __require("http");
+  var import_node_https = __require("https");
+  var import_node_net = __require("net");
+  function resolvePmProxyHost(proxy) {
+    return proxy.host?.trim() || "0.0.0.0";
+  }
+  function resolvePmProxyTargetHost(proxy) {
+    return proxy.targetHost?.trim() || "127.0.0.1";
+  }
+  function resolvePmProxyEnvVar(proxy) {
+    return proxy.envVar?.trim() || "PORT";
+  }
+  function buildPmProxyTargetUrl(proxy, targetPort) {
+    return `http://${resolvePmProxyTargetHost(proxy)}:${targetPort}`;
+  }
+  function rewritePmProxyHealthCheckUrl(url, targetHost, targetPort) {
+    const targetUrl = new URL(url);
+    targetUrl.hostname = targetHost;
+    targetUrl.port = String(targetPort);
+    return targetUrl.toString();
+  }
+  async function allocatePmProxyTargetPort(host = "127.0.0.1") {
+    const server = (0, import_node_net.createServer)();
+    return await new Promise((resolve7, reject) => {
+      server.once("error", reject);
+      server.listen(0, host, () => {
+        const address = server.address();
+        if (!address || typeof address === "string") {
+          server.close(() => reject(new Error("Failed to allocate an internal PM proxy port.")));
+          return;
+        }
+        const port = address.port;
+        server.close((error) => {
+          if (error) {
+            reject(error);
+            return;
+          }
+          resolve7(port);
+        });
+      });
+    });
+  }
+  function buildPmProxyHeaders(headersInput, host) {
+    const headers = {};
+    for (const [key, value] of Object.entries(headersInput)) {
+      if (value !== void 0) {
+        headers[key] = value;
+      }
+    }
+    headers.host = host;
+    return headers;
+  }
+  function writeRawHttpResponse(socket, statusCode, statusMessage, headers) {
+    const lines = [`HTTP/1.1 ${statusCode} ${statusMessage}`];
+    for (const [key, value] of Object.entries(headers)) {
+      if (value === void 0) {
+        continue;
+      }
+      if (Array.isArray(value)) {
+        for (const item of value) {
+          lines.push(`${key}: ${item}`);
+        }
+        continue;
+      }
+      lines.push(`${key}: ${value}`);
+    }
+    socket.write(`${lines.join("\r\n")}\r
+\r
+`);
+  }
+  async function createPmProxyController(proxy) {
+    let targets = [];
+    let nextTargetIndex = 0;
+    const setResolvedTargets = (nextTargets) => {
+      const unchanged = nextTargets.length === targets.length && nextTargets.every((target, index) => targets[index]?.href === target.href);
+      targets = nextTargets;
+      if (targets.length === 0) {
+        nextTargetIndex = 0;
+        return;
+      }
+      if (!unchanged) {
+        nextTargetIndex = nextTargetIndex % targets.length;
+      }
+    };
+    const pickTarget = () => {
+      if (targets.length === 0) {
+        return null;
+      }
+      const target = targets[nextTargetIndex % targets.length];
+      nextTargetIndex = (nextTargetIndex + 1) % targets.length;
+      return target;
+    };
+    const server = (0, import_node_http.createServer)((req, res) => {
+      const target = pickTarget();
+      if (!target) {
+        res.statusCode = 503;
+        res.end("PM proxy target is not ready.");
+        return;
+      }
+      const requestLib = target.protocol === "https:" ? import_node_https.request : import_node_http.request;
+      const targetUrl = new URL(req.url || "/", target);
+      const headers = buildPmProxyHeaders(req.headers, target.host);
+      const proxyReq = requestLib(targetUrl, {
+        method: req.method,
+        headers
+      }, (proxyRes) => {
+        const outgoingHeaders = {};
+        for (const [key, value] of Object.entries(proxyRes.headers)) {
+          if (value !== void 0) {
+            outgoingHeaders[key] = value;
+          }
+        }
+        res.writeHead(proxyRes.statusCode || 200, outgoingHeaders);
+        proxyRes.pipe(res);
+      });
+      proxyReq.on("error", (error) => {
+        if (!res.headersSent) {
+          res.statusCode = 502;
+        }
+        res.end(`PM proxy error: ${error.message}`);
+      });
+      req.pipe(proxyReq);
+    });
+    server.on("upgrade", (req, socket, head) => {
+      const target = pickTarget();
+      if (!target) {
+        writeRawHttpResponse(socket, 503, "Service Unavailable", {
+          connection: "close",
+          "content-length": 0
+        });
+        socket.destroy();
+        return;
+      }
+      const requestLib = target.protocol === "https:" ? import_node_https.request : import_node_http.request;
+      const targetUrl = new URL(req.url || "/", target);
+      const proxyReq = requestLib(targetUrl, {
+        method: req.method,
+        headers: buildPmProxyHeaders(req.headers, target.host)
+      });
+      proxyReq.on("upgrade", (proxyRes, proxySocket, proxyHead) => {
+        writeRawHttpResponse(socket, proxyRes.statusCode || 101, proxyRes.statusMessage || "Switching Protocols", proxyRes.headers);
+        if (head.length > 0) {
+          proxySocket.write(head);
+        }
+        if (proxyHead.length > 0) {
+          socket.write(proxyHead);
+        }
+        socket.on("error", () => proxySocket.destroy());
+        proxySocket.on("error", () => socket.destroy());
+        proxySocket.pipe(socket);
+        socket.pipe(proxySocket);
+      });
+      proxyReq.on("response", (proxyRes) => {
+        writeRawHttpResponse(socket, proxyRes.statusCode || 502, proxyRes.statusMessage || "Bad Gateway", proxyRes.headers);
+        proxyRes.pipe(socket);
+      });
+      proxyReq.on("error", (error) => {
+        writeRawHttpResponse(socket, 502, "Bad Gateway", {
+          connection: "close",
+          "content-type": "text/plain; charset=utf-8",
+          "content-length": Buffer.byteLength(`PM proxy error: ${error.message}`)
+        });
+        socket.end(`PM proxy error: ${error.message}`);
+      });
+      proxyReq.end();
+    });
+    await new Promise((resolve7, reject) => {
+      server.once("error", reject);
+      server.listen(proxy.port, resolvePmProxyHost(proxy), () => resolve7());
+    });
+    return {
+      setTarget(targetUrl) {
+        setResolvedTargets(targetUrl ? [new URL(targetUrl)] : []);
+      },
+      setTargets(targetUrls) {
+        setResolvedTargets(targetUrls.map((targetUrl) => new URL(targetUrl)));
+      },
+      close() {
+        return new Promise((resolve7, reject) => {
+          server.close((error) => {
+            if (error) {
+              reject(error);
+              return;
+            }
+            resolve7();
+          });
+        });
+      }
+    };
+  }
+
   // src/cli/pm/runner.ts
   function writePmLog(stream, message) {
-    stream.write(`[elit pm] ${(/* @__PURE__ */ new Date()).toISOString()} ${message}${import_node_os.EOL}`);
+    if (stream.writableEnded || stream.destroyed) {
+      return;
+    }
+    try {
+      stream.write(`[elit pm] ${(/* @__PURE__ */ new Date()).toISOString()} ${message}${import_node_os.EOL}`);
+    } catch (error) {
+      if (error.code !== "ERR_STREAM_WRITE_AFTER_END") {
+        throw error;
+      }
+    }
   }
   function waitForExit(code, signal) {
     if (typeof code === "number") {
@@ -4671,38 +5416,367 @@ error: ${text}`);
   async function delay(milliseconds) {
     await new Promise((resolvePromise) => setTimeout(resolvePromise, milliseconds));
   }
-  async function waitForProcessTermination(pid, timeoutMs) {
-    if (!pid || !isProcessAlive(pid)) {
-      return true;
-    }
-    const deadline = Date.now() + timeoutMs;
-    while (Date.now() < deadline) {
-      if (!isProcessAlive(pid)) {
-        return true;
-      }
-      await delay(DEFAULT_PM_STOP_POLL_MS);
-    }
-    return !isProcessAlive(pid);
+  function resolveRunnerPathsFromRecordFile(filePath) {
+    const appsDir = (0, import_node_path6.dirname)(filePath);
+    const dataDir = (0, import_node_path6.dirname)(appsDir);
+    return {
+      dataDir,
+      appsDir,
+      logsDir: (0, import_node_path6.join)(dataDir, "logs"),
+      dumpFile: (0, import_node_path6.join)(dataDir, DEFAULT_PM_DUMP_FILE)
+    };
   }
-  async function waitForManagedChildExit(child) {
-    return await new Promise((resolvePromise) => {
-      let resolved = false;
-      child.once("error", (error) => {
-        if (resolved) {
-          return;
-        }
-        resolved = true;
-        resolvePromise({ code: 1, signal: null, error: error instanceof Error ? error.message : String(error) });
-      });
-      child.once("close", (code, signal) => {
-        if (resolved) {
-          return;
-        }
-        resolved = true;
-        resolvePromise({ code, signal });
+  function usesPmProxyController(record) {
+    return Boolean(record.proxy) && (record.proxy?.strategy ?? DEFAULT_PM_PROXY_STRATEGY) === "proxy";
+  }
+  function usesPmInheritedListener(record) {
+    return Boolean(record.proxy) && (record.proxy?.strategy ?? DEFAULT_PM_PROXY_STRATEGY) === "inherit";
+  }
+  function isPmProxyOwner(record) {
+    return usesPmProxyController(record) && record.instanceIndex === 1;
+  }
+  function resolvePmProxyTargetUrls(paths, baseName) {
+    return listPmRecordMatches(paths).filter((match) => match.record.baseName === baseName).filter((match) => usesPmProxyController(match.record)).filter((match) => match.record.desiredState === "running" && Boolean(match.record.proxyReadyAt)).filter((match) => typeof match.record.proxyTargetPort === "number" && match.record.proxyTargetPort > 0).sort((left, right) => left.record.instanceIndex - right.record.instanceIndex).map((match) => buildPmProxyTargetUrl(match.record.proxy, match.record.proxyTargetPort));
+  }
+  async function createPmInheritedListener(proxy) {
+    const server = (0, import_node_http2.createServer)();
+    await new Promise((resolvePromise, reject) => {
+      server.once("error", reject);
+      server.listen(proxy.port, resolvePmProxyHost(proxy), () => resolvePromise());
+    });
+    return server;
+  }
+  function createPmChildIpcState(child, sharedListener) {
+    let bootstrapReady = false;
+    let listenerReady = false;
+    let sharedHandleSent = false;
+    const sendSharedHandle = () => {
+      if (!sharedListener || !bootstrapReady || sharedHandleSent || !child.connected) {
+        return;
+      }
+      sharedHandleSent = true;
+      child.send?.({ type: "elit:pm:listen-handle" }, sharedListener);
+    };
+    const onMessage = (message) => {
+      if (!message || typeof message !== "object") {
+        return;
+      }
+      if (message.type === "elit:pm:bootstrap-ready") {
+        bootstrapReady = true;
+        sendSharedHandle();
+        return;
+      }
+      if (message.type === "elit:pm:listener-ready") {
+        listenerReady = true;
+      }
+    };
+    child.on("message", onMessage);
+    return {
+      get bootstrapReady() {
+        return bootstrapReady;
+      },
+      get listenerReady() {
+        return listenerReady;
+      },
+      stop() {
+        child.off("message", onMessage);
+      }
+    };
+  }
+  function buildPmChildEnv(record, command, targetPort) {
+    return {
+      ...process.env,
+      ...record.env,
+      ...command.env,
+      ...usesPmProxyController(record) && targetPort ? {
+        [resolvePmProxyEnvVar(record.proxy)]: String(targetPort),
+        ELIT_PM_PUBLIC_PORT: String(record.proxy.port)
+      } : {},
+      ELIT_PM_NAME: record.name,
+      ELIT_PM_ID: record.id
+    };
+  }
+  function buildPmChildStdio(command, onlineStdinShutdownEnabled) {
+    return [
+      onlineStdinShutdownEnabled ? "pipe" : "ignore",
+      "pipe",
+      "pipe",
+      ...command.ipc ? ["ipc"] : []
+    ];
+  }
+  function createPmReadinessMonitor(record, onReady, onFailure, options) {
+    if (options?.ipcController) {
+      let stopped2 = false;
+      let timer2 = null;
+      let timeoutTimer2 = null;
+      const clearTimers2 = () => {
+        if (timer2) {
+          clearInterval(timer2);
+          timer2 = null;
+        }
+        if (timeoutTimer2) {
+          clearTimeout(timeoutTimer2);
+          timeoutTimer2 = null;
+        }
+      };
+      const host = record.proxy?.host ?? "0.0.0.0";
+      const port = record.proxy?.port ?? 0;
+      timer2 = setInterval(() => {
+        if (stopped2 || !options.ipcController?.listenerReady) {
+          return;
+        }
+        stopped2 = true;
+        clearTimers2();
+        onReady(`shared listener ready on ${host}:${port}`);
+      }, 25);
+      timer2.unref?.();
+      timeoutTimer2 = setTimeout(() => {
+        if (stopped2) {
+          return;
+        }
+        stopped2 = true;
+        clearTimers2();
+        onFailure(`listen timeout reached after ${record.listenTimeout}ms while waiting for shared listener ${host}:${port}`);
+      }, record.listenTimeout);
+      timeoutTimer2.unref?.();
+      return {
+        stop() {
+          stopped2 = true;
+          clearTimers2();
+        }
+      };
+    }
+    if (!record.waitReady || !record.healthCheck) {
+      return {
+        stop() {
+        }
+      };
+    }
+    const healthCheck = record.healthCheck;
+    const pollInterval = Math.max(50, Math.min(healthCheck.interval, 250));
+    let stopped = false;
+    let timer = null;
+    let timeoutTimer = null;
+    let inFlight = false;
+    const clearTimers = () => {
+      if (timer) {
+        clearInterval(timer);
+        timer = null;
+      }
+      if (timeoutTimer) {
+        clearTimeout(timeoutTimer);
+        timeoutTimer = null;
+      }
+    };
+    const runHealthCheck = async () => {
+      if (stopped || inFlight) {
+        return;
+      }
+      inFlight = true;
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), healthCheck.timeout);
+      timeoutId.unref?.();
+      try {
+        const response = await fetch(healthCheck.url, {
+          method: "GET",
+          signal: controller.signal
+        });
+        if (stopped) {
+          return;
+        }
+        if (!response.ok) {
+          throw new Error(`health check returned ${response.status}`);
+        }
+        stopped = true;
+        clearTimers();
+        onReady(`readiness check passed: ${healthCheck.url}`);
+      } catch {
+      } finally {
+        clearTimeout(timeoutId);
+        inFlight = false;
+      }
+    };
+    timeoutTimer = setTimeout(() => {
+      if (stopped) {
+        return;
+      }
+      stopped = true;
+      clearTimers();
+      onFailure(`listen timeout reached after ${record.listenTimeout}ms while waiting for ${healthCheck.url}`);
+    }, record.listenTimeout);
+    timeoutTimer.unref?.();
+    void runHealthCheck();
+    timer = setInterval(() => {
+      void runHealthCheck();
+    }, pollInterval);
+    timer.unref?.();
+    return {
+      stop() {
+        stopped = true;
+        clearTimers();
+      }
+    };
+  }
+  function resolvePmStopTimeout(record) {
+    if (isPmOnlineWapkRecord(record)) {
+      return Math.max(record.killTimeout, PM_WAPK_ONLINE_SHUTDOWN_TIMEOUT_MS);
+    }
+    return record.killTimeout;
+  }
+  function supportsPmProxyReload(record) {
+    return Boolean(record.proxy) && record.instances === 1;
+  }
+  function buildPmMonitorRecord(record, targetPort) {
+    if (!record.proxy || !targetPort) {
+      return record;
+    }
+    const targetHost = resolvePmProxyTargetHost(record.proxy);
+    return {
+      ...record,
+      proxyTargetPort: targetPort,
+      healthCheck: record.healthCheck ? {
+        ...record.healthCheck,
+        url: rewritePmProxyHealthCheckUrl(record.healthCheck.url, targetHost, targetPort)
+      } : void 0
+    };
+  }
+  async function waitForProcessTermination(pid, timeoutMs) {
+    if (!pid || !isProcessAlive(pid)) {
+      return true;
+    }
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+      if (!isProcessAlive(pid)) {
+        return true;
+      }
+      await delay(DEFAULT_PM_STOP_POLL_MS);
+    }
+    return !isProcessAlive(pid);
+  }
+  async function waitForManagedChildExit(child) {
+    return await new Promise((resolvePromise) => {
+      let resolved = false;
+      child.once("error", (error) => {
+        if (resolved) {
+          return;
+        }
+        resolved = true;
+        resolvePromise({ code: 1, signal: null, error: error instanceof Error ? error.message : String(error) });
+      });
+      child.once("close", (code, signal) => {
+        if (resolved) {
+          return;
+        }
+        resolved = true;
+        resolvePromise({ code, signal });
       });
     });
   }
+  async function createPmChildControllers(record, child, stdoutLog, stderrLog, requestPlannedRestart, onReady, options) {
+    let healthMonitor = {
+      stop() {
+      }
+    };
+    let memoryMonitor = {
+      stop() {
+      }
+    };
+    let scheduleMonitor = {
+      stop() {
+      }
+    };
+    const startHealthMonitor = () => {
+      healthMonitor = createPmHealthMonitor(
+        record,
+        (message) => requestPlannedRestart("health", message),
+        (message) => writePmLog(stdoutLog, message)
+      );
+    };
+    const needsReadySignal = Boolean(options?.ipcController) || record.waitReady;
+    const readinessMonitor = options?.ready || !needsReadySignal ? { stop() {
+    } } : createPmReadinessMonitor(
+      record,
+      (message) => {
+        onReady(message);
+        startHealthMonitor();
+      },
+      (message) => requestPlannedRestart("startup", message),
+      { ipcController: options?.ipcController }
+    );
+    const watchController = await createPmWatchController(
+      record,
+      (changedPath) => requestPlannedRestart("watch", changedPath),
+      (message) => writePmLog(stderrLog, `watch error: ${message}`)
+    );
+    memoryMonitor = createPmMemoryMonitor(
+      record,
+      child.pid,
+      (kind, message) => requestPlannedRestart(kind, message)
+    );
+    scheduleMonitor = createPmScheduleMonitor(
+      record,
+      (message) => requestPlannedRestart("cron", message),
+      (message) => writePmLog(stdoutLog, message)
+    );
+    if (options?.ready || !needsReadySignal) {
+      startHealthMonitor();
+    }
+    return {
+      async stop() {
+        await watchController.close();
+        readinessMonitor.stop();
+        healthMonitor.stop();
+        memoryMonitor.stop();
+        scheduleMonitor.stop();
+      }
+    };
+  }
+  async function waitForPmChildReady(record, child, ipcController) {
+    if (!ipcController && (!record.waitReady || !record.healthCheck)) {
+      return { ready: true };
+    }
+    let readyMessage;
+    let failureMessage;
+    let exitResult;
+    const readinessMonitor = createPmReadinessMonitor(
+      record,
+      (message) => {
+        readyMessage = message;
+      },
+      (message) => {
+        failureMessage = message;
+      },
+      { ipcController }
+    );
+    void waitForManagedChildExit(child).then((result) => {
+      exitResult = result;
+    });
+    while (!readyMessage && !failureMessage && !exitResult) {
+      await delay(25);
+    }
+    readinessMonitor.stop();
+    if (readyMessage) {
+      return { ready: true, message: readyMessage };
+    }
+    return {
+      ready: false,
+      message: failureMessage,
+      exitResult
+    };
+  }
+  async function stopProxyManagedChild(child, record, stderrLog) {
+    if (!child.pid || !isProcessAlive(child.pid)) {
+      return;
+    }
+    terminateProcessTree(child.pid);
+    const stopTimeout = resolvePmStopTimeout(record);
+    const stopped = await waitForProcessTermination(child.pid, stopTimeout);
+    if (!stopped && child.pid && isProcessAlive(child.pid)) {
+      writePmLog(stderrLog, `proxy handoff shutdown timed out after ${stopTimeout}ms; forcing process termination`);
+      terminateProcessTree(child.pid, { force: true });
+      await waitForProcessTermination(child.pid, DEFAULT_PM_STOP_POLL_MS);
+    }
+  }
   async function createPmWatchController(record, onChange, onError) {
     if (!record.watch || record.watchPaths.length === 0) {
       return {
@@ -4766,11 +5840,17 @@ error: ${text}`);
           method: "GET",
           signal: controller.signal
         });
+        if (stopped) {
+          return;
+        }
         if (!response.ok) {
           throw new Error(`health check returned ${response.status}`);
         }
         failureCount = 0;
       } catch (error) {
+        if (stopped) {
+          return;
+        }
         failureCount += 1;
         const message = error instanceof Error ? error.message : String(error);
         onLog(`health check failed (${failureCount}/${healthCheck.maxFailures}): ${message}`);
@@ -4805,6 +5885,90 @@ error: ${text}`);
       }
     };
   }
+  function createPmMemoryMonitor(record, pid, onFailure) {
+    if (!record.maxMemoryBytes || !pid) {
+      return {
+        stop() {
+        }
+      };
+    }
+    const memoryLimit = record.maxMemoryBytes;
+    let stopped = false;
+    const timer = setInterval(() => {
+      if (stopped) {
+        return;
+      }
+      const memoryRssBytes = samplePmProcessMetrics(pid).memoryRssBytes;
+      if (memoryRssBytes === void 0 || memoryRssBytes <= memoryLimit) {
+        return;
+      }
+      stopped = true;
+      onFailure(record.memoryAction === "stop" ? "memory-stop" : "memory", `memory usage ${memoryRssBytes} exceeded limit ${memoryLimit}`);
+    }, DEFAULT_PM_MEMORY_CHECK_INTERVAL);
+    timer.unref?.();
+    return {
+      stop() {
+        stopped = true;
+        clearInterval(timer);
+      }
+    };
+  }
+  function createPmScheduleMonitor(record, onTrigger, onLog) {
+    if (!record.cronRestart) {
+      return {
+        stop() {
+        }
+      };
+    }
+    const schedule = parsePmRestartSchedule(record.cronRestart, "pm cronRestart");
+    let stopped = false;
+    let timer = null;
+    const armTimer = (from = /* @__PURE__ */ new Date()) => {
+      const nextOccurrence = resolveNextPmScheduleOccurrence(schedule, from);
+      if (!nextOccurrence) {
+        onLog(`schedule has no next occurrence: ${record.cronRestart}`);
+        return;
+      }
+      const delayMs = Math.max(0, nextOccurrence.getTime() - Date.now());
+      timer = setTimeout(() => {
+        timer = null;
+        if (stopped) {
+          return;
+        }
+        onTrigger(`restart schedule matched: ${record.cronRestart}`);
+      }, delayMs);
+      timer.unref?.();
+    };
+    armTimer();
+    return {
+      stop() {
+        stopped = true;
+        if (timer) {
+          clearTimeout(timer);
+          timer = null;
+        }
+      }
+    };
+  }
+  function resolvePmRestartDelay(record, restartCount, shouldApplyBackoff) {
+    if (!shouldApplyBackoff || !record.expBackoffRestartDelay) {
+      return record.restartDelay;
+    }
+    const exponent = Math.max(0, restartCount - 1);
+    return Math.min(record.expBackoffRestartDelay * 2 ** exponent, record.expBackoffRestartMaxDelay ?? DEFAULT_PM_EXP_BACKOFF_MAX_DELAY);
+  }
+  function resolvePmRestartCountBase(record, wasStable, restartKind) {
+    if (wasStable) {
+      return 0;
+    }
+    if (record.restartWindow && record.lastRestartAt) {
+      const lastRestartTime = Date.parse(record.lastRestartAt);
+      if (!Number.isNaN(lastRestartTime) && Date.now() - lastRestartTime > record.restartWindow) {
+        return 0;
+      }
+    }
+    return restartKind === "watch" ? record.restartCount ?? 0 : record.restartCount ?? 0;
+  }
   function readPlannedRestartRequest(state) {
     return state.request;
   }
@@ -4818,6 +5982,16 @@ error: ${text}`);
     (0, import_node_fs4.mkdirSync)((0, import_node_path6.dirname)(initialRecord.logFiles.err), { recursive: true });
     const stdoutLog = (0, import_node_fs4.createWriteStream)(initialRecord.logFiles.out, { flags: "a" });
     const stderrLog = (0, import_node_fs4.createWriteStream)(initialRecord.logFiles.err, { flags: "a" });
+    let proxyController = null;
+    let proxyTargetSyncTimer = null;
+    let inheritedListener = null;
+    const runnerPaths = resolveRunnerPathsFromRecordFile(filePath);
+    const syncOwnedProxyTargets = (baseName) => {
+      if (!proxyController) {
+        return;
+      }
+      proxyController.setTargets(resolvePmProxyTargetUrls(runnerPaths, baseName));
+    };
     const persist = (mutator) => {
       const current = readLatestPmRecord(filePath, record);
       record = mutator(current);
@@ -4830,26 +6004,30 @@ error: ${text}`);
         activeChildStopTimer = null;
       }
     };
+    const scheduleForcedActiveChildStop = (timeoutMs, reason) => {
+      if (!activeChild?.pid || process.platform === "win32") {
+        return;
+      }
+      clearActiveChildStopTimer();
+      activeChildStopTimer = setTimeout(() => {
+        if (activeChild?.pid && isProcessAlive(activeChild.pid)) {
+          writePmLog(stderrLog, `${reason} after ${timeoutMs}ms; forcing process termination`);
+          terminateProcessTree(activeChild.pid, { force: true });
+        }
+      }, timeoutMs);
+      activeChildStopTimer.unref?.();
+    };
     const stopActiveChild = () => {
       if (!activeChild?.pid || !isProcessAlive(activeChild.pid)) {
         return;
       }
       const current = readLatestPmRecord(filePath, record);
+      const stopTimeout = resolvePmStopTimeout(current);
       if (isPmOnlineWapkRecord(current) && activeChild.stdin && !activeChild.stdin.destroyed && activeChild.stdin.writable) {
         try {
           activeChild.stdin.end(`${PM_WAPK_ONLINE_SHUTDOWN_COMMAND}
 `);
-          clearActiveChildStopTimer();
-          activeChildStopTimer = setTimeout(() => {
-            if (activeChild?.pid && isProcessAlive(activeChild.pid)) {
-              writePmLog(
-                stderrLog,
-                `graceful WAPK online shutdown timed out after ${PM_WAPK_ONLINE_SHUTDOWN_TIMEOUT_MS}ms; forcing process termination`
-              );
-              terminateProcessTree(activeChild.pid);
-            }
-          }, PM_WAPK_ONLINE_SHUTDOWN_TIMEOUT_MS);
-          activeChildStopTimer.unref?.();
+          scheduleForcedActiveChildStop(stopTimeout, "graceful WAPK online shutdown timed out");
           return;
         } catch (error) {
           const message = error instanceof Error ? error.message : String(error);
@@ -4857,6 +6035,7 @@ error: ${text}`);
         }
       }
       terminateProcessTree(activeChild.pid);
+      scheduleForcedActiveChildStop(stopTimeout, "graceful shutdown timed out");
     };
     const requestManagedStop = (reason) => {
       if (stopRequested) {
@@ -4894,6 +6073,17 @@ error: ${text}`);
         let command;
         try {
           command = buildPmCommand(latest);
+          if (latest.proxy && isPmProxyOwner(latest) && !proxyController) {
+            proxyController = await createPmProxyController(latest.proxy);
+            syncOwnedProxyTargets(latest.baseName);
+            if (!proxyTargetSyncTimer) {
+              proxyTargetSyncTimer = setInterval(() => syncOwnedProxyTargets(latest.baseName), 50);
+              proxyTargetSyncTimer.unref?.();
+            }
+          }
+          if (latest.proxy && usesPmInheritedListener(latest) && !inheritedListener) {
+            inheritedListener = await createPmInheritedListener(latest.proxy);
+          }
         } catch (error) {
           const message = error instanceof Error ? error.message : String(error);
           writePmLog(stderrLog, message);
@@ -4903,25 +6093,24 @@ error: ${text}`);
             error: message,
             runnerPid: void 0,
             childPid: void 0,
+            proxyTargetPort: void 0,
+            proxyReadyAt: void 0,
             updatedAt: (/* @__PURE__ */ new Date()).toISOString()
           }));
           return;
         }
         const onlineStdinShutdownEnabled = isPmOnlineWapkRecord(latest);
-        const child = (0, import_node_child_process2.spawn)(command.command, command.args, {
+        const initialTargetPort = usesPmProxyController(latest) ? await allocatePmProxyTargetPort(resolvePmProxyTargetHost(latest.proxy)) : void 0;
+        const monitorRecord = buildPmMonitorRecord(latest, initialTargetPort);
+        let child = (0, import_node_child_process2.spawn)(command.command, command.args, {
           cwd: latest.cwd,
-          env: {
-            ...process.env,
-            ...latest.env,
-            ...command.env,
-            ELIT_PM_NAME: latest.name,
-            ELIT_PM_ID: latest.id
-          },
-          stdio: [onlineStdinShutdownEnabled ? "pipe" : "ignore", "pipe", "pipe"],
+          env: buildPmChildEnv(latest, command, initialTargetPort),
+          stdio: buildPmChildStdio(command, onlineStdinShutdownEnabled),
           windowsHide: true,
           shell: command.shell
         });
-        const childStartedAt = Date.now();
+        let childStartedAt = Date.now();
+        let childIpcState = command.ipc ? createPmChildIpcState(child, inheritedListener) : void 0;
         activeChild = child;
         if (child.stdout) {
           child.stdout.pipe(stdoutLog, { end: false });
@@ -4929,26 +6118,38 @@ error: ${text}`);
         if (child.stderr) {
           child.stderr.pipe(stderrLog, { end: false });
         }
+        let childWaitState = { settled: false, result: void 0 };
+        void waitForManagedChildExit(child).then((result) => {
+          childWaitState.result = result;
+          childWaitState.settled = true;
+        });
         const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+        const waitingForReady = latest.waitReady || Boolean(childIpcState);
         persist((current2) => ({
           ...current2,
-          status: "online",
+          status: waitingForReady ? "starting" : "online",
           commandPreview: command.preview,
           runtime: command.runtime ?? current2.runtime,
           runnerPid: process.pid,
           childPid: child.pid,
+          proxyTargetPort: initialTargetPort,
+          proxyReadyAt: !waitingForReady && usesPmProxyController(latest) ? startedAt : void 0,
           startedAt,
           stoppedAt: void 0,
+          reloadRequestedAt: void 0,
           error: void 0,
           updatedAt: startedAt
         }));
         writePmLog(stdoutLog, `started ${command.preview}${child.pid ? ` (pid ${child.pid})` : ""}`);
+        if (isPmProxyOwner(latest) && !waitingForReady) {
+          syncOwnedProxyTargets(latest.baseName);
+        }
         const requestPlannedRestart = (kind, detail) => {
           if (stopRequested || restartState.request) {
             return;
           }
           restartState.request = { kind, detail };
-          writePmLog(kind === "health" ? stderrLog : stdoutLog, `${kind} restart requested: ${detail}`);
+          writePmLog(kind === "watch" || kind === "cron" ? stdoutLog : stderrLog, `${kind} restart requested: ${detail}`);
           persist((current2) => ({
             ...current2,
             status: "restarting",
@@ -4956,27 +6157,124 @@ error: ${text}`);
           }));
           stopActiveChild();
         };
-        const watchController = await createPmWatchController(
-          latest,
-          (changedPath) => requestPlannedRestart("watch", changedPath),
-          (message) => writePmLog(stderrLog, `watch error: ${message}`)
-        );
-        const healthMonitor = createPmHealthMonitor(
-          latest,
-          (message) => requestPlannedRestart("health", message),
-          (message) => writePmLog(stdoutLog, message)
+        let controllers = await createPmChildControllers(
+          monitorRecord,
+          child,
+          stdoutLog,
+          stderrLog,
+          requestPlannedRestart,
+          (message) => {
+            const readyAt = (/* @__PURE__ */ new Date()).toISOString();
+            if (isPmProxyOwner(latest)) {
+              syncOwnedProxyTargets(latest.baseName);
+            }
+            persist((current2) => ({
+              ...current2,
+              status: "online",
+              proxyTargetPort: initialTargetPort,
+              proxyReadyAt: readyAt,
+              updatedAt: readyAt
+            }));
+            writePmLog(stdoutLog, message);
+          },
+          { ready: !waitingForReady, ipcController: childIpcState }
         );
-        const desiredStatePoller = setInterval(() => {
+        let handledReloadAt = latest.reloadRequestedAt;
+        while (!childWaitState.settled) {
           const latestRecord = readLatestPmRecord(filePath, record);
-          if (!stopRequested && latestRecord.desiredState === "stopped") {
+          if (latestRecord.desiredState === "stopped" && !stopRequested) {
             requestManagedStop("stop requested by PM control state");
           }
-        }, DEFAULT_PM_STOP_POLL_MS);
-        desiredStatePoller.unref?.();
-        const exitResult = await waitForManagedChildExit(child);
-        clearInterval(desiredStatePoller);
-        await watchController.close();
-        healthMonitor.stop();
+          const reloadRequestedAt = latestRecord.reloadRequestedAt;
+          if (!stopRequested && supportsPmProxyReload(latestRecord) && reloadRequestedAt && reloadRequestedAt !== handledReloadAt && latestRecord.proxy) {
+            handledReloadAt = reloadRequestedAt;
+            const replacementTargetPort = usesPmProxyController(latestRecord) ? await allocatePmProxyTargetPort(resolvePmProxyTargetHost(latestRecord.proxy)) : void 0;
+            const replacementMonitorRecord = buildPmMonitorRecord(latestRecord, replacementTargetPort);
+            const replacementChild = (0, import_node_child_process2.spawn)(command.command, command.args, {
+              cwd: latestRecord.cwd,
+              env: buildPmChildEnv(latestRecord, command, replacementTargetPort),
+              stdio: buildPmChildStdio(command, onlineStdinShutdownEnabled),
+              windowsHide: true,
+              shell: command.shell
+            });
+            const replacementIpcState = command.ipc ? createPmChildIpcState(replacementChild, inheritedListener) : void 0;
+            if (replacementChild.stdout) {
+              replacementChild.stdout.pipe(stdoutLog, { end: false });
+            }
+            if (replacementChild.stderr) {
+              replacementChild.stderr.pipe(stderrLog, { end: false });
+            }
+            writePmLog(stdoutLog, `starting ${usesPmInheritedListener(latestRecord) ? "shared-listener" : "proxy handoff"} replacement${replacementChild.pid ? ` (pid ${replacementChild.pid})` : ""}`);
+            const readyResult = await waitForPmChildReady(replacementMonitorRecord, replacementChild, replacementIpcState);
+            if (!readyResult.ready) {
+              writePmLog(stderrLog, readyResult.message ?? "replacement exited before becoming ready");
+              replacementIpcState?.stop();
+              await stopProxyManagedChild(replacementChild, latestRecord, stderrLog);
+              persist((current2) => ({
+                ...current2,
+                status: "online",
+                proxyReadyAt: current2.proxyReadyAt,
+                reloadRequestedAt: void 0,
+                updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+              }));
+              continue;
+            }
+            const previousChild = child;
+            const previousControllers = controllers;
+            const previousIpcState = childIpcState;
+            const handoffAt = (/* @__PURE__ */ new Date()).toISOString();
+            if (usesPmProxyController(latestRecord) && replacementTargetPort) {
+              proxyController?.setTarget(buildPmProxyTargetUrl(latestRecord.proxy, replacementTargetPort));
+            }
+            persist((current2) => ({
+              ...current2,
+              status: "online",
+              childPid: replacementChild.pid,
+              proxyTargetPort: replacementTargetPort,
+              proxyReadyAt: handoffAt,
+              startedAt: handoffAt,
+              reloadRequestedAt: void 0,
+              error: void 0,
+              updatedAt: handoffAt
+            }));
+            if (readyResult.message) {
+              writePmLog(stdoutLog, readyResult.message);
+            }
+            writePmLog(stdoutLog, `${usesPmInheritedListener(latestRecord) ? "shared listener" : "proxy handoff"} activated on ${latestRecord.proxy.host ?? "0.0.0.0"}:${latestRecord.proxy.port}`);
+            child = replacementChild;
+            childIpcState = replacementIpcState;
+            childStartedAt = Date.now();
+            activeChild = replacementChild;
+            childWaitState = { settled: false, result: void 0 };
+            void waitForManagedChildExit(replacementChild).then((result) => {
+              childWaitState.result = result;
+              childWaitState.settled = true;
+            });
+            controllers = await createPmChildControllers(
+              replacementMonitorRecord,
+              replacementChild,
+              stdoutLog,
+              stderrLog,
+              requestPlannedRestart,
+              () => {
+              },
+              { ready: true, ipcController: replacementIpcState }
+            );
+            await delay(250);
+            await previousControllers.stop();
+            previousIpcState?.stop();
+            await stopProxyManagedChild(previousChild, latestRecord, stderrLog);
+            clearActiveChildStopTimer();
+            if (isPmProxyOwner(latestRecord)) {
+              syncOwnedProxyTargets(latestRecord.baseName);
+            }
+            continue;
+          }
+          await delay(25);
+        }
+        const exitResult = childWaitState.result;
+        await controllers.stop();
+        childIpcState?.stop();
         clearActiveChildStopTimer();
         activeChild = null;
         const exitCode = waitForExit(exitResult.code, exitResult.signal);
@@ -4992,56 +6290,77 @@ error: ${text}`);
         if (stopRequested || current.desiredState === "stopped") {
           break;
         }
-        const shouldRestartForExit = plannedRestart ? true : current.restartPolicy === "always" ? true : current.restartPolicy === "on-failure" ? exitCode !== 0 || Boolean(exitResult.error) : false;
+        const shouldRestartForExit = plannedRestart?.kind === "memory-stop" ? false : plannedRestart ? true : current.restartPolicy === "always" ? true : current.restartPolicy === "on-failure" ? exitCode !== 0 || Boolean(exitResult.error) : false;
         if (!shouldRestartForExit) {
           persist((latestRecord) => ({
             ...latestRecord,
-            status: exitCode === 0 && !exitResult.error ? "exited" : "errored",
+            status: plannedRestart?.kind === "memory-stop" ? "errored" : exitCode === 0 && !exitResult.error ? "exited" : "errored",
             childPid: void 0,
+            proxyTargetPort: void 0,
+            proxyReadyAt: void 0,
             runnerPid: void 0,
             lastExitCode: exitCode,
-            error: exitCode === 0 && !exitResult.error ? void 0 : exitResult.error ?? `Process exited with code ${exitCode}.`,
+            reloadRequestedAt: void 0,
+            error: plannedRestart?.kind === "memory-stop" ? plannedRestart.detail : exitCode === 0 && !exitResult.error ? void 0 : exitResult.error ?? `Process exited with code ${exitCode}.`,
             stoppedAt: (/* @__PURE__ */ new Date()).toISOString(),
             updatedAt: (/* @__PURE__ */ new Date()).toISOString()
           }));
+          if (isPmProxyOwner(current)) {
+            syncOwnedProxyTargets(current.baseName);
+          }
           return;
         }
         const shouldCountRestart = plannedRestart?.kind !== "watch";
-        const baseRestartCount = wasStable ? 0 : current.restartCount ?? 0;
+        const baseRestartCount = resolvePmRestartCountBase(current, wasStable, plannedRestart?.kind);
         const nextRestartCount = shouldCountRestart ? baseRestartCount + 1 : current.restartCount ?? 0;
         if (nextRestartCount > current.maxRestarts) {
           persist((latestRecord) => ({
             ...latestRecord,
             status: "errored",
             childPid: void 0,
+            proxyTargetPort: void 0,
+            proxyReadyAt: void 0,
             runnerPid: void 0,
             restartCount: nextRestartCount,
+            lastRestartAt: (/* @__PURE__ */ new Date()).toISOString(),
             lastExitCode: exitCode,
+            reloadRequestedAt: void 0,
             error: plannedRestart ? `Reached max restart attempts (${current.maxRestarts}) after ${plannedRestart.kind} restart requests.` : `Reached max restart attempts (${current.maxRestarts}).`,
             stoppedAt: (/* @__PURE__ */ new Date()).toISOString(),
             updatedAt: (/* @__PURE__ */ new Date()).toISOString()
           }));
           writePmLog(stderrLog, `max restart attempts reached (${current.maxRestarts})`);
+          if (isPmProxyOwner(current)) {
+            syncOwnedProxyTargets(current.baseName);
+          }
           return;
         }
         persist((latestRecord) => ({
           ...latestRecord,
           status: "restarting",
           childPid: void 0,
+          proxyTargetPort: void 0,
+          proxyReadyAt: void 0,
           lastExitCode: exitCode,
           restartCount: nextRestartCount,
+          lastRestartAt: (/* @__PURE__ */ new Date()).toISOString(),
+          reloadRequestedAt: void 0,
           error: void 0,
           updatedAt: (/* @__PURE__ */ new Date()).toISOString()
         }));
+        if (isPmProxyOwner(current)) {
+          syncOwnedProxyTargets(current.baseName);
+        }
+        const resolvedRestartDelay = resolvePmRestartDelay(current, nextRestartCount, shouldCountRestart && !wasStable && plannedRestart?.kind !== "watch");
         if (plannedRestart) {
           writePmLog(
-            plannedRestart.kind === "health" ? stderrLog : stdoutLog,
-            `restarting in ${current.restartDelay}ms after ${plannedRestart.kind}: ${plannedRestart.detail}`
+            plannedRestart.kind === "health" || plannedRestart.kind === "memory" || plannedRestart.kind === "memory-stop" || plannedRestart.kind === "startup" ? stderrLog : stdoutLog,
+            `restarting in ${resolvedRestartDelay}ms after ${plannedRestart.kind}: ${plannedRestart.detail}`
           );
         } else {
-          writePmLog(stdoutLog, `restarting in ${current.restartDelay}ms`);
+          writePmLog(stdoutLog, `restarting in ${resolvedRestartDelay}ms`);
         }
-        await delay(current.restartDelay);
+        await delay(resolvedRestartDelay);
       }
     } finally {
       stopRequested = true;
@@ -5054,11 +6373,26 @@ error: ${text}`);
         status: finalRecord.status === "errored" ? "errored" : finalRecord.status === "exited" ? "exited" : "stopped",
         runnerPid: void 0,
         childPid: void 0,
+        proxyTargetPort: void 0,
+        proxyReadyAt: void 0,
+        reloadRequestedAt: void 0,
         stoppedAt: (/* @__PURE__ */ new Date()).toISOString(),
         updatedAt: (/* @__PURE__ */ new Date()).toISOString()
       });
       process.off("SIGINT", handleStopSignal);
       process.off("SIGTERM", handleStopSignal);
+      if (proxyTargetSyncTimer) {
+        clearInterval(proxyTargetSyncTimer);
+        proxyTargetSyncTimer = null;
+      }
+      if (proxyController) {
+        await proxyController.close().catch(() => void 0);
+        proxyController = null;
+      }
+      if (inheritedListener) {
+        await new Promise((resolvePromise) => inheritedListener?.close(() => resolvePromise()));
+        inheritedListener = null;
+      }
       await new Promise((resolvePromise) => stdoutLog.end(resolvePromise));
       await new Promise((resolvePromise) => stderrLog.end(resolvePromise));
     }
@@ -5112,23 +6446,26 @@ error: ${text}`);
         stoppedAt: (/* @__PURE__ */ new Date()).toISOString()
       };
       writePmRecord(match.filePath, updated);
-      const runnerStopped = await waitForProcessTermination(match.record.runnerPid, DEFAULT_PM_STOP_GRACE_PERIOD_MS);
+      const stopTimeout = resolvePmStopTimeout(match.record);
+      const runnerStopped = await waitForProcessTermination(match.record.runnerPid, stopTimeout);
       const childStopped = await waitForProcessTermination(
         match.record.childPid,
-        runnerStopped ? DEFAULT_PM_STOP_POLL_MS : DEFAULT_PM_STOP_GRACE_PERIOD_MS
+        runnerStopped ? DEFAULT_PM_STOP_POLL_MS : stopTimeout
       );
       if (!runnerStopped && match.record.runnerPid && isProcessAlive(match.record.runnerPid)) {
-        terminateProcessTree(match.record.runnerPid);
+        terminateProcessTree(match.record.runnerPid, { force: true });
         await waitForProcessTermination(match.record.runnerPid, DEFAULT_PM_STOP_POLL_MS);
       }
       if (!childStopped && match.record.childPid && isProcessAlive(match.record.childPid)) {
-        terminateProcessTree(match.record.childPid);
+        terminateProcessTree(match.record.childPid, { force: true });
         await waitForProcessTermination(match.record.childPid, DEFAULT_PM_STOP_POLL_MS);
       }
       writePmRecord(match.filePath, {
         ...updated,
         runnerPid: void 0,
         childPid: void 0,
+        proxyTargetPort: void 0,
+        reloadRequestedAt: void 0,
         status: "stopped",
         updatedAt: (/* @__PURE__ */ new Date()).toISOString()
       });
@@ -5197,13 +6534,13 @@ error: ${text}`);
 
   // src/shares/workspace-package/roots.ts
   function findPackageDirectory(startDir, resolveMatch) {
-    let currentDir = resolve4(startDir);
+    let currentDir = resolve5(startDir);
     while (true) {
       const match = resolveMatch(currentDir);
       if (match) {
         return match;
       }
-      const parentDir = dirname2(currentDir);
+      const parentDir = dirname3(currentDir);
       if (parentDir === currentDir) {
         return void 0;
       }
@@ -5231,17 +6568,17 @@ error: ${text}`);
   function getWorkspacePackageImportCandidates(packageRoot, specifier, options = {}) {
     const subpath = specifier === "elit" ? "index" : specifier.slice("elit/".length);
     const builtCandidates = options.preferredBuiltFormat === "cjs" ? [
-      resolve4(packageRoot, "dist", `${subpath}.cjs`),
-      resolve4(packageRoot, "dist", `${subpath}.js`),
-      resolve4(packageRoot, "dist", `${subpath}.mjs`)
+      resolve5(packageRoot, "dist", `${subpath}.cjs`),
+      resolve5(packageRoot, "dist", `${subpath}.js`),
+      resolve5(packageRoot, "dist", `${subpath}.mjs`)
     ] : [
-      resolve4(packageRoot, "dist", `${subpath}.mjs`),
-      resolve4(packageRoot, "dist", `${subpath}.js`),
-      resolve4(packageRoot, "dist", `${subpath}.cjs`)
+      resolve5(packageRoot, "dist", `${subpath}.mjs`),
+      resolve5(packageRoot, "dist", `${subpath}.js`),
+      resolve5(packageRoot, "dist", `${subpath}.cjs`)
     ];
     const sourceCandidates = [
-      resolve4(packageRoot, "src", `${subpath}.ts`),
-      resolve4(packageRoot, "src", `${subpath}.tsx`)
+      resolve5(packageRoot, "src", `${subpath}.ts`),
+      resolve5(packageRoot, "src", `${subpath}.tsx`)
     ];
     return options.preferBuilt ? [...builtCandidates, ...sourceCandidates] : [...sourceCandidates, ...builtCandidates];
   }
@@ -5276,7 +6613,7 @@ error: ${text}`);
   // src/shares/config/loader.ts
   function resolveConfigPath(cwd = process.cwd()) {
     for (const configFile of ELIT_CONFIG_FILES) {
-      const configPath = resolve4(cwd, configFile);
+      const configPath = resolve5(cwd, configFile);
       if (existsSync4(configPath)) {
         return configPath;
       }
@@ -5305,7 +6642,7 @@ error: ${text}`);
     if (ext === "ts" || ext === "mts") {
       try {
         const { build } = await Promise.resolve().then(() => __toESM(require_main()));
-        const configDir = dirname2(configPath);
+        const configDir = dirname3(configPath);
         const tempFile = join5(configDir, `.elit-config-${Date.now()}.mjs`);
         const externalAllPlugin = {
           name: "external-all",
@@ -5379,6 +6716,43 @@ error: ${text}`);
   }
 
   // src/cli/pm/commands.ts
+  var PM_SIGNAL_NAMES = /* @__PURE__ */ new Set([
+    "SIGABRT",
+    "SIGALRM",
+    "SIGBREAK",
+    "SIGBUS",
+    "SIGCHLD",
+    "SIGCONT",
+    "SIGFPE",
+    "SIGHUP",
+    "SIGILL",
+    "SIGINT",
+    "SIGIO",
+    "SIGIOT",
+    "SIGKILL",
+    "SIGPIPE",
+    "SIGPOLL",
+    "SIGPROF",
+    "SIGPWR",
+    "SIGQUIT",
+    "SIGSEGV",
+    "SIGSTKFLT",
+    "SIGSTOP",
+    "SIGSYS",
+    "SIGTERM",
+    "SIGTRAP",
+    "SIGTSTP",
+    "SIGTTIN",
+    "SIGTTOU",
+    "SIGUNUSED",
+    "SIGURG",
+    "SIGUSR1",
+    "SIGUSR2",
+    "SIGVTALRM",
+    "SIGWINCH",
+    "SIGXCPU",
+    "SIGXFSZ"
+  ]);
   async function runPmStart(args) {
     const parsed = parsePmStartArgs(args);
     const workspaceRoot = process.cwd();
@@ -5411,9 +6785,130 @@ error: ${text}`);
     if (value === "all") {
       return listPmRecordMatches(paths).map(syncPmRecordLiveness);
     }
+    const groupMatches = findPmGroupMatches(paths, value);
+    if (groupMatches.length > 0) {
+      return groupMatches.map(syncPmRecordLiveness);
+    }
     const match = findPmRecordMatch(paths, value);
     return match ? [syncPmRecordLiveness(match)] : [];
   }
+  function sortPmMatchesByInstance(matches) {
+    return [...matches].sort((left, right) => left.record.instanceIndex - right.record.instanceIndex);
+  }
+  function resolveInspectableMatch(paths, value) {
+    const exactMatch = findPmRecordMatch(paths, value);
+    const groupMatches = findPmGroupMatches(paths, value).map(syncPmRecordLiveness);
+    if (groupMatches.length > 1 && exactMatch?.record.baseName === value && exactMatch.record.name === value) {
+      throw new Error(`Multiple managed processes found for: ${value}. Use a specific instance name such as ${groupMatches[0]?.record.name} or ${groupMatches[1]?.record.name}.`);
+    }
+    if (exactMatch) {
+      return syncPmRecordLiveness(exactMatch);
+    }
+    return groupMatches[0];
+  }
+  function rebuildPmRecordDefinition(record, targetInstances = record.instances) {
+    const definition = resolvePmAppDefinition(
+      toPmAppConfig(record),
+      { name: record.baseName, env: {}, watchPaths: [], watchIgnore: [], instances: targetInstances },
+      process.cwd(),
+      record.source
+    );
+    return {
+      ...definition,
+      name: record.name,
+      baseName: record.baseName,
+      instanceIndex: record.instanceIndex,
+      instances: targetInstances
+    };
+  }
+  function rebuildPmSavedDefinition(app) {
+    const definition = resolvePmAppDefinition(
+      toSavedPmAppConfig(app),
+      { name: app.baseName, env: {}, watchPaths: [], watchIgnore: [], instances: app.instances },
+      process.cwd(),
+      "cli"
+    );
+    return {
+      ...definition,
+      name: app.name,
+      baseName: app.baseName,
+      instanceIndex: app.instanceIndex,
+      instances: app.instances
+    };
+  }
+  function deletePmMatches(matches) {
+    for (const match of matches) {
+      if ((0, import_node_fs5.existsSync)(match.record.logFiles.out)) {
+        (0, import_node_fs5.rmSync)(match.record.logFiles.out, { force: true });
+      }
+      if ((0, import_node_fs5.existsSync)(match.record.logFiles.err)) {
+        (0, import_node_fs5.rmSync)(match.record.logFiles.err, { force: true });
+      }
+      (0, import_node_fs5.rmSync)(match.filePath, { force: true });
+    }
+  }
+  function updatePmInstanceCount(matches, instances) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    for (const match of matches) {
+      writePmRecord(match.filePath, {
+        ...match.record,
+        instances,
+        updatedAt: now
+      });
+    }
+  }
+  function normalizePmSignalName(value) {
+    const trimmed = value.trim().toUpperCase();
+    const signalName = trimmed.startsWith("SIG") ? trimmed : `SIG${trimmed}`;
+    if (!PM_SIGNAL_NAMES.has(signalName)) {
+      throw new Error(`Unsupported pm signal: ${value}`);
+    }
+    return signalName;
+  }
+  function resolveSignalablePid(record) {
+    if (record.childPid && record.childPid > 0) {
+      return record.childPid;
+    }
+    if (record.runnerPid && record.runnerPid > 0) {
+      return record.runnerPid;
+    }
+    return void 0;
+  }
+  function groupPmMatchesByBaseName(matches) {
+    const grouped = /* @__PURE__ */ new Map();
+    for (const match of matches) {
+      const group = grouped.get(match.record.baseName);
+      if (group) {
+        group.push(match);
+        continue;
+      }
+      grouped.set(match.record.baseName, [match]);
+    }
+    return [...grouped.entries()].sort((left, right) => left[0].localeCompare(right[0])).map(([, group]) => sortPmMatchesByInstance(group));
+  }
+  async function waitForPmRecordOnline(filePath, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+      if (!(0, import_node_fs5.existsSync)(filePath)) {
+        break;
+      }
+      const record = readPmRecord(filePath);
+      if (record.status === "online") {
+        return record;
+      }
+      if (record.status === "errored" || record.status === "exited" || record.status === "stopped") {
+        throw new Error(record.error ?? `Process ${record.name} failed while reloading.`);
+      }
+      await new Promise((resolvePromise) => setTimeout(resolvePromise, 50));
+    }
+    throw new Error(`Timed out waiting for the reloaded process to become online after ${timeoutMs}ms.`);
+  }
+  function resolvePmReloadReadyTimeout(record) {
+    return record.waitReady || record.proxy?.strategy === "inherit" ? Math.max(record.listenTimeout + 1e3, 2e3) : Math.max(record.restartDelay + 1e3, 2e3);
+  }
+  function supportsPmProxyReload2(record) {
+    return Boolean(record.proxy) && record.instances === 1 && Boolean(record.runnerPid);
+  }
   function padCell(value, width) {
     return value.length >= width ? value : `${value}${" ".repeat(width - value.length)}`;
   }
@@ -5424,8 +6919,255 @@ error: ${text}`);
     const lines = (0, import_node_fs5.readFileSync)(filePath, "utf8").split(/\r?\n/).filter((line) => line.length > 0);
     return lines.slice(-lineCount).join(import_node_os2.EOL);
   }
-  function printPmList(paths) {
-    const matches = listPmRecordMatches(paths).map(syncPmRecordLiveness);
+  function listPmMatches(paths) {
+    return listPmRecordMatches(paths).map(syncPmRecordLiveness);
+  }
+  function isPmRecordActive(record) {
+    return record.desiredState === "running" && (record.status === "starting" || record.status === "online" || record.status === "restarting");
+  }
+  function resolvePmUptimeMs(record) {
+    if (!isPmRecordActive(record) || !record.startedAt) {
+      return void 0;
+    }
+    const startedTime = Date.parse(record.startedAt);
+    if (Number.isNaN(startedTime)) {
+      return void 0;
+    }
+    return Math.max(0, Date.now() - startedTime);
+  }
+  function resolvePmLiveMetrics(record) {
+    const uptimeMs = resolvePmUptimeMs(record);
+    if (!isPmRecordActive(record) || !record.childPid) {
+      return { uptimeMs };
+    }
+    const sampledMetrics = samplePmProcessMetrics(record.childPid);
+    return {
+      ...sampledMetrics,
+      uptimeMs,
+      updatedAt: sampledMetrics.cpuPercent !== void 0 || sampledMetrics.memoryRssBytes !== void 0 ? (/* @__PURE__ */ new Date()).toISOString() : void 0
+    };
+  }
+  function toPmDisplayRecord(record) {
+    return {
+      record,
+      liveMetrics: resolvePmLiveMetrics(record)
+    };
+  }
+  function serializePmRecord(record) {
+    return {
+      ...record,
+      liveMetrics: resolvePmLiveMetrics(record)
+    };
+  }
+  function parsePmFormatOption(args, index, option) {
+    let value;
+    if (option.startsWith("--format=")) {
+      value = option.slice("--format=".length);
+    } else {
+      value = readRequiredValue(args, index + 1, "--format");
+      index += 1;
+    }
+    if (value !== "table" && value !== "json") {
+      throw new Error(`Unsupported pm output format: ${value}`);
+    }
+    return {
+      format: value,
+      nextIndex: index
+    };
+  }
+  function parsePmListArgs(args) {
+    let format = "table";
+    for (let index = 0; index < args.length; index++) {
+      const arg = args[index];
+      switch (arg) {
+        case "--json":
+          format = "json";
+          break;
+        case "--format":
+        default:
+          if (arg === "--format" || arg.startsWith("--format=")) {
+            const parsed = parsePmFormatOption(args, index, arg);
+            format = parsed.format;
+            index = parsed.nextIndex;
+            break;
+          }
+          throw new Error(`Unknown pm list option: ${arg}`);
+      }
+    }
+    return { format };
+  }
+  function parsePmShowArgs(args) {
+    let format = "text";
+    let name;
+    for (let index = 0; index < args.length; index++) {
+      const arg = args[index];
+      switch (arg) {
+        case "--json":
+          format = "json";
+          break;
+        case "--format":
+        default:
+          if (arg === "--format" || arg.startsWith("--format=")) {
+            const parsed = parsePmFormatOption(args, index, arg);
+            format = parsed.format === "json" ? "json" : "text";
+            index = parsed.nextIndex;
+            break;
+          }
+          if (arg.startsWith("-")) {
+            throw new Error(`Unknown pm show option: ${arg}`);
+          }
+          if (name) {
+            throw new Error("pm show accepts exactly one process name.");
+          }
+          name = arg;
+          break;
+      }
+    }
+    if (!name) {
+      throw new Error("Usage: elit pm show <name> [--json]");
+    }
+    return { name, format };
+  }
+  function formatPmDuration(durationMs) {
+    if (durationMs < 1e3) {
+      return `${durationMs}ms`;
+    }
+    const totalSeconds = Math.floor(durationMs / 1e3);
+    const days = Math.floor(totalSeconds / 86400);
+    const hours = Math.floor(totalSeconds % 86400 / 3600);
+    const minutes = Math.floor(totalSeconds % 3600 / 60);
+    const seconds = totalSeconds % 60;
+    const parts = [];
+    if (days > 0) {
+      parts.push(`${days}d`);
+    }
+    if (hours > 0) {
+      parts.push(`${hours}h`);
+    }
+    if (minutes > 0) {
+      parts.push(`${minutes}m`);
+    }
+    if (seconds > 0 || parts.length === 0) {
+      parts.push(`${seconds}s`);
+    }
+    return parts.slice(0, 2).join(" ");
+  }
+  function formatPmCpuPercent(cpuPercent) {
+    if (cpuPercent === void 0 || !Number.isFinite(cpuPercent)) {
+      return "-";
+    }
+    return `${cpuPercent >= 100 ? cpuPercent.toFixed(0) : cpuPercent.toFixed(1)}%`;
+  }
+  function formatPmMemory(memoryRssBytes) {
+    if (memoryRssBytes === void 0 || !Number.isFinite(memoryRssBytes) || memoryRssBytes < 0) {
+      return "-";
+    }
+    const units = ["B", "KB", "MB", "GB", "TB"];
+    let value = memoryRssBytes;
+    let unitIndex = 0;
+    while (value >= 1024 && unitIndex < units.length - 1) {
+      value /= 1024;
+      unitIndex += 1;
+    }
+    const formatted = value >= 10 || unitIndex === 0 ? value.toFixed(0) : value.toFixed(1);
+    return `${formatted}${units[unitIndex]}`;
+  }
+  function formatPmUptime(uptimeMs) {
+    if (uptimeMs === void 0 || !Number.isFinite(uptimeMs)) {
+      return "-";
+    }
+    return formatPmDuration(Math.max(0, uptimeMs));
+  }
+  function formatPmTarget(record) {
+    if (record.script) {
+      return record.script;
+    }
+    if (record.file) {
+      return record.file;
+    }
+    if (record.wapk) {
+      return record.wapk;
+    }
+    return "-";
+  }
+  function pushPmDetail(lines, label, value) {
+    lines.push(`${padCell(`${label}:`, 18)} ${value}`);
+  }
+  function pushPmDetailList(lines, label, values) {
+    if (values.length === 0) {
+      pushPmDetail(lines, label, "-");
+      return;
+    }
+    pushPmDetail(lines, label, values[0] ?? "-");
+    for (const value of values.slice(1)) {
+      lines.push(`${" ".repeat(20)} ${value}`);
+    }
+  }
+  function formatPmRecordDetails(record, liveMetrics) {
+    const lines = [`Process: ${record.name}`];
+    pushPmDetail(lines, "id", record.id);
+    pushPmDetail(lines, "status", record.status);
+    pushPmDetail(lines, "desired state", record.desiredState);
+    pushPmDetail(lines, "instance", `${record.instanceIndex}/${record.instances}`);
+    pushPmDetail(lines, "cpu", formatPmCpuPercent(liveMetrics.cpuPercent));
+    pushPmDetail(lines, "memory", formatPmMemory(liveMetrics.memoryRssBytes));
+    pushPmDetail(lines, "uptime", formatPmUptime(liveMetrics.uptimeMs));
+    pushPmDetail(lines, "type", record.type);
+    pushPmDetail(lines, "source", record.source);
+    pushPmDetail(lines, "runtime", record.runtime ?? "-");
+    pushPmDetail(lines, "cwd", record.cwd);
+    pushPmDetail(lines, "target", formatPmTarget(record));
+    pushPmDetail(lines, "command", record.commandPreview || "-");
+    pushPmDetail(lines, "runner pid", record.runnerPid ? String(record.runnerPid) : "-");
+    pushPmDetail(lines, "child pid", record.childPid ? String(record.childPid) : "-");
+    pushPmDetail(lines, "restart count", `${record.restartCount}/${record.maxRestarts}`);
+    pushPmDetail(lines, "restart policy", record.restartPolicy);
+    pushPmDetail(lines, "proxy", record.proxy ? `http://${record.proxy.host ?? "0.0.0.0"}:${record.proxy.port}` : "-");
+    pushPmDetail(lines, "proxy strategy", record.proxy?.strategy ?? "-");
+    pushPmDetail(lines, "proxy target", record.proxy && record.proxyTargetPort ? `${record.proxy.targetHost ?? "127.0.0.1"}:${record.proxyTargetPort}` : "-");
+    pushPmDetail(lines, "max memory", record.maxMemoryBytes ? formatPmMemory(record.maxMemoryBytes) : "-");
+    pushPmDetail(lines, "memory action", record.memoryAction ?? "-");
+    pushPmDetail(lines, "cron restart", record.cronRestart ?? "-");
+    pushPmDetail(lines, "exp backoff", record.expBackoffRestartDelay ? formatPmDuration(record.expBackoffRestartDelay) : "-");
+    pushPmDetail(lines, "exp backoff max", record.expBackoffRestartMaxDelay ? formatPmDuration(record.expBackoffRestartMaxDelay) : "-");
+    pushPmDetail(lines, "restart window", record.restartWindow ? formatPmDuration(record.restartWindow) : "-");
+    pushPmDetail(lines, "wait ready", record.waitReady ? "enabled" : "disabled");
+    pushPmDetail(lines, "listen timeout", record.waitReady ? formatPmDuration(record.listenTimeout) : "-");
+    pushPmDetail(lines, "restart delay", formatPmDuration(record.restartDelay));
+    pushPmDetail(lines, "kill timeout", formatPmDuration(record.killTimeout));
+    pushPmDetail(lines, "min uptime", formatPmDuration(record.minUptime));
+    pushPmDetail(lines, "autorestart", record.autorestart ? "enabled" : "disabled");
+    pushPmDetail(lines, "watch", record.watch ? "enabled" : "disabled");
+    pushPmDetail(lines, "watch debounce", record.watch ? formatPmDuration(record.watchDebounce) : "-");
+    pushPmDetailList(lines, "watch paths", record.watchPaths);
+    pushPmDetailList(lines, "watch ignore", record.watchIgnore);
+    if (record.healthCheck) {
+      pushPmDetail(lines, "health check", record.healthCheck.url);
+      pushPmDetail(lines, "health grace", formatPmDuration(record.healthCheck.gracePeriod));
+      pushPmDetail(lines, "health interval", formatPmDuration(record.healthCheck.interval));
+      pushPmDetail(lines, "health timeout", formatPmDuration(record.healthCheck.timeout));
+      pushPmDetail(lines, "health failures", String(record.healthCheck.maxFailures));
+    } else {
+      pushPmDetail(lines, "health check", "-");
+    }
+    pushPmDetailList(lines, "env", Object.entries(record.env).map(([key, value]) => `${key}=${value}`));
+    pushPmDetail(lines, "stdout log", record.logFiles.out);
+    pushPmDetail(lines, "stderr log", record.logFiles.err);
+    pushPmDetail(lines, "created at", record.createdAt);
+    pushPmDetail(lines, "updated at", record.updatedAt);
+    pushPmDetail(lines, "metrics at", liveMetrics.updatedAt ?? "-");
+    pushPmDetail(lines, "started at", record.startedAt ?? "-");
+    pushPmDetail(lines, "stopped at", record.stoppedAt ?? "-");
+    pushPmDetail(lines, "last exit", record.lastExitCode === void 0 ? "-" : String(record.lastExitCode));
+    pushPmDetail(lines, "error", record.error ?? "-");
+    return lines.join(import_node_os2.EOL);
+  }
+  function printPmList(paths, format = "table") {
+    const matches = listPmMatches(paths).map((match) => toPmDisplayRecord(match.record));
+    if (format === "json") {
+      console.log(JSON.stringify(matches.map((match) => ({ ...match.record, liveMetrics: match.liveMetrics })), null, 2));
+      return;
+    }
     if (matches.length === 0) {
       console.log("No managed processes found.");
       return;
@@ -5434,22 +7176,47 @@ error: ${text}`);
       padCell("name", 20),
       padCell("status", 12),
       padCell("pid", 8),
+      padCell("cpu", 8),
+      padCell("memory", 10),
+      padCell("uptime", 10),
       padCell("restarts", 10),
       padCell("type", 8),
       "runtime"
     ];
     console.log(headers.join("  "));
-    for (const { record } of matches) {
+    for (const { record, liveMetrics } of matches) {
       console.log([
         padCell(record.name, 20),
         padCell(record.status, 12),
         padCell(record.childPid ? String(record.childPid) : "-", 8),
+        padCell(formatPmCpuPercent(liveMetrics.cpuPercent), 8),
+        padCell(formatPmMemory(liveMetrics.memoryRssBytes), 10),
+        padCell(formatPmUptime(liveMetrics.uptimeMs), 10),
         padCell(String(record.restartCount ?? 0), 10),
         padCell(record.type, 8),
         record.runtime ?? "-"
       ].join("  "));
     }
   }
+  async function runPmList(args) {
+    const options = parsePmListArgs(args);
+    const { paths } = await loadPmContext();
+    printPmList(paths, options.format);
+  }
+  async function runPmShow(args) {
+    const options = parsePmShowArgs(args);
+    const { paths } = await loadPmContext();
+    const match = resolveInspectableMatch(paths, options.name);
+    if (!match) {
+      throw new Error(`No managed process found for: ${options.name}`);
+    }
+    const synced = syncPmRecordLiveness(match);
+    if (options.format === "json") {
+      console.log(JSON.stringify(serializePmRecord(synced.record), null, 2));
+      return;
+    }
+    console.log(formatPmRecordDetails(synced.record, resolvePmLiveMetrics(synced.record)));
+  }
   async function runPmStop(args) {
     const target = args[0];
     if (!target) {
@@ -5476,17 +7243,62 @@ error: ${text}`);
     await stopPmMatches(matches);
     const restarted = [];
     for (const match of matches) {
-      const definition = resolvePmAppDefinition(
-        toPmAppConfig(match.record),
-        { name: match.record.name, env: {}, watchPaths: [], watchIgnore: [] },
-        process.cwd(),
-        match.record.source
-      );
+      const definition = rebuildPmRecordDefinition(match.record);
       await startManagedProcess(definition, paths);
       restarted.push(match.record.name);
     }
     console.log(`[pm] restarted ${restarted.join(", ")}`);
   }
+  async function runPmReload(args) {
+    const target = args[0];
+    if (!target) {
+      throw new Error("Usage: elit pm reload <name|all>");
+    }
+    const { paths } = await loadPmContext();
+    const matches = resolveNamedMatches(paths, target);
+    if (matches.length === 0) {
+      throw new Error(`No managed process found for: ${target}`);
+    }
+    const reloaded = [];
+    const errors = [];
+    for (const group of groupPmMatchesByBaseName(matches)) {
+      for (const match of group) {
+        try {
+          if (supportsPmProxyReload2(match.record)) {
+            const reloadRequestedAt = (/* @__PURE__ */ new Date()).toISOString();
+            writePmRecord(match.filePath, {
+              ...match.record,
+              status: "restarting",
+              reloadRequestedAt,
+              updatedAt: reloadRequestedAt,
+              error: void 0
+            });
+            await waitForPmRecordOnline(
+              getPmRecordPath(paths, match.record.id),
+              resolvePmReloadReadyTimeout(match.record)
+            );
+            reloaded.push(match.record.name);
+            continue;
+          }
+          await stopPmMatches([match]);
+          const definition = rebuildPmRecordDefinition(match.record);
+          const startedRecord = await startManagedProcess(definition, paths);
+          await waitForPmRecordOnline(
+            getPmRecordPath(paths, startedRecord.id),
+            resolvePmReloadReadyTimeout(startedRecord)
+          );
+          reloaded.push(match.record.name);
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          errors.push(`[pm] ${match.record.name}: ${message}`);
+        }
+      }
+    }
+    if (errors.length > 0) {
+      throw new Error([`[pm] reloaded ${reloaded.length} process${reloaded.length === 1 ? "" : "es"}`, ...errors].join(import_node_os2.EOL));
+    }
+    console.log(`[pm] reloaded ${reloaded.join(", ")}`);
+  }
   async function runPmSave() {
     const { paths } = await loadPmContext();
     ensurePmDirectories(paths);
@@ -5508,12 +7320,7 @@ error: ${text}`);
     let restored = 0;
     for (const app of dump.apps) {
       try {
-        const definition = resolvePmAppDefinition(
-          toSavedPmAppConfig(app),
-          { name: app.name, env: {}, watchPaths: [], watchIgnore: [] },
-          process.cwd(),
-          "cli"
-        );
+        const definition = rebuildPmSavedDefinition(app);
         await startManagedProcess(definition, paths);
         restored += 1;
       } catch (error) {
@@ -5537,16 +7344,127 @@ error: ${text}`);
       throw new Error(`No managed process found for: ${target}`);
     }
     await stopPmMatches(matches);
+    deletePmMatches(matches);
+    console.log(`[pm] deleted ${matches.length} process${matches.length === 1 ? "" : "es"}`);
+  }
+  async function runPmScale(args) {
+    const target = args[0];
+    const countArg = args[1];
+    if (!target || countArg === void 0 || args.length > 2) {
+      throw new Error("Usage: elit pm scale <name> <count>");
+    }
+    const desiredCount = normalizeIntegerOption(countArg, "pm scale <count>", 0);
+    const { config, paths } = await loadPmContext();
+    const exactMatch = findPmRecordMatch(paths, target);
+    const currentMatches = sortPmMatchesByInstance(resolveNamedMatches(paths, exactMatch?.record.baseName ?? target));
+    if (currentMatches.length === 0) {
+      if (desiredCount === 0) {
+        console.log(`[pm] ${target} already scaled to 0 instances`);
+        return;
+      }
+      const definitions = resolvePmStartDefinitions(
+        { name: target, env: {}, watchPaths: [], watchIgnore: [], instances: desiredCount },
+        config,
+        process.cwd()
+      );
+      for (const definition of definitions) {
+        await startManagedProcess(definition, paths);
+      }
+      console.log(`[pm] scaled ${target} to ${desiredCount} instance${desiredCount === 1 ? "" : "s"}`);
+      return;
+    }
+    const baseName = currentMatches[0]?.record.baseName ?? target;
+    if (desiredCount === currentMatches.length) {
+      console.log(`[pm] ${baseName} already scaled to ${desiredCount} instance${desiredCount === 1 ? "" : "s"}`);
+      return;
+    }
+    if (desiredCount === 0) {
+      await stopPmMatches(currentMatches);
+      deletePmMatches(currentMatches);
+      console.log(`[pm] scaled ${baseName} to 0 instances`);
+      return;
+    }
+    if (desiredCount < currentMatches.length) {
+      const toRemove = [...currentMatches].sort((left, right) => right.record.instanceIndex - left.record.instanceIndex).slice(0, currentMatches.length - desiredCount);
+      const remaining = currentMatches.filter((match) => !toRemove.some((removal) => removal.record.id === match.record.id));
+      await stopPmMatches(toRemove);
+      deletePmMatches(toRemove);
+      updatePmInstanceCount(remaining, desiredCount);
+      console.log(`[pm] scaled ${baseName} to ${desiredCount} instance${desiredCount === 1 ? "" : "s"}`);
+      return;
+    }
+    updatePmInstanceCount(currentMatches, desiredCount);
+    const baseRecord = currentMatches[0]?.record;
+    if (!baseRecord) {
+      throw new Error(`No managed process found for: ${target}`);
+    }
+    const baseDefinition = rebuildPmRecordDefinition(baseRecord, desiredCount);
+    const expandedDefinitions = expandPmInstanceDefinitions(baseDefinition, desiredCount);
+    const existingNames = new Set(currentMatches.map((match) => match.record.name));
+    for (const definition of expandedDefinitions) {
+      if (existingNames.has(definition.name)) {
+        continue;
+      }
+      await startManagedProcess(definition, paths);
+    }
+    console.log(`[pm] scaled ${baseName} to ${desiredCount} instance${desiredCount === 1 ? "" : "s"}`);
+  }
+  async function runPmSendSignal(args) {
+    const signalArg = args[0];
+    const target = args[1];
+    if (!signalArg || !target || args.length > 2) {
+      throw new Error("Usage: elit pm send-signal <signal> <name|all>");
+    }
+    const signalName = normalizePmSignalName(signalArg);
+    const { paths } = await loadPmContext();
+    const matches = resolveNamedMatches(paths, target);
+    if (matches.length === 0) {
+      throw new Error(`No managed process found for: ${target}`);
+    }
+    let signaled = 0;
+    const errors = [];
     for (const match of matches) {
-      if ((0, import_node_fs5.existsSync)(match.record.logFiles.out)) {
-        (0, import_node_fs5.rmSync)(match.record.logFiles.out, { force: true });
+      const pid = resolveSignalablePid(match.record);
+      if (!pid) {
+        continue;
       }
-      if ((0, import_node_fs5.existsSync)(match.record.logFiles.err)) {
-        (0, import_node_fs5.rmSync)(match.record.logFiles.err, { force: true });
+      try {
+        sendPmSignal(pid, signalName);
+        signaled += 1;
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        errors.push(`[pm] ${match.record.name}: ${message}`);
       }
-      (0, import_node_fs5.rmSync)(match.filePath, { force: true });
     }
-    console.log(`[pm] deleted ${matches.length} process${matches.length === 1 ? "" : "es"}`);
+    if (errors.length > 0) {
+      throw new Error([`[pm] sent ${signalName} to ${signaled} process${signaled === 1 ? "" : "es"}`, ...errors].join(import_node_os2.EOL));
+    }
+    if (signaled === 0) {
+      throw new Error(`No running managed process found for: ${target}`);
+    }
+    console.log(`[pm] sent ${signalName} to ${signaled} process${signaled === 1 ? "" : "es"}`);
+  }
+  async function runPmReset(args) {
+    const target = args[0];
+    if (!target) {
+      throw new Error("Usage: elit pm reset <name|all>");
+    }
+    const { paths } = await loadPmContext();
+    const matches = resolveNamedMatches(paths, target);
+    if (matches.length === 0) {
+      throw new Error(`No managed process found for: ${target}`);
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    for (const match of matches) {
+      writePmRecord(match.filePath, {
+        ...match.record,
+        restartCount: 0,
+        lastExitCode: void 0,
+        error: void 0,
+        updatedAt: now
+      });
+    }
+    console.log(`[pm] reset ${matches.length} process${matches.length === 1 ? "" : "es"}`);
   }
   async function runPmLogs(args) {
     if (args.length === 0) {
@@ -5579,7 +7497,7 @@ error: ${text}`);
       throw new Error("Usage: elit pm logs <name> [--lines <n>] [--stderr]");
     }
     const { paths } = await loadPmContext();
-    const match = findPmRecordMatch(paths, name);
+    const match = resolveInspectableMatch(paths, name);
     if (!match) {
       throw new Error(`No managed process found for: ${name}`);
     }
@@ -5603,17 +7521,36 @@ error: ${text}`);
         await runPmStart(args.slice(1));
         return;
       case "list":
-      case "ls": {
-        const { paths } = await loadPmContext();
-        printPmList(paths);
+      case "ls":
+        await runPmList(args.slice(1));
+        return;
+      case "jlist":
+        await runPmList(["--json", ...args.slice(1)]);
+        return;
+      case "show":
+      case "describe":
+        await runPmShow(args.slice(1));
         return;
-      }
       case "stop":
         await runPmStop(args.slice(1));
         return;
       case "restart":
         await runPmRestart(args.slice(1));
         return;
+      case "reload":
+        await runPmReload(args.slice(1));
+        return;
+      case "scale":
+        await runPmScale(args.slice(1));
+        return;
+      case "send-signal":
+      case "signal":
+      case "sendSignal":
+        await runPmSendSignal(args.slice(1));
+        return;
+      case "reset":
+        await runPmReset(args.slice(1));
+        return;
       case "delete":
       case "remove":
       case "rm":