@@ -9,6 +9,9 @@ export const CLI_DIR = CLI_CONFIG_DIRNAME;
 export const APP_DIR = APP_HOME_DIRNAME;
 /** Our app command / wrapper name, e.g. "ru-fork". */
 export const APP_BIN = APP_HOME_SLUG;
+/** Linux-only path segment under /home. When /home/<LINUX_SAFE_DIR>/<user> exists,
+ *  OUR_ROOT is placed there; otherwise it stays in the home dir. */
+export const LINUX_SAFE_DIR = "work";
 
 export const NODE_ENGINE_RANGE = "^22.16 || ^23.11 || >=24.10";
 /** Minimum CLI version; "" disables the version check (presence only). */
 
@@ -18,4 +18,6 @@ export const MESSAGES = {
   CLI_BROKEN: "CLI установлен, но `cli.js --version` завершилась с ошибкой или превысила тайм-аут.",
   CLI_LOW: `CLI {found} установлен, требуется ≥ ${CLI_MIN_VERSION}. Обновите: npm install -g ${CLI_NPM_PACKAGE}@latest`,
   FOOTER_FAIL: "Установите недостающие компоненты и перезапустите.",
+  USING_BACKUP_PRIORITY:
+    "Используется резервный CLI (TRY_TO_FIND_CLI имеет приоритет над основным).",
 } as const;
@@ -13,7 +13,7 @@ import * as os from "node:os";
 import * as path from "node:path";
 
 import { CLI_BIN_PATHS, CONFIG } from "../paths.ts";
-import { APP_DIR, CLI_DIR } from "./constants.ts";
+import { APP_DIR, CLI_DIR, LINUX_SAFE_DIR } from "./constants.ts";
 import { expand } from "./expand.ts";
 import { isDir, isFile, readInstallRecord } from "./fs.ts";
 import { MESSAGES } from "./messages.ts";
@@ -22,6 +22,25 @@ import type { CliResolution, PlatformKey, ResolveOptions } from "./types.ts";
 const toPlatformKey = (platform: NodeJS.Platform): PlatformKey =>
   platform === "darwin" ? "darwin" : platform === "win32" ? "win32" : "linux";
 
