elit 3.6.7 → 3.6.8

package/dist/pm.mjs

@@ -461,6 +461,7 @@ var DEFAULT_RESTART_DELAY = 1e3;
 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;
@@ -468,6 +469,11 @@ var DEFAULT_HEALTHCHECK_MAX_FAILURES = 3;
 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;
@@ -505,6 +511,32 @@ function normalizePmRestartPolicy(value, optionName = "--restart-policy") {
   }
   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) {
@@ -512,6 +544,30 @@ function normalizeIntegerOption(value, optionName, min = 0) {
   }
   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;
@@ -788,6 +844,30 @@ function readRequiredValue(args, index, optionName) {
   }
   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
 import { existsSync as existsSync2, mkdirSync, readFileSync, readdirSync, writeFileSync } from "fs";
@@ -820,18 +900,31 @@ function writePmRecord(filePath, record) {
 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,
@@ -898,6 +991,9 @@ function findPmRecordMatch(paths, nameOrId) {
   }
   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;
@@ -947,11 +1043,22 @@ function toPmAppConfig(record) {
     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,
@@ -970,11 +1077,22 @@ function toSavedPmAppConfig(app) {
     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,
@@ -986,6 +1104,170 @@ function toSavedPmAppConfig(app) {
 
 // src/cli/pm/config.ts
 import { resolve as resolve3 } from "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 };
@@ -1028,6 +1310,20 @@ function defaultProcessName(base, explicitName) {
   }
   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;
 }
@@ -1065,8 +1361,25 @@ function resolvePmAppDefinition(base, parsed, workspaceRoot, source) {
     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";
@@ -1086,6 +1399,7 @@ function resolvePmAppDefinition(base, parsed, workspaceRoot, source) {
     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) {
@@ -1094,8 +1408,14 @@ function resolvePmAppDefinition(base, parsed, workspaceRoot, source) {
   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,
@@ -1110,9 +1430,19 @@ function resolvePmAppDefinition(base, parsed, workspaceRoot, source) {
     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) : [],
@@ -1124,16 +1454,17 @@ function resolvePmAppDefinition(base, parsed, workspaceRoot, source) {
 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 = {
@@ -1206,6 +1537,39 @@ function parsePmStartArgs(args) {
         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;
@@ -1256,6 +1620,30 @@ function parsePmStartArgs(args) {
       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;
@@ -1295,6 +1683,9 @@ function parsePmStartArgs(args) {
       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;
@@ -1336,8 +1727,15 @@ function printPmHelp() {
     "  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",
@@ -1353,6 +1751,12 @@ function printPmHelp() {
     "  --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",
@@ -1364,6 +1768,14 @@ function printPmHelp() {
     "  --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",
@@ -1376,6 +1788,7 @@ function printPmHelp() {
     "  --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:",
@@ -1399,6 +1812,17 @@ function printPmHelp() {
     "  - 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.",
@@ -1409,7 +1833,7 @@ function printPmHelp() {
 // src/cli/pm/process.ts
 import { spawn, spawnSync } from "child_process";
 import { existsSync as existsSync3 } from "fs";
-import { basename, join as join4 } from "path";
+import { basename, dirname as dirname2, join as join4, resolve as resolve4 } from "path";
 function readCurrentCliInvocation() {
   const cliEntry = process.argv[1];
   if (!cliEntry) {
@@ -1454,16 +1878,94 @@ function resolveTsxExecutable(cwd) {
   const globalCommand = process.platform === "win32" ? "tsx.cmd" : "tsx";
   return commandExists(globalCommand) ? globalCommand : void 0;
 }
+function resolvePmNodeSharedListenerBootstrapPath() {
+  const cliEntry = process.argv[1];
+  const candidates = [
+    join4(__dirname, "node-shared-listener-bootstrap.cjs"),
+    join4(__dirname, "..", "..", "..", "dist", "pm-node-shared-listener-bootstrap.cjs")
+  ];
+  if (cliEntry) {
+    const resolvedCliEntry = resolve4(cliEntry);
+    const baseDir = dirname2(resolvedCliEntry);
+    candidates.push(
+      join4(baseDir, "cli", "pm", "node-shared-listener-bootstrap.cjs"),
+      join4(baseDir, "pm-node-shared-listener-bootstrap.cjs")
+    );
+  }
+  return candidates.find((candidate) => existsSync3(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 = 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 = 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,
@@ -1535,9 +2037,23 @@ function buildPmCommand(record) {
   }
   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: `${basename(executable)} ${quoteCommandSegment(record.file)}`
   };
@@ -1549,20 +2065,33 @@ function createRecordFromDefinition(definition, paths, existing) {
   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,
@@ -1578,16 +2107,20 @@ function createRecordFromDefinition(definition, paths, existing) {
     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: join4(paths.logsDir, `${id}.out.log`),
       err: join4(paths.logsDir, `${id}.err.log`)
     }
   };
 }
-function terminateProcessTree(pid) {
+function terminateProcessTree(pid, options) {
   if (process.platform === "win32") {
     const result = spawnSync("taskkill", ["/PID", String(pid), "/T", "/F"], {
       stdio: "ignore",
@@ -1599,7 +2132,17 @@ function terminateProcessTree(pid) {
     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") {
@@ -1651,9 +2194,10 @@ async function startManagedProcess(definition, paths) {
 
 // src/cli/pm/runner.ts
 import { spawn as spawn2 } from "child_process";
+import { createServer as createHttpServer } from "http";
 import { createWriteStream, mkdirSync as mkdirSync3 } from "fs";
 import { EOL } from "os";
-import { dirname as dirname3, join as join6, resolve as resolve5 } from "path";
+import { dirname as dirname4, join as join6, resolve as resolve6 } from "path";
 
 // src/server/chokidar/watch.ts
 init_runtime();
@@ -1884,13 +2428,13 @@ var win32 = createPathOps(true);
 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);
 }
 
@@ -1928,14 +2472,14 @@ function getBaseDirectory(pattern) {
   }
   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 || ".";
 }
@@ -2130,9 +2674,210 @@ function watch(paths, options) {
   return watcher;
 }
 
+// src/cli/pm/proxy.ts
+import { createServer, request as httpRequest } from "http";
+import { request as httpsRequest } from "https";
+import { createServer as createNetServer } from "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 = createNetServer();
+  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 = 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:" ? httpsRequest : httpRequest;
+    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:" ? httpsRequest : httpRequest;
+    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}${EOL}`);
+  if (stream.writableEnded || stream.destroyed) {
+    return;
+  }
+  try {
+    stream.write(`[elit pm] ${(/* @__PURE__ */ new Date()).toISOString()} ${message}${EOL}`);
+  } catch (error) {
+    if (error.code !== "ERR_STREAM_WRITE_AFTER_END") {
+      throw error;
+    }
+  }
 }
 function waitForExit(code, signal) {
   if (typeof code === "number") {
@@ -2146,40 +2891,369 @@ function waitForExit(code, signal) {
 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 = dirname4(filePath);
+  const dataDir = dirname4(appsDir);
+  return {
+    dataDir,
+    appsDir,
+    logsDir: join6(dataDir, "logs"),
+    dumpFile: join6(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";
 }
-async function createPmWatchController(record, onChange, onError) {
-  if (!record.watch || record.watchPaths.length === 0) {
+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 = createHttpServer();
+  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 {
       async close() {
       }
@@ -2241,11 +3315,17 @@ function createPmHealthMonitor(record, onFailure, onLog) {
         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}`);
@@ -2280,6 +3360,90 @@ function createPmHealthMonitor(record, onFailure, onLog) {
     }
   };
 }
+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;
 }
@@ -2289,10 +3453,20 @@ async function runManagedProcessLoop(filePath, initialRecord) {
   let activeChildStopTimer = null;
   let stopRequested = false;
   const restartState = { request: null };
-  mkdirSync3(dirname3(initialRecord.logFiles.out), { recursive: true });
-  mkdirSync3(dirname3(initialRecord.logFiles.err), { recursive: true });
+  mkdirSync3(dirname4(initialRecord.logFiles.out), { recursive: true });
+  mkdirSync3(dirname4(initialRecord.logFiles.err), { recursive: true });
   const stdoutLog = createWriteStream(initialRecord.logFiles.out, { flags: "a" });
   const stderrLog = 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);
@@ -2305,26 +3479,30 @@ async function runManagedProcessLoop(filePath, initialRecord) {
       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);
@@ -2332,6 +3510,7 @@ async function runManagedProcessLoop(filePath, initialRecord) {
       }
     }
     terminateProcessTree(activeChild.pid);
+    scheduleForcedActiveChildStop(stopTimeout, "graceful shutdown timed out");
   };
   const requestManagedStop = (reason) => {
     if (stopRequested) {
@@ -2369,6 +3548,17 @@ async function runManagedProcessLoop(filePath, initialRecord) {
       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);
@@ -2378,25 +3568,24 @@ async function runManagedProcessLoop(filePath, initialRecord) {
           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 = spawn2(command.command, command.args, {
+      const initialTargetPort = usesPmProxyController(latest) ? await allocatePmProxyTargetPort(resolvePmProxyTargetHost(latest.proxy)) : void 0;
+      const monitorRecord = buildPmMonitorRecord(latest, initialTargetPort);
+      let child = spawn2(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 });
@@ -2404,26 +3593,38 @@ async function runManagedProcessLoop(filePath, initialRecord) {
       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",
@@ -2431,27 +3632,124 @@ async function runManagedProcessLoop(filePath, initialRecord) {
         }));
         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 = spawn2(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);
@@ -2467,56 +3765,77 @@ async function runManagedProcessLoop(filePath, initialRecord) {
       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;
@@ -2529,11 +3848,26 @@ async function runManagedProcessLoop(filePath, initialRecord) {
       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));
   }
@@ -2558,7 +3892,7 @@ function parseRunnerArgs(args) {
     throw new Error("Usage: elit pm __run --data-dir <dir> --id <name>");
   }
   return {
-    dataDir: resolve5(dataDir),
+    dataDir: resolve6(dataDir),
     id
   };
 }
@@ -2587,23 +3921,26 @@ async function stopPmMatches(matches) {
       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()
     });
@@ -2672,13 +4009,13 @@ function readPackageJson(filePath) {
 
 // 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;
     }
@@ -2706,17 +4043,17 @@ init_fs();
 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];
 }
@@ -2751,7 +4088,7 @@ function resolveWorkspacePackageImport(specifier, startDir, options = {}) {
 // 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;
     }
@@ -2780,7 +4117,7 @@ async function loadConfigFile(configPath) {
   if (ext === "ts" || ext === "mts") {
     try {
       const { build } = await import("esbuild");
-      const configDir = dirname2(configPath);
+      const configDir = dirname3(configPath);
       const tempFile = join5(configDir, `.elit-config-${Date.now()}.mjs`);
       const externalAllPlugin = {
         name: "external-all",
@@ -2854,6 +4191,43 @@ async function loadConfigFile(configPath) {
 }
 
 // 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();
@@ -2886,9 +4260,130 @@ function resolveNamedMatches(paths, value) {
   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 (existsSync5(match.record.logFiles.out)) {
+      rmSync(match.record.logFiles.out, { force: true });
+    }
+    if (existsSync5(match.record.logFiles.err)) {
+      rmSync(match.record.logFiles.err, { force: true });
+    }
+    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 (!existsSync5(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)}`;
 }
@@ -2899,8 +4394,255 @@ function tailLogFile(filePath, lineCount) {
   const lines = readFileSync3(filePath, "utf8").split(/\r?\n/).filter((line) => line.length > 0);
   return lines.slice(-lineCount).join(EOL2);
 }
-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(EOL2);
+}
+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;
@@ -2909,22 +4651,47 @@ function printPmList(paths) {
     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) {
@@ -2951,17 +4718,62 @@ async function runPmRestart(args) {
   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(EOL2));
+  }
+  console.log(`[pm] reloaded ${reloaded.join(", ")}`);
+}
 async function runPmSave() {
   const { paths } = await loadPmContext();
   ensurePmDirectories(paths);
@@ -2983,12 +4795,7 @@ async function runPmResurrect() {
   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) {
@@ -3012,16 +4819,127 @@ async function runPmDelete(args) {
     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 (existsSync5(match.record.logFiles.out)) {
-      rmSync(match.record.logFiles.out, { force: true });
+    const pid = resolveSignalablePid(match.record);
+    if (!pid) {
+      continue;
     }
-    if (existsSync5(match.record.logFiles.err)) {
-      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}`);
     }
-    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(EOL2));
+  }
+  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) {
@@ -3054,7 +4972,7 @@ async function runPmLogs(args) {
     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}`);
   }
@@ -3078,17 +4996,36 @@ async function runPmCommand(args) {
       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":
@@ -3120,6 +5057,12 @@ export {
   DEFAULT_MIN_UPTIME,
   DEFAULT_PM_DATA_DIR,
   DEFAULT_PM_DUMP_FILE,
+  DEFAULT_PM_EXP_BACKOFF_MAX_DELAY,
+  DEFAULT_PM_KILL_TIMEOUT,
+  DEFAULT_PM_LISTEN_TIMEOUT,
+  DEFAULT_PM_MEMORY_CHECK_INTERVAL,
+  DEFAULT_PM_PROXY_STRATEGY,
+  DEFAULT_PM_RESTART_WINDOW,
   DEFAULT_PM_STOP_GRACE_PERIOD_MS,
   DEFAULT_PM_STOP_POLL_MS,
   DEFAULT_RESTART_DELAY,
@@ -3138,7 +5081,10 @@ export {
   countDefinedPmWapkSources,
   deriveDefaultWatchPaths,
   ensurePmDirectories,
+  expandPmInstanceDefinitions,
+  findPmGroupMatches,
   findPmRecordMatch,
+  formatPmInstanceName,
   getPmRecordPath,
   hasPmGoogleDriveConfig,
   hasPmWapkRunConfig,
@@ -3157,6 +5103,10 @@ export {
   normalizeHealthCheckConfig,
   normalizeIntegerOption,
   normalizeNonEmptyString,
+  normalizePmMemoryAction,
+  normalizePmMemoryLimit,
+  normalizePmProxyConfig,
+  normalizePmProxyStrategy,
   normalizePmRestartPolicy,
   normalizePmRuntime,
   normalizeResolvedWatchIgnorePaths,
@@ -3180,7 +5130,9 @@ export {
   runManagedProcessLoop,
   runPmCommand,
   runPmRunner,
+  samplePmProcessMetrics,
   sanitizePmProcessName,
+  sendPmSignal,
   startManagedProcess,
   stopPmMatches,
   stripPmWapkSourceFromRunConfig,