@skrr-ai/cli 0.1.115 → 0.1.116

package/dist/node_modules/@skrr-ai/auth-core/dist/cjs/firstPartyHarnessHome.js

@@ -1,375 +1,265 @@
 "use strict";
-/**
- * Where the first-party harness lives on disk, and the one-time move that keeps
- * that true across a rename.
- *
- * ── Why one implementation ────────────────────────────────────────────────
- *
- * Three processes put an engine under the skrr root and read it back: the daemon
- * installer, the CLI (`skrr code`), and the desktop app's bundled-engine
- * install. Each used to build `<root>/sky-code/bin/sky-code` itself, and they
- * already disagreed once about which root that was (see `configRoot.ts`). A
- * rename that every one of them had to perform independently would disagree
- * again, so the paths AND the move live here.
- *
- * ── The move ──────────────────────────────────────────────────────────────
- *
- * Idempotent, lossless, and safe to run concurrently from all three:
- *
- *   1. The HOME follows the engine's namespace. If `<root>/<appName>` does not
- *      exist and `<root>/<legacyAppName>` is a real directory, rename it and
- *      leave the legacy name as a relative symlink. (No legacy app name exists
- *      yet; this step is what an engine-namespace rename will use.)
- *   2. The BINARY follows the provider. Inside `<home>/bin`, if the canonical
- *      binary does not exist and a binary under an older spelling is a real
- *      file, rename it and each companion (rollback copy, provenance sidecar),
- *      leaving a relative symlink at every old name.
- *
- * "Older spelling" means every ARTIFACT spelling that is not canonical — the
- * aliases AND the former spellings (`firstPartyHarnessArtifactSpellings`). An
- * installed binary is an artifact: a machine that never ran a post-rename client
- * still has its engine under the old name after that name stops being accepted
- * anywhere, and it must still be moved rather than reinstalled beside.
- *
- * The two follow different names on purpose: the home is shared with the
- * engine, which reads its config and managed `AGENTS.md` from it, so it can only
- * move when the engine's namespace does (`firstPartyHarnessHomeDirname`). The
- * symlinks are the compatibility story, not an afterthought: every CLI and
- * daemon already installed reads the legacy binary path, and a symlink keeps
- * them working with no coordination.
- *
- * It never overwrites, never deletes, and never renames THROUGH a symlink, so
- * running it twice, or after a downgrade, changes nothing. Any error leaves the
- * tree exactly as it was and is reported rather than thrown: a failed move must
- * degrade to reading the old path, not to an engine that cannot start.
- *
- * Skipped on Windows, where creating a symlink needs a privilege a normal user
- * does not hold, and where no engine artifact is published anyway.
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FIRST_PARTY_HARNESS_PROVENANCE_SUFFIX = exports.FIRST_PARTY_HARNESS_PREVIOUS_SUFFIX = void 0;
-exports.firstPartyHarnessHomeDir = firstPartyHarnessHomeDir;
-exports.firstPartyHarnessBinDir = firstPartyHarnessBinDir;
-exports.firstPartyHarnessInstalledBinaryPath = firstPartyHarnessInstalledBinaryPath;
-exports.migrateFirstPartyHarnessHome = migrateFirstPartyHarnessHome;
-exports.linkFirstPartyHarnessAliases = linkFirstPartyHarnessAliases;
-const node_fs_1 = require("node:fs");
-const node_path_1 = __importDefault(require("node:path"));
-const configRoot_js_1 = require("./configRoot.js");
-const firstPartyHarness_js_1 = require("./firstPartyHarness.js");
-/** Every artifact spelling except the canonical one, newest first. */
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var firstPartyHarnessHome_exports = {};
+__export(firstPartyHarnessHome_exports, {
+  FIRST_PARTY_HARNESS_PREVIOUS_SUFFIX: () => FIRST_PARTY_HARNESS_PREVIOUS_SUFFIX,
+  FIRST_PARTY_HARNESS_PROVENANCE_SUFFIX: () => FIRST_PARTY_HARNESS_PROVENANCE_SUFFIX,
+  firstPartyHarnessBinDir: () => firstPartyHarnessBinDir,
+  firstPartyHarnessHomeDir: () => firstPartyHarnessHomeDir,
+  firstPartyHarnessInstalledBinaryPath: () => firstPartyHarnessInstalledBinaryPath,
+  linkFirstPartyHarnessAliases: () => linkFirstPartyHarnessAliases,
+  migrateFirstPartyHarnessHome: () => migrateFirstPartyHarnessHome
+});
+module.exports = __toCommonJS(firstPartyHarnessHome_exports);
+var import_node_fs = require("node:fs");
+var import_node_path = __toESM(require("node:path"), 1);
+var import_configRoot = require("./configRoot.js");
+var import_firstPartyHarness = require("./firstPartyHarness.js");
 function olderSpellings() {
-    return (0, firstPartyHarness_js_1.firstPartyHarnessArtifactSpellings)().filter((spelling) => spelling !== firstPartyHarness_js_1.FIRST_PARTY_HARNESS.provider);
+  return (0, import_firstPartyHarness.firstPartyHarnessArtifactSpellings)().filter((spelling) => spelling !== import_firstPartyHarness.FIRST_PARTY_HARNESS.provider);
 }