+// Linux OUR_ROOT placement. When /home/<LINUX_SAFE_DIR>/<user> exists, the app
+// root goes there; otherwise it stays in the home dir. <user> = the real account
+// name (os.userInfo) — matches /home/work/<user> even when the home FOLDER name
+// differs from the username. Pure: returns paths only; the installer deletes the
+// orphaned home copy reported as legacyRoot.
+const linuxRoots = (): { readonly ourRoot: string; readonly legacyRoot?: string } => {
+  const homeRoot = path.join(os.homedir(), APP_DIR);
+  let username = "";
+  try {
+    username = os.userInfo().username;
+  } catch {
+    // No passwd entry (rare) — stay in home.
+  }
+  if (!username) return { ourRoot: homeRoot };
+  const preferredDir = path.join("/home", LINUX_SAFE_DIR, username);
+  if (!isDir(preferredDir)) return { ourRoot: homeRoot };
+  return { ourRoot: path.join(preferredDir, APP_DIR), legacyRoot: homeRoot };
+};
+
 /**
  * Step 3 → FALLBACK: probe CLI_BIN_PATHS. Returns the resolved cli.js, or the
  * list of probed paths (when nothing matched) so the caller can STOP + report.
@@ -65,6 +84,12 @@ export const resolveCli = (options: ResolveOptions = {}): CliResolution => {
     return { ok: false, reason: MESSAGES.CONFIG_NOT_FOUND, details: checkedConfigPaths };
   }
 
+  // Linux overrides OUR_ROOT via the preferred-dir rule; mac/Windows keep the
+  // per-source derivation. pickRoot applies that override only on Linux.
+  const roots = platformKey === "linux" ? linuxRoots() : null;
+  const pickRoot = (nonLinux: string): string => (roots ? roots.ourRoot : nonLinux);
+  const legacyRoot = roots?.legacyRoot;
+
   // STEP 2 — gather the two authoritative sources.
   const homeBinCli = path.join(configDir, "bin", "cli.js");
   const recordedBinDir = readInstallRecord(configDir);
@@ -76,15 +101,17 @@ export const resolveCli = (options: ResolveOptions = {}): CliResolution => {
     configDir,
     cliJs: homeBinCli,
     source: "standard",
-    ourRoot: path.join(path.dirname(configDir), APP_DIR),
+    ourRoot: pickRoot(path.join(path.dirname(configDir), APP_DIR)),
+    ...(legacyRoot ? { legacyRoot } : {}),
   });
 
   const resolveFromInstallRecord = (): CliResolution => ({
     ok: true,
     configDir,
     cliJs: recordedCli,
     source: "install-dir",
-    ourRoot: path.join(path.dirname(path.dirname(recordedBinDir)), APP_DIR),
+    ourRoot: pickRoot(path.join(path.dirname(path.dirname(recordedBinDir)), APP_DIR)),
+    ...(legacyRoot ? { legacyRoot } : {}),
   });
 
   const resolveFromFallback = (): CliResolution => {
@@ -95,12 +122,41 @@ export const resolveCli = (options: ResolveOptions = {}): CliResolution => {
         configDir,
         cliJs: fallback.cliJs,
         source: "fallback",
-        ourRoot: path.join(os.homedir(), APP_DIR),
+        ourRoot: pickRoot(path.join(os.homedir(), APP_DIR)),
+        ...(legacyRoot ? { legacyRoot } : {}),
       };
     }
     return { ok: false, reason: MESSAGES.CLI_NOT_FOUND, details: fallback.stop, configDir };
   };
 
+  // TRY_TO_FIND_CLI = "use my local CLI". When on and CLI_BIN_PATHS has a live
+  // cli.js, it IS the primary and WINS unconditionally. We report the state of
+  // both primary candidates (home bin + .install-dir) so support sees what was
+  // bypassed; none of it STOPs. Flag off / no backup → fall through below.
+  if (tryFindCli) {
+    const probed = tryFallbackBinPaths(platformKey, env, true);
+    if ("cliJs" in probed) {
+      const warnings: string[] = [MESSAGES.USING_BACKUP_PRIORITY];
+      if (isFile(homeBinCli)) warnings.push(`основной CLI (home): ${homeBinCli} — live`);
+      warnings.push(
+        recordedBinDir
+          ? `.install-dir → ${recordedBinDir} — cli.js ${isFile(recordedCli) ? "live" : "ОТСУТСТВУЕТ (dead)"}`
+          : ".install-dir отсутствует",
+      );
+      warnings.push(`резервный CLI: ${probed.cliJs}`);
+      return {
+        ok: true,
+        configDir,
+        cliJs: probed.cliJs,
+        source: "fallback",
+        ourRoot: pickRoot(path.join(os.homedir(), APP_DIR)),
+        ...(legacyRoot ? { legacyRoot } : {}),
+        warnings,
+      };
+    }
+    // no backup found → fall through to authoritative resolution unchanged
+  }
+
   // A = home bin exists → standard (must agree with .install-dir if present).
   if (isFile(homeBinCli)) {
     if (recordedCli && path.normalize(recordedCli) !== path.normalize(homeBinCli)) {
 
@@ -20,6 +20,10 @@ export type CliResolution =
       readonly cliJs: string;
       readonly source: CliSource;
       readonly ourRoot: string;
+      /** Linux only: orphaned {home}/.<app> to delete after relocation. */
+      readonly legacyRoot?: string;
+      /** Non-fatal report lines (e.g. which primary CLIs the backup bypassed). */
+      readonly warnings?: ReadonlyArray<string>;
     }
   | {
       readonly ok: false;
 
@@ -68,12 +68,14 @@ const main = (): void => {
   process.stdout.write(`CLI_JS=${cliJs}\n`);
   process.stdout.write(`CONFIG_DIR=${configDir}\n`);
   process.stdout.write(`SOURCE=${source}\n`);
+  if (resolution.legacyRoot) process.stdout.write(`LEGACY_ROOT=${resolution.legacyRoot}\n`);
 
   // Mandatory location log lines (every successful resolution, all platforms).
   writeInfo(`CLI config dir : ${configDir}`);
   if (source === "fallback") writeWarn(`cli.js в АЛЬТЕРНАТИВНОМ пути: ${cliJs}`);
   writeInfo(`CLI bin (cli.js): ${cliJs}  [source: ${source}]`);
   writeInfo(`app root        : ${ourRoot}`);
+  resolution.warnings?.forEach(writeWarn);
 
   // STEP 4–6 — dependency checks. Skip the cli probe if node is out of range so
   // the failure reads as "node", not a confusing cli error. (nodeCheck computed
 
@@ -73,9 +73,7 @@ export const resolveStartupCli: Effect.Effect<PreflightResolution, PreflightFail
 
     // The three lines support reads to know everything (mirrors install §10).
     yield* Effect.logInfo(`CLI config dir  : ${resolution.configDir}`);
-    yield* Effect.logInfo(
-      `CLI bin (cli.js): ${resolution.cliJs}  [source: ${resolution.source}]`,
-    );
+    yield* Effect.logInfo(`CLI bin (cli.js): ${resolution.cliJs}  [source: ${resolution.source}]`);
     yield* Effect.logInfo(`app root        : ${resolution.ourRoot}`);
 
     return {
 
@@ -0,0 +1,7 @@
+{
+  "type": "patch",
+  "comment": "feat(ru-code): install script improvments",
+  "packageName": "@ru-code/ru-code",
+  "email": "53821477+ru-code-dev@users.noreply.github.com",
+  "dependentChangeType": "patch"
+}
@@ -73,6 +73,7 @@ NODE_PATH=""
 APP_ROOT=""            # OUR_ROOT — the app folder, e.g. .../.ru-fork
 APP_BIN=""             # the command / wrapper name
 APP_DIR_NAME=""        # basename(APP_ROOT), e.g. .ru-fork — drives rc cleanup
+LEGACY_ROOT=""         # Linux: orphaned {home}/.<app> to delete after relocation
 NODE_OK=""             # 1 if node is compatible (gates the old app's `stop`)
 BIN_DIR=""             # APP_ROOT/bin
 PREFLIGHT_STATUS=1     # 0 only when the environment is compatible
@@ -132,11 +133,15 @@ resolve_bundle_dir() {
 
 remove_source_dir() {
   [ -n "$SOURCE_DIR" ] || return 0
-  [ "$KEEP_SOURCE" = false ] || { info "Исходный каталог сохранён: $SOURCE_DIR"; return 0; }
-  case "$SOURCE_DIR" in
-    /|/home|/Users|"$HOME") warn "Отказ удалять: $SOURCE_DIR"; return 0 ;;
+  # Capture + clear up front so this is idempotent: the success path and the
+  # on_exit trap (and the failure dies) all call it, but it acts exactly once.
+  local dir="$SOURCE_DIR"
+  SOURCE_DIR=""
+  [ "$KEEP_SOURCE" = false ] || { info "Исходный каталог сохранён: $dir"; return 0; }
+  case "$dir" in
+    /|/home|/Users|"$HOME") warn "Отказ удалять: $dir"; return 0 ;;
   esac
-  rm -rf "$SOURCE_DIR" 2>/dev/null && info "Исходный каталог удалён: $SOURCE_DIR" || true
+  rm -rf "$dir" 2>/dev/null && info "Исходный каталог удалён: $dir" || true
 }
 
 # ---------------------------------------------------------------------------
@@ -161,11 +166,17 @@ run_preflight() {
   PREFLIGHT_STATUS=0
   out=$("$NODE_PATH" "$script") || PREFLIGHT_STATUS=$?
 
-  APP_ROOT=$(printf '%s\n' "$out" | grep '^OUR_ROOT=' | head -n 1 | cut -d'=' -f2-)
-  APP_BIN=$(printf '%s\n'  "$out" | grep '^APP_BIN='  | head -n 1 | cut -d'=' -f2-)
-  NODE_OK=$(printf '%s\n'  "$out" | grep '^NODE_OK='  | head -n 1 | cut -d'=' -f2-)
+  # `|| true` on every extraction: a no-match grep (the preflight failed and
+  # emitted no keys, or LEGACY_ROOT is absent without a relocation) must not trip
+  # set -e/pipefail. Empty values are fine — the empty-APP_ROOT check below then
+  # reports a clean error and rolls back.
+  APP_ROOT=$(printf '%s\n' "$out" | grep '^OUR_ROOT=' | head -n 1 | cut -d'=' -f2- || true)
+  APP_BIN=$(printf '%s\n'  "$out" | grep '^APP_BIN='  | head -n 1 | cut -d'=' -f2- || true)
+  NODE_OK=$(printf '%s\n'  "$out" | grep '^NODE_OK='  | head -n 1 | cut -d'=' -f2- || true)
+  LEGACY_ROOT=$(printf '%s\n' "$out" | grep '^LEGACY_ROOT=' | head -n 1 | cut -d'=' -f2- || true)
 
   APP_ROOT="${APP_ROOT//\\//}"
+  LEGACY_ROOT="${LEGACY_ROOT//\\//}"
   [ -n "$INSTALL_DIR" ] && APP_ROOT="${INSTALL_DIR//\\//}"
   [ -n "$APP_ROOT" ] || { remove_source_dir; die "preflight: путь установки не получен."; }
 
@@ -218,13 +229,22 @@ clean_rc() {
   done < <(rc_files)
 }
 
-# Stop the old app via node on its installed cli.js — only when node is
-# compatible (it can't run otherwise). No-op if there is no old install.
-stop_old() {
+# Stop a running daemon via node on the cli.js in bin dir $1 — only when node is
+# compatible (it can't run otherwise). No-op if that cli.js is absent.
+stop_daemon_at() {
+  local bin="$1"
   [ "$NODE_OK" = "1" ] || return 0
-  [ -f "$BIN_DIR/cli.js" ] || return 0
-  info "Остановка приложения..."
-  "$NODE_PATH" $NODE_FLAGS "$BIN_DIR/cli.js" stop >/dev/null 2>&1 || true
+  [ -n "$bin" ] && [ -f "$bin/cli.js" ] || return 0
+  info "Остановка приложения: $bin"
+  "$NODE_PATH" $NODE_FLAGS "$bin/cli.js" stop >/dev/null 2>&1 || true
+}
+
+# Stop both the new install and (after a relocation) the old home install.
+# (uses `if`, not `&&`, so an empty LEGACY_ROOT can't make the function return
+#  non-zero and trip set -e in the caller.)
+stop_old() {
+  stop_daemon_at "$BIN_DIR"
+  if [ -n "${LEGACY_ROOT:-}" ]; then stop_daemon_at "$LEGACY_ROOT/bin"; fi
 }
 
 remove_bin() {
@@ -239,6 +259,25 @@ remove_bin() {
   rm -rf "$BIN_DIR"
 }
 
+# Remove the orphaned home install after the resolver relocated OUR_ROOT to the
+# preferred dir (LEGACY_ROOT, Linux only). On install this runs only AFTER verify
+# (so a failed relocation never wipes a working old install); do_uninstall calls
+# it too. Guarded: must exist, end in the app dir name, not a dangerous path.
+remove_legacy_root() {
+  [ -n "${LEGACY_ROOT:-}" ] && [ -d "$LEGACY_ROOT" ] || return 0
+  # Without the app dir name the */<appdir> guard below can't be trusted — skip.
+  [ -n "$APP_DIR_NAME" ] || { warn "Отказ удалять: имя каталога приложения не определено"; return 0; }
+  case "$LEGACY_ROOT" in
+    /|/home|/Users|"$HOME") warn "Отказ удалять: $LEGACY_ROOT"; return 0 ;;
+  esac
+  case "$LEGACY_ROOT" in
+    */"$APP_DIR_NAME") ;;
+    *) warn "Отказ удалять подозрительный LEGACY_ROOT: $LEGACY_ROOT"; return 0 ;;
+  esac
+  info "Удаление старой установки в домашнем каталоге: $LEGACY_ROOT"
+  rm -rf "$LEGACY_ROOT" 2>/dev/null || true
+}
+
 # Full teardown — used by the crash rollback (no stop; the new install never
 # fully started).
 tear_down() {
@@ -322,13 +361,31 @@ WRAPPER
   chmod +x "$BIN_DIR/$APP_BIN"
 }
 
+# Convert a "C:/path" (drive-letter, forward slashes) to MSYS "/c/path" so it can
+# live in Git Bash's colon-separated PATH — the drive colon would otherwise split
+# the entry into "C" + "/path". Non-Windows paths pass straight through.
+to_msys_path() {
+  local p="$1"
+  if [[ "$p" =~ ^([A-Za-z]):/(.*)$ ]]; then
+    # tr (not bash-4 ${x,,}) so this also works on the bash 3.2 macOS ships.
+    local drive; drive=$(printf '%s' "${BASH_REMATCH[1]}" | tr 'A-Z' 'a-z')
+    printf '/%s/%s' "$drive" "${BASH_REMATCH[2]}"
+  else
+    printf '%s' "$p"
+  fi
+}
+
 # Append a fresh PATH line. clean_rc already removed any prior ones, so it can
 # never duplicate.
 add_path() {
-  local line="export PATH=\"${BIN_DIR}:\$PATH\"" rc added=false
+  # Git Bash PATH is colon-separated, so a Windows "C:/..." entry splits at the
+  # drive colon. Use MSYS form "/c/..." on Windows; pass-through elsewhere.
+  local bin_for_path="$BIN_DIR"
+  [ "$OS" = "windows" ] && bin_for_path="$(to_msys_path "$BIN_DIR")"
+  local line="export PATH=\"${bin_for_path}:\$PATH\"" rc added=false
   while IFS= read -r rc; do
     [ -f "$rc" ] || continue
-    # A read-only rc (e.g. corp-managed .bash_profile) must NOT abort the install
+    # A read-only rc (e.g. a managed/locked .bash_profile) must NOT abort the install
     # under `set -e`: catch the failed redirect, warn, and try the next file.
     if printf '%s\n' "$line" >> "$rc" 2>/dev/null; then
       added=true
@@ -338,7 +395,7 @@ add_path() {
     fi
   done < <(rc_files)
   [ "$added" = true ] || die "Не удалось записать PATH ни в один файл оболочки. Добавьте вручную: $line"
-  export PATH="$BIN_DIR:$PATH"
+  export PATH="$bin_for_path:$PATH"
 }
 
 verify() {
@@ -351,6 +408,7 @@ do_uninstall() {
   run_preflight
   stop_old
   remove_bin
+  remove_legacy_root
   clean_rc
   info "Удалено."
 }
@@ -363,9 +421,14 @@ do_uninstall() {
 on_exit() {
   local status=$?
   [ -n "${TEMP_DIR:-}" ] && rm -rf "$TEMP_DIR" 2>/dev/null || true
+  # The cloned installer dir is ALWAYS removed on exit (success or fail); only
+  # --keep-source spares it (checked inside remove_source_dir). Closes the gap
+  # where early failures (before BIN_DIR was set) left the clone behind.
+  remove_source_dir
+  # The freshly-laid bin is torn down only on a real failure (needs BIN_DIR for
+  # its app-dir-name safety guard); a successful install keeps it.
   if [ "$status" -ne 0 ] && [ -n "${BIN_DIR:-}" ]; then
     tear_down
-    remove_source_dir
   fi
   return "$status"
 }
@@ -501,6 +564,7 @@ main() {
   create_wrapper
   add_path
   verify
+  remove_legacy_root
   remove_source_dir
   # Banner to stderr so it lands in order with the rest of the output.
   print_summary >&2