-/**
- * Entries rescued from a legacy home when the canonical one already exists as a
- * shell. `bin` is what managed resolution needs; `skills` is the user's own
- * data. Deliberately a short, named list rather than "everything": a merge this
- * module cannot enumerate (there is no readdir here) would be guessing.
- */
-const STRANDED_HOME_ENTRIES = ['bin', 'skills'];
-/** Suffix of the rollback copy the installer keeps beside the binary. */
-exports.FIRST_PARTY_HARNESS_PREVIOUS_SUFFIX = '.previous';
-/**
- * Suffix of the provenance record beside the binary. The `oversky` in it is a
- * persisted file name that already exists on machines, not the product name.
- */
-exports.FIRST_PARTY_HARNESS_PROVENANCE_SUFFIX = '.oversky-provenance.json';
-/** `<root>/<engine appName>` — the engine home, shared by the platform and the engine. */
+const STRANDED_HOME_ENTRIES = ["bin", "skills"];
+const FIRST_PARTY_HARNESS_PREVIOUS_SUFFIX = ".previous";
+const FIRST_PARTY_HARNESS_PROVENANCE_SUFFIX = ".oversky-provenance.json";
 function firstPartyHarnessHomeDir(env = process.env) {
-    return node_path_1.default.join((0, configRoot_js_1.resolveConfigRoot)(env), (0, firstPartyHarness_js_1.firstPartyHarnessHomeDirname)());
+  return import_node_path.default.join((0, import_configRoot.resolveConfigRoot)(env), (0, import_firstPartyHarness.firstPartyHarnessHomeDirname)());
 }
-/** `<home>/bin`, where the platform installs the engine binary. */
 function firstPartyHarnessBinDir(env = process.env) {
-    return node_path_1.default.join(firstPartyHarnessHomeDir(env), 'bin');
+  return import_node_path.default.join(firstPartyHarnessHomeDir(env), "bin");
 }
-/** The installed binary path for a spelling (canonical by default) — lookup order is canonical first. */
-function firstPartyHarnessInstalledBinaryPath(env = process.env, provider = firstPartyHarness_js_1.FIRST_PARTY_HARNESS.provider, platform = process.platform) {
-    return node_path_1.default.join(firstPartyHarnessBinDir(env), (0, firstPartyHarness_js_1.firstPartyHarnessBinaryName)(provider, platform));
+function firstPartyHarnessInstalledBinaryPath(env = process.env, provider = import_firstPartyHarness.FIRST_PARTY_HARNESS.provider, platform = process.platform) {
+  return import_node_path.default.join(firstPartyHarnessBinDir(env), (0, import_firstPartyHarness.firstPartyHarnessBinaryName)(provider, platform));
 }
 const NODE_FS = {
-    lstat(p) {
-        try {
-            return (0, node_fs_1.lstatSync)(p);
-        }
-        catch {
-            return null;
-        }
-    },
-    readlink(p) {
-        try {
-            return (0, node_fs_1.lstatSync)(p).isSymbolicLink() ? (0, node_fs_1.readlinkSync)(p) : null;
-        }
-        catch {
-            return null;
-        }
-    },
-    rename: node_fs_1.renameSync,
-    symlink(target, at, type) {
-        (0, node_fs_1.symlinkSync)(target, at, type);
-    },
+  lstat(p) {
+    try {
+      return (0, import_node_fs.lstatSync)(p);
+    } catch {
+      return null;
+    }
+  },
+  readlink(p) {
+    try {
+      return (0, import_node_fs.lstatSync)(p).isSymbolicLink() ? (0, import_node_fs.readlinkSync)(p) : null;
+    } catch {
+      return null;
+    }
+  },
+  rename: import_node_fs.renameSync,
+  symlink(target, at, type) {
+    (0, import_node_fs.symlinkSync)(target, at, type);
+  }
 };
 function isRealDirectory(stat) {
-    return stat !== null && stat.isDirectory() && !stat.isSymbolicLink();
+  return stat !== null && stat.isDirectory() && !stat.isSymbolicLink();
 }
 function isRealFile(stat) {
-    return stat !== null && stat.isFile() && !stat.isSymbolicLink();
+  return stat !== null && stat.isFile() && !stat.isSymbolicLink();
 }
 function describe(err) {
-    return err instanceof Error ? err.message : String(err);
+  return err instanceof Error ? err.message : String(err);
 }
-/** Companions that travel with the binary, binary first. */
 const COMPANION_SUFFIXES = [
-    '',
-    exports.FIRST_PARTY_HARNESS_PREVIOUS_SUFFIX,
-    exports.FIRST_PARTY_HARNESS_PROVENANCE_SUFFIX,
+  "",
+  FIRST_PARTY_HARNESS_PREVIOUS_SUFFIX,
+  FIRST_PARTY_HARNESS_PROVENANCE_SUFFIX
 ];
-/**
- * How much newer an alias binary must be before it is treated as a later
- * install rather than the same one. Clock and filesystem-granularity slack.
- */
-const NEWER_THRESHOLD_MS = 1000;
-/**
- * Move a legacy engine home and binary onto the canonical names. See the file
- * header for the exact contract. Returns what it did; never throws.
- *
- * Inside `<home>/bin` it resolves the three layouts a rename can leave. An
- * "alias" below is any non-canonical artifact spelling — an accepted alias or a
- * former spelling alike, since the file on disk does not know which it is now:
- *
- *   - canonical ABSENT, an alias is a real file — the ordinary legacy install.
- *     The alias moves to canonical and a link is left at its name.
- *   - canonical is a LINK to an alias that is a real file — what an alias link
- *     left DURING the expand phase becomes once the flip swaps which spelling is
- *     canonical. Leaving it means the next install writes its provenance record
- *     THROUGH the link onto the old binary's record, and the legacy name then
- *     verifies as `tampered`. The real file is adopted onto the canonical name
- *     (a rename replaces the link itself, never what it points at).
- *   - canonical and an alias are BOTH real files and the alias is newer — a
- *     client that predates the flip installed an update under the old name. The
- *     newer engine is what every reader should run, so it is promoted: the older
- *     canonical binary becomes the rollback copy, and the alias becomes a link.
- *
- * Any other layout is left exactly as it is.
- */
+const NEWER_THRESHOLD_MS = 1e3;
 function migrateFirstPartyHarnessHome(options = {}) {
-    const env = options.env ?? process.env;
-    const platform = options.platform ?? process.platform;
-    const fs = options.fs ?? NODE_FS;
-    if (platform === 'win32') {
-        return { moved: [], errors: [], skipped: 'unsupported-platform' };
+  const env = options.env ?? process.env;
+  const platform = options.platform ?? process.platform;
+  const fs = options.fs ?? NODE_FS;
+  if (platform === "win32") {
+    return { moved: [], errors: [], skipped: "unsupported-platform" };
+  }
+  const moved = [];
+  const errors = [];
+  const canonical = import_firstPartyHarness.FIRST_PARTY_HARNESS.provider;
+  const root = (0, import_configRoot.resolveConfigRoot)(env);
+  const canonicalHome = firstPartyHarnessHomeDir(env);
+  if (fs.lstat(canonicalHome) === null) {
+    for (const legacyAppName of import_firstPartyHarness.FIRST_PARTY_HARNESS_ENGINE.legacyAppNames) {
+      const aliasHome = import_node_path.default.join(root, legacyAppName);
+      if (!isRealDirectory(fs.lstat(aliasHome)))
+        continue;
+      try {
+        fs.rename(aliasHome, canonicalHome);
+      } catch (err) {
+        errors.push(`could not move ${aliasHome} to ${canonicalHome}: ${describe(err)}`);
+        break;
+      }
+      moved.push(`${aliasHome} -> ${canonicalHome}`);
+      try {
+        fs.symlink(import_node_path.default.basename(canonicalHome), aliasHome, "dir");
+        moved.push(`symlink ${aliasHome} -> ${import_node_path.default.basename(canonicalHome)}`);
+      } catch (err) {
+        errors.push(`moved ${aliasHome} but could not leave a symlink behind: ${describe(err)}`);
+      }
+      break;
     }
-    const moved = [];
-    const errors = [];
-    const canonical = firstPartyHarness_js_1.FIRST_PARTY_HARNESS.provider;
-    const root = (0, configRoot_js_1.resolveConfigRoot)(env);
-    const canonicalHome = firstPartyHarnessHomeDir(env);
-    // 1. The home directory — follows the engine's namespace.
-    if (fs.lstat(canonicalHome) === null) {
-        for (const legacyAppName of firstPartyHarness_js_1.FIRST_PARTY_HARNESS_ENGINE.legacyAppNames) {
-            const aliasHome = node_path_1.default.join(root, legacyAppName);
-            if (!isRealDirectory(fs.lstat(aliasHome)))
-                continue;
-            try {
-                fs.rename(aliasHome, canonicalHome);
-            }
-            catch (err) {
-                // A concurrent migrator may have won; step 2 still runs against
-                // whatever is now at the canonical path.
-                errors.push(`could not move ${aliasHome} to ${canonicalHome}: ${describe(err)}`);
-                break;
-            }
-            moved.push(`${aliasHome} -> ${canonicalHome}`);
-            try {
-                fs.symlink(node_path_1.default.basename(canonicalHome), aliasHome, 'dir');
-                moved.push(`symlink ${aliasHome} -> ${node_path_1.default.basename(canonicalHome)}`);
-            }
-            catch (err) {
-                errors.push(`moved ${aliasHome} but could not leave a symlink behind: ${describe(err)}`);
-            }
-            break;
-        }
-    }
-    else if (isRealDirectory(fs.lstat(canonicalHome))) {
-        // 1b. The canonical home EXISTS, so the rename above is impossible — but it
-        // may be a shell rather than the real home. A managed write that reaches
-        // `<root>/<appName>` before this migration runs creates the directory, and
-        // from then on step 1 skips forever and the legacy home keeps the binary.
-        // Observed on a real machine: `<root>/<appName>` holding a 2-byte `{}`
-        // config written hours after `<root>/<legacy appName>/bin` received the
-        // signed 107MB engine, which left managed resolution pointing at a bin
-        // directory that did not exist and every managed session with no engine to
-        // spawn.
-        //
-        // A rename cannot merge two directories, and this module has no readdir, so
-        // this moves the two entries that carry weight and nothing else: `bin`,
-        // which is what resolution needs, and `skills`, which is user data. An
-        // entry already present at the canonical home is never touched — the shell
-        // may be empty, but it is not automatically wrong.
-        for (const legacyAppName of firstPartyHarness_js_1.FIRST_PARTY_HARNESS_ENGINE.legacyAppNames) {
-            const aliasHome = node_path_1.default.join(root, legacyAppName);
-            if (!isRealDirectory(fs.lstat(aliasHome)))
-                continue;
-            for (const entry of STRANDED_HOME_ENTRIES) {
-                const from = node_path_1.default.join(aliasHome, entry);
-                const to = node_path_1.default.join(canonicalHome, entry);
-                if (!isRealDirectory(fs.lstat(from)))
-                    continue;
-                if (fs.lstat(to) !== null)
-                    continue;
-                try {
-                    fs.rename(from, to);
-                    moved.push(`${from} -> ${to}`);
-                }
-                catch (err) {
-                    errors.push(`could not move ${from} to ${to}: ${describe(err)}`);
-                }
-            }
-            break;
-        }
-    }
-    // 2. The binary and its companions — follow the provider — inside the home.
-    const binDir = node_path_1.default.join(canonicalHome, 'bin');
-    if (!isRealDirectory(fs.lstat(binDir))) {
-        return { moved, errors };
-    }
-    const canonicalName = (0, firstPartyHarness_js_1.firstPartyHarnessBinaryName)(canonical, platform);
-    const canonicalBinary = node_path_1.default.join(binDir, canonicalName);
-    const canonicalStat = fs.lstat(canonicalBinary);
-    const aliasNames = olderSpellings().map((spelling) => (0, firstPartyHarness_js_1.firstPartyHarnessBinaryName)(spelling, platform));
-    /** Move `<from><suffix>` onto `<to><suffix>` and leave a link; `replaceable` says what may sit at the target. */
-    const relocate = (fromName, suffix, replaceable) => {
-        const from = node_path_1.default.join(binDir, `${fromName}${suffix}`);
-        const to = node_path_1.default.join(binDir, `${canonicalName}${suffix}`);
-        const toStat = fs.lstat(to);
-        if (!isRealFile(fs.lstat(from)) || !replaceable(to, toStat))
-            return 'skipped';
-        try {
-            // `rename` replaces a LINK at `to` itself, never the file it points at.
-            fs.rename(from, to);
-        }
-        catch (err) {
-            errors.push(`could not move ${from} to ${to}: ${describe(err)}`);
-            return 'failed';
-        }
-        moved.push(`${from} -> ${to}`);
+  } else if (isRealDirectory(fs.lstat(canonicalHome))) {
+    for (const legacyAppName of import_firstPartyHarness.FIRST_PARTY_HARNESS_ENGINE.legacyAppNames) {
+      const aliasHome = import_node_path.default.join(root, legacyAppName);
+      if (!isRealDirectory(fs.lstat(aliasHome)))
+        continue;
+      for (const entry of STRANDED_HOME_ENTRIES) {
+        const from = import_node_path.default.join(aliasHome, entry);
+        const to = import_node_path.default.join(canonicalHome, entry);
+        if (!isRealDirectory(fs.lstat(from)))
+          continue;
+        if (fs.lstat(to) !== null)
+          continue;
         try {
-            fs.symlink(node_path_1.default.basename(to), from, 'file');
-            moved.push(`symlink ${from} -> ${node_path_1.default.basename(to)}`);
+          fs.rename(from, to);
+          moved.push(`${from} -> ${to}`);
+        } catch (err) {
+          errors.push(`could not move ${from} to ${to}: ${describe(err)}`);
         }
-        catch (err) {
-            errors.push(`moved ${from} but could not leave a symlink behind: ${describe(err)}`);
-        }
-        return 'moved';
-    };
-    // 2a. Canonical absent: an ordinary legacy install.
-    if (canonicalStat === null) {
-        const aliasName = aliasNames.find((name) => isRealFile(fs.lstat(node_path_1.default.join(binDir, name))));
-        if (aliasName) {
-            for (const suffix of COMPANION_SUFFIXES) {
-                const outcome = relocate(aliasName, suffix, (_to, toStat) => toStat === null);
-                if (suffix === '' && outcome !== 'moved')
-                    break;
-            }
-        }
-        return { moved, errors };
+      }
+      break;
     }
-    // 2b. Canonical is a link to a real alias file: adopt the file.
-    const linkText = fs.readlink(canonicalBinary);
-    if (linkText !== null) {
-        const linkedName = node_path_1.default.basename(linkText);
-        if (node_path_1.default.dirname(linkText) === '.' &&
-            aliasNames.includes(linkedName) &&
-            isRealFile(fs.lstat(node_path_1.default.join(binDir, linkedName)))) {
-            for (const suffix of COMPANION_SUFFIXES) {
-                const outcome = relocate(linkedName, suffix, (to, toStat) => toStat === null || fs.readlink(to) === `${linkedName}${suffix}`);
-                if (suffix === '' && outcome !== 'moved')
-                    break;
-            }
-        }
-        return { moved, errors };
+  }
+  const binDir = import_node_path.default.join(canonicalHome, "bin");
+  if (!isRealDirectory(fs.lstat(binDir))) {
+    return { moved, errors };
+  }
+  const canonicalName = (0, import_firstPartyHarness.firstPartyHarnessBinaryName)(canonical, platform);
+  const canonicalBinary = import_node_path.default.join(binDir, canonicalName);
+  const canonicalStat = fs.lstat(canonicalBinary);
+  const aliasNames = olderSpellings().map((spelling) => (0, import_firstPartyHarness.firstPartyHarnessBinaryName)(spelling, platform));
+  const relocate = (fromName, suffix, replaceable) => {
+    const from = import_node_path.default.join(binDir, `${fromName}${suffix}`);
+    const to = import_node_path.default.join(binDir, `${canonicalName}${suffix}`);
+    const toStat = fs.lstat(to);
+    if (!isRealFile(fs.lstat(from)) || !replaceable(to, toStat))
+      return "skipped";
+    try {
+      fs.rename(from, to);
+    } catch (err) {
+      errors.push(`could not move ${from} to ${to}: ${describe(err)}`);
+      return "failed";
     }
-    // 2c. Both real, alias newer: an update installed under the old name.
-    if (isRealFile(canonicalStat)) {
-        const newer = aliasNames
-            .map((name) => ({ name, stat: fs.lstat(node_path_1.default.join(binDir, name)) }))
-            .filter((entry) => isRealFile(entry.stat))
-            .filter((entry) => entry.stat.mtimeMs - canonicalStat.mtimeMs > NEWER_THRESHOLD_MS)
-            .sort((a, b) => b.stat.mtimeMs - a.stat.mtimeMs)[0];
-        if (newer) {
-            const previous = `${canonicalBinary}${exports.FIRST_PARTY_HARNESS_PREVIOUS_SUFFIX}`;
-            const previousStat = fs.lstat(previous);
-            if (previousStat !== null && !isRealFile(previousStat)) {
-                errors.push(`${previous} is not a regular file; left the newer ${newer.name} in place`);
-                return { moved, errors };
-            }
-            try {
-                // The older canonical engine becomes the rollback copy — the same
-                // meaning `.previous` has after any install.
-                fs.rename(canonicalBinary, previous);
-            }
-            catch (err) {
-                errors.push(`could not keep ${canonicalBinary} as ${previous}: ${describe(err)}`);
-                return { moved, errors };
-            }
-            moved.push(`${canonicalBinary} -> ${previous}`);
-            for (const suffix of ['', exports.FIRST_PARTY_HARNESS_PROVENANCE_SUFFIX]) {
-                // The alias's sidecar describes the alias's bytes, so it replaces the
-                // canonical one: a record must always sit beside the binary it describes.
-                const outcome = relocate(newer.name, suffix, (to, toStat) => suffix === '' ? toStat === null : toStat === null || isRealFile(toStat));
-                if (suffix === '' && outcome !== 'moved')
-                    break;
-            }
-        }
+    moved.push(`${from} -> ${to}`);
+    try {
+      fs.symlink(import_node_path.default.basename(to), from, "file");
+      moved.push(`symlink ${from} -> ${import_node_path.default.basename(to)}`);
+    } catch (err) {
+      errors.push(`moved ${from} but could not leave a symlink behind: ${describe(err)}`);
+    }
+    return "moved";
+  };
+  if (canonicalStat === null) {
+    const aliasName = aliasNames.find((name) => isRealFile(fs.lstat(import_node_path.default.join(binDir, name))));
+    if (aliasName) {
+      for (const suffix of COMPANION_SUFFIXES) {
+        const outcome = relocate(aliasName, suffix, (_to, toStat) => toStat === null);
+        if (suffix === "" && outcome !== "moved")
+          break;
+      }
     }
     return { moved, errors };
-}
-/**
- * Leave a relative symlink at every older name — binary and provenance sidecar —
- * that does not exist yet, pointing at the canonical file.
- *
- * Call after installing the canonical binary. A platform CLI or daemon installed
- * before a rename resolves the legacy name; the link keeps it on the current
- * engine. "Older" includes FORMER spellings, not only aliases: an installed CLI
- * cannot be telemetry-gated the way a connected daemon can, and it does not stop
- * existing when its spelling stops being accepted, so the link outlives the
- * alias window (`firstPartyHarnessBinaryNames`). It never replaces anything that
- * exists, whether a real file (an older engine someone may still run) or a link
- * someone else placed. Never throws.
- */
-function linkFirstPartyHarnessAliases(options = {}) {
-    const env = options.env ?? process.env;
-    const platform = options.platform ?? process.platform;
-    const fs = options.fs ?? NODE_FS;
-    if (platform === 'win32') {
-        return { moved: [], errors: [], skipped: 'unsupported-platform' };
+  }
+  const linkText = fs.readlink(canonicalBinary);
+  if (linkText !== null) {
+    const linkedName = import_node_path.default.basename(linkText);
+    if (import_node_path.default.dirname(linkText) === "." && aliasNames.includes(linkedName) && isRealFile(fs.lstat(import_node_path.default.join(binDir, linkedName)))) {
+      for (const suffix of COMPANION_SUFFIXES) {
+        const outcome = relocate(linkedName, suffix, (to, toStat) => toStat === null || fs.readlink(to) === `${linkedName}${suffix}`);
+        if (suffix === "" && outcome !== "moved")
+          break;
+      }
     }
-    const moved = [];
-    const errors = [];
-    const binDir = firstPartyHarnessBinDir(env);
-    const canonicalName = (0, firstPartyHarness_js_1.firstPartyHarnessBinaryName)(firstPartyHarness_js_1.FIRST_PARTY_HARNESS.provider, platform);
-    if (!isRealFile(fs.lstat(node_path_1.default.join(binDir, canonicalName)))) {
+    return { moved, errors };
+  }
+  if (isRealFile(canonicalStat)) {
+    const newer = aliasNames.map((name) => ({ name, stat: fs.lstat(import_node_path.default.join(binDir, name)) })).filter((entry) => isRealFile(entry.stat)).filter((entry) => entry.stat.mtimeMs - canonicalStat.mtimeMs > NEWER_THRESHOLD_MS).sort((a, b) => b.stat.mtimeMs - a.stat.mtimeMs)[0];
+    if (newer) {
+      const previous = `${canonicalBinary}${FIRST_PARTY_HARNESS_PREVIOUS_SUFFIX}`;
+      const previousStat = fs.lstat(previous);
+      if (previousStat !== null && !isRealFile(previousStat)) {
+        errors.push(`${previous} is not a regular file; left the newer ${newer.name} in place`);
         return { moved, errors };
+      }
+      try {
+        fs.rename(canonicalBinary, previous);
+      } catch (err) {
+        errors.push(`could not keep ${canonicalBinary} as ${previous}: ${describe(err)}`);
+        return { moved, errors };
+      }
+      moved.push(`${canonicalBinary} -> ${previous}`);
+      for (const suffix of ["", FIRST_PARTY_HARNESS_PROVENANCE_SUFFIX]) {
+        const outcome = relocate(newer.name, suffix, (to, toStat) => suffix === "" ? toStat === null : toStat === null || isRealFile(toStat));
+        if (suffix === "" && outcome !== "moved")
+          break;
+      }
     }
-    for (const spelling of olderSpellings()) {
-        const aliasName = (0, firstPartyHarness_js_1.firstPartyHarnessBinaryName)(spelling, platform);
-        // Sidecar FIRST: a verifier that finds the binary link must find its record.
-        for (const suffix of [exports.FIRST_PARTY_HARNESS_PROVENANCE_SUFFIX, '']) {
-            const target = `${canonicalName}${suffix}`;
-            const at = node_path_1.default.join(binDir, `${aliasName}${suffix}`);
-            if (!isRealFile(fs.lstat(node_path_1.default.join(binDir, target))) || fs.lstat(at) !== null)
-                continue;
-            try {
-                fs.symlink(target, at, 'file');
-                moved.push(`symlink ${at} -> ${target}`);
-            }
-            catch (err) {
-                errors.push(`could not link ${at} -> ${target}: ${describe(err)}`);
-            }
-        }
-    }
+  }
+  return { moved, errors };
+}
+function linkFirstPartyHarnessAliases(options = {}) {
+  const env = options.env ?? process.env;
+  const platform = options.platform ?? process.platform;
+  const fs = options.fs ?? NODE_FS;
+  if (platform === "win32") {
+    return { moved: [], errors: [], skipped: "unsupported-platform" };
+  }
+  const moved = [];
+  const errors = [];
+  const binDir = firstPartyHarnessBinDir(env);
+  const canonicalName = (0, import_firstPartyHarness.firstPartyHarnessBinaryName)(import_firstPartyHarness.FIRST_PARTY_HARNESS.provider, platform);
+  if (!isRealFile(fs.lstat(import_node_path.default.join(binDir, canonicalName)))) {
     return { moved, errors };
+  }
+  for (const spelling of olderSpellings()) {
+    const aliasName = (0, import_firstPartyHarness.firstPartyHarnessBinaryName)(spelling, platform);
+    for (const suffix of [FIRST_PARTY_HARNESS_PROVENANCE_SUFFIX, ""]) {
+      const target = `${canonicalName}${suffix}`;
+      const at = import_node_path.default.join(binDir, `${aliasName}${suffix}`);
+      if (!isRealFile(fs.lstat(import_node_path.default.join(binDir, target))) || fs.lstat(at) !== null)
+        continue;
+      try {
+        fs.symlink(target, at, "file");
+        moved.push(`symlink ${at} -> ${target}`);
+      } catch (err) {
+        errors.push(`could not link ${at} -> ${target}: ${describe(err)}`);
+      }
+    }
+  }
+  return { moved, errors };
 }
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FIRST_PARTY_HARNESS_PREVIOUS_SUFFIX,
+  FIRST_PARTY_HARNESS_PROVENANCE_SUFFIX,
+  firstPartyHarnessBinDir,
+  firstPartyHarnessHomeDir,
+  firstPartyHarnessInstalledBinaryPath,
+  linkFirstPartyHarnessAliases,
+  migrateFirstPartyHarnessHome
+});