@phnx-labs/agents-cli 1.22.85 → 1.22.86

package/CHANGELOG.md

@@ -1,5 +1,44 @@
 # Changelog
 
+## 1.22.86
+
+- **Workers now materialize a slot for every registered Claude account, not only
+  the ones added through the v2 `accounts add` flow (PHNX-3940).** The daemon's
+  slot reconciliation skipped any account row without a `workerCredential` field —
+  every account registered before the v2 model — on the assumption that a legacy
+  row "resolves its token at spawn". That holds for `agents run claude#<name>` but
+  not for the interactive picker, so on a worker whose `auth` bundle already held
+  all eight setup-tokens `agents run claude --interactive --device auto` listed the
+  installed version labels, showed most of them `logged out`, and launching one put
+  a Claude login screen on a headless box. `reconcileLocalWorkerSlots` now resolves
+  each row through the same `reservedSyncTargets` the push plan uses (a v2 row's
+  reserved `__claude__` key, a legacy row's email-keyed `auth` token), so every
+  account whose token is on the box gets a `durable` slot with a 0600
+  `.oauth_token` and the seeded identity the adapter injects from. Two related
+  fixes ride along: the credential publisher is now a ready **headed** device
+  (`electPublisher`, headed-first then by name) instead of the alphabetically first
+  ready box, which had made a worker the fleet's source of truth; and slot
+  reconciliation runs first in the `auth-sync` tick, so a failed shared-state git
+  exchange no longer postpones local provisioning. Source:
+  `cli/src/lib/secrets/reserved-sync.ts`, `cli/src/lib/daemon/auth-sync-service.ts`.
+
+- **`agents secrets` no longer recurses into the legacy `secrets` shim after an
+  in-place upgrade (PHNX-3989).** Boxes that ran agents-cli before the standalone
+  `secrets` engine still carry `~/.agents/.cache/shims/secrets`, a command shim that
+  `exec`s `agents secrets`. It sits first on PATH and survives an upgrade because its
+  baked entrypoint still exists, and 1.22.85 resolved the standalone with a plain
+  `which secrets` — so on every such box `agents secrets …` (and the daemon's
+  reserved-store sync, which uses the same resolver) re-entered itself through the
+  shim without bound. The resolver now skips agents-cli's own shims dir when looking
+  for the standalone (`SECRETS_BIN` still wins; a miss still fails loud with the
+  install command), and the self-heal shim pass removes that legacy `secrets` shim
+  even though its target install is alive, since it can only recurse. The package's
+  postinstall — which used to write that very shim on every install, so an upgrade
+  kept bringing it back — no longer writes a `secrets` alias at all and removes one
+  a previous install left behind; the bare-command aliases are now `sessions`,
+  `browser`, `pty`, and `teams`. Install the standalone with
+  `npm i -g @phnx-labs/secrets-cli` if `agents secrets` reports it missing.
+
 ## 1.22.85
 
 - **`agents run codex` marks an exhausted account so rotation stops re-picking it

package/dist/commands/alias.js

@@ -8,9 +8,13 @@ import { setHelpSections } from '../lib/help.js';
 function aliasesFile() {
     return path.join(getUserAgentsDir(), 'aliases.json');
 }
-/** Names that would clobber an agent CLI shim or the `agents` binary itself. */
+/**
+ * Names that would clobber an agent CLI shim, the `agents` binary itself, or the
+ * standalone `secrets` CLI (PHNX-3989): the shims dir sits first on PATH, so an
+ * alias named `secrets` would shadow `@phnx-labs/secrets-cli` for every caller.
+ */
 function reservedNames() {
-    const reserved = new Set(['agents']);
+    const reserved = new Set(['agents', 'secrets']);
     for (const id of ALL_AGENT_IDS)
         reserved.add(AGENTS[id].cliCommand);
     return reserved;
@@ -85,7 +89,7 @@ export function registerAliasCommand(setupCmd) {
             process.exit(1);
         }
         if (reservedNames().has(name)) {
-            console.error(chalk.red(`"${name}" is reserved (collides with an agent CLI or the agents binary).`));
+            console.error(chalk.red(`"${name}" is reserved (collides with an agent CLI, the agents binary, or the standalone secrets CLI).`));
             process.exit(1);
         }
         const target = shimPath(name);

package/dist/lib/agent-spec/agents.js

@@ -127,6 +127,12 @@ export function findInPath(command, options = {}) {
                 const stat = fs.statSync(full);
                 if (!stat.isFile())
                     continue;
+                // A shell only runs an executable file; `which` skips a mode-644 namesake and
+                // so must this, or a stray non-executable `secrets`/`claude` file earlier on
+                // PATH would shadow the real binary further down. On win32 the mode bit is
+                // meaningless (PATHEXT decides), so the check is POSIX-only.
+                if (process.platform !== 'win32')
+                    fs.accessSync(full, fs.constants.X_OK);
                 const native = resolveNativeBinaryPath(command, full, options);
                 if (native)
                     return native;

package/dist/lib/daemon/auth-sync-service.js

@@ -22,7 +22,24 @@ export class AuthSyncService extends BasePeriodicService {
         // Nothing to release — the supervisor's timer teardown is the only cleanup.
     }
     async onTick(ctx) {
-        const { publishReservedAuthVerdict, syncReservedAuthBundle } = await import('../secrets-policy.js');
+        const { publishReservedAuthVerdict, reconcileLocalWorkerSlots, syncReservedAuthBundle, syncReservedStores, } = await import('../secrets-policy.js');
+        // Worker-side slot materialization FIRST (PHNX-3940 T6): for each registered
+        // account whose durable key is already on this box, create the HOME-shaped
+        // slot the picker and spawn read. It touches only local state — the registry
+        // copy and the file-backed store — so it never waits on the git exchange
+        // below. It used to sit after `if (!transport.success) return`, so a single
+        // `git rebase timed out` postponed every slot on the box by another tick.
+        // Self-gated on device role: a headed box returns immediately.
+        try {
+            const slots = reconcileLocalWorkerSlots();
+            if (slots.provisioned.length > 0)
+                ctx.log('INFO', `auth-sync: provisioned worker slot(s) for ${slots.provisioned.join(', ')}`);
+            for (const err of slots.errors)
+                ctx.log('WARN', `auth-sync: worker slot ${err.accountId}: ${err.message}`);
+        }
+        catch (err) {
+            ctx.log('WARN', `auth-sync: worker slot reconcile: ${err.message}`);
+        }
         const published = await publishReservedAuthVerdict();
         if (published.error)
             ctx.log('WARN', `auth-sync: verdict: ${published.error}`);
@@ -44,13 +61,10 @@ export class AuthSyncService extends BasePeriodicService {
         for (const err of result.errors) {
             ctx.log('WARN', `auth-sync: ${err.device}: ${err.message}`);
         }
-        // Generalized per-account, per-key, per-role reserved-store sync (PHNX-3940
+        // Generalized per-account, per-key, per-role reserved-store push (PHNX-3940
         // T6). On the elected headed publisher this pushes every portable account's
-        // reserved `__<harness>__` store to the worker peers missing it; on a worker
-        // it materializes a slot for each account whose durable key has landed. Each
-        // self-gates on device role, so exactly one arm acts per box. The push is the
-        // only transport — provisioning writes only locally (invariant 1).
-        const { syncReservedStores, reconcileLocalWorkerSlots } = await import('../secrets-policy.js');
+        // reserved `__<harness>__` store to the worker peers missing it. The push is
+        // the only transport — provisioning (above) writes only locally (invariant 1).
         try {
             const stores = await syncReservedStores();
             for (const p of stores.pushed)
@@ -61,15 +75,5 @@ export class AuthSyncService extends BasePeriodicService {
         catch (err) {
             ctx.log('WARN', `auth-sync: reserved-store sync: ${err.message}`);
         }
-        try {
-            const slots = reconcileLocalWorkerSlots();
-            if (slots.provisioned.length > 0)
-                ctx.log('INFO', `auth-sync: provisioned worker slot(s) for ${slots.provisioned.join(', ')}`);
-            for (const err of slots.errors)
-                ctx.log('WARN', `auth-sync: worker slot ${err.accountId}: ${err.message}`);
-        }
-        catch (err) {
-            ctx.log('WARN', `auth-sync: worker slot reconcile: ${err.message}`);
-        }
     }
 }

package/dist/lib/installations/shims.d.ts

@@ -358,10 +358,12 @@ export declare function listShimFileNames(): string[];
 /**
  * Prune a stale, orphaned shim: one that is NOT a managed agent shim and NOT a user
  * alias, whose baked `AGENTS_BIN` points at an install that no longer exists. These
- * are legacy `exec "$AGENTS_BIN" <cmd>` command shims (browser/secrets/sessions/…)
- * left behind by a removed install — the current source never generates them, and
- * they either die with `exit 127` or shadow the real package bin on PATH. Only
- * removed when the baked target is gone, so a working shim is never touched.
+ * are `exec "$AGENTS_BIN" <cmd>` command shims (browser/sessions/pty/teams) that
+ * `scripts/postinstall.js` writes for the LIVE install; one baked at a removed
+ * install either dies with `exit 127` or shadows the real package bin on PATH.
+ * Only removed when the baked target is gone, so a working shim is never touched —
+ * except the `LEGACY_SHIMS_ALWAYS_PRUNED` set, which cannot work at all (and which
+ * postinstall no longer writes).
  * Returns true if removed.
  */
 export declare function pruneOrphanedCommandShim(fileName: string): boolean;

package/dist/lib/installations/shims.js

@@ -2165,13 +2165,25 @@ export function listShimFileNames() {
         return [];
     }
 }
+/**
+ * Legacy command shims that are wrong even when their baked install is alive.
+ * `secrets`: the shim `exec`s `agents secrets`, which since PHNX-3989 is a
+ * passthrough to the STANDALONE `secrets` binary — so a `secrets` shim that
+ * re-enters `agents secrets` is a recursion, never a working command. It sits
+ * first on PATH and shadows the real `@phnx-labs/secrets-cli` bin, so it is
+ * pruned unconditionally (the liveness check below is what kept it alive across
+ * every in-place upgrade from 1.22.84).
+ */
+const LEGACY_SHIMS_ALWAYS_PRUNED = new Set(['secrets']);
 /**
  * Prune a stale, orphaned shim: one that is NOT a managed agent shim and NOT a user
  * alias, whose baked `AGENTS_BIN` points at an install that no longer exists. These
- * are legacy `exec "$AGENTS_BIN" <cmd>` command shims (browser/secrets/sessions/…)
- * left behind by a removed install — the current source never generates them, and
- * they either die with `exit 127` or shadow the real package bin on PATH. Only
- * removed when the baked target is gone, so a working shim is never touched.
+ * are `exec "$AGENTS_BIN" <cmd>` command shims (browser/sessions/pty/teams) that
+ * `scripts/postinstall.js` writes for the LIVE install; one baked at a removed
+ * install either dies with `exit 127` or shadows the real package bin on PATH.
+ * Only removed when the baked target is gone, so a working shim is never touched —
+ * except the `LEGACY_SHIMS_ALWAYS_PRUNED` set, which cannot work at all (and which
+ * postinstall no longer writes).
  * Returns true if removed.
  */
 export function pruneOrphanedCommandShim(fileName) {
@@ -2192,7 +2204,7 @@ export function pruneOrphanedCommandShim(fileName) {
     const bin = readAgentsBinFromShim(shimPath);
     if (!bin)
         return false; // not an AGENTS_BIN-baked shim
-    if (fs.existsSync(bin))
+    if (fs.existsSync(bin) && !LEGACY_SHIMS_ALWAYS_PRUNED.has(fileName))
         return false; // its install is still alive — leave it
     try {
         fs.rmSync(shimPath);

package/dist/lib/secrets-client.d.ts

@@ -56,8 +56,16 @@ export declare function parseBundleValue(raw: BundleValue): {
 };
 /**
  * Resolve the standalone `secrets` executable: `$SECRETS_BIN` if set, else the
- * `secrets` command on PATH. Cached for the process. A miss throws with install
- * guidance — there is NO fallback to the embedded engine (DIST-1).
+ * `secrets` command on PATH — resolved with `findInPath`, which skips agents-cli's
+ * own shims dir. That skip is load-bearing, not tidiness: before PHNX-3989 the
+ * shims dir carried a `secrets` command shim that `exec`s `agents secrets`, it
+ * sits FIRST on PATH, and it survives an in-place upgrade (its baked entrypoint
+ * still exists). A plain `which secrets` returned that shim, so `agents secrets`
+ * → shim → `agents secrets` → … spawned an unbounded process chain on every box
+ * upgraded from 1.22.84 (the whole fleet, via R5 auto-update). A `secrets` inside
+ * our shims dir can never be the standalone, so it is not a candidate at all.
+ * Cached for the process. A miss throws with install guidance — there is NO
+ * fallback to the embedded engine (DIST-1).
  */
 export declare function resolveSecretsBin(): string;
 /**

package/dist/lib/secrets-client.js

@@ -45,7 +45,7 @@ import { spawn, spawnSync } from 'node:child_process';
 import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
-import { findExecutable } from './platform/exec.js';
+import { findInPath } from './agent-spec/agents.js';
 import { getUserAgentsDir } from './state.js';
 /**
  * Wire contract, mirrored from `secrets-cli/src/protocol.ts`. Both sides MUST
@@ -190,14 +190,22 @@ export function parseBundleValue(raw) {
 let cachedBin;
 /**
  * Resolve the standalone `secrets` executable: `$SECRETS_BIN` if set, else the
- * `secrets` command on PATH. Cached for the process. A miss throws with install
- * guidance — there is NO fallback to the embedded engine (DIST-1).
+ * `secrets` command on PATH — resolved with `findInPath`, which skips agents-cli's
+ * own shims dir. That skip is load-bearing, not tidiness: before PHNX-3989 the
+ * shims dir carried a `secrets` command shim that `exec`s `agents secrets`, it
+ * sits FIRST on PATH, and it survives an in-place upgrade (its baked entrypoint
+ * still exists). A plain `which secrets` returned that shim, so `agents secrets`
+ * → shim → `agents secrets` → … spawned an unbounded process chain on every box
+ * upgraded from 1.22.84 (the whole fleet, via R5 auto-update). A `secrets` inside
+ * our shims dir can never be the standalone, so it is not a candidate at all.
+ * Cached for the process. A miss throws with install guidance — there is NO
+ * fallback to the embedded engine (DIST-1).
  */
 export function resolveSecretsBin() {
     if (cachedBin)
         return cachedBin;
     const explicit = process.env.SECRETS_BIN?.trim();
-    const resolved = explicit && explicit.length > 0 ? explicit : findExecutable('secrets');
+    const resolved = explicit && explicit.length > 0 ? explicit : findInPath('secrets');
     if (!resolved) {
         throw new SecretsClientError('SECRETS_BIN_MISSING', 'The standalone `secrets` CLI was not found. Install it with:\n' +
             '  npm i -g @phnx-labs/secrets-cli\n' +

package/dist/lib/secrets-policy.d.ts

@@ -75,9 +75,21 @@ export interface AuthSyncDeps {
     localName?: string;
     userAgentsDir?: string;
     isPinned?: (name: string) => boolean;
+    peerRole?: (name: string) => ReturnType<typeof selfConfiguredDeviceRole>;
+    selfRole?: () => ReturnType<typeof selfConfiguredDeviceRole>;
     push?: (bundle: string, host: string) => Promise<PushBundleResult>;
     sshTarget?: (device: DeviceProfile) => string;
 }
+/**
+ * The one device that pushes credentials this tick. A ready HEADED device
+ * (`personal`/`desktop`) wins over any ready worker: the headed box is where
+ * tokens are minted (invariant 7), so it is the copy of record; a worker holds
+ * only what was once pushed to it. Name order breaks ties so every box elects
+ * the same publisher from the same shared verdicts. Before this rule the sort
+ * was by name alone, which elected `mac-mini` (a worker with a 6-day-old copy)
+ * over `zion`, and zion then skipped every peer as a non-publisher.
+ */
+export declare function electPublisher(ready: readonly string[], roleOf: (name: string) => ReturnType<typeof selfConfiguredDeviceRole>): string | null;
 export interface PublishAuthVerdictOptions {
     inspectLocal?: () => {
         exists: boolean;
@@ -181,6 +193,7 @@ export interface ReservedStoreSyncDeps {
     readMetaFn?: () => Pick<Meta, 'accounts' | 'deviceAccounts'>;
     isPinned?: (name: string) => boolean;
     peerRole?: (name: string) => ReturnType<typeof selfConfiguredDeviceRole>;
+    selfRole?: () => ReturnType<typeof selfConfiguredDeviceRole>;
     localReady?: boolean;
     /** Does THIS publisher hold (bundle, key) to push? Defaults to a local bundle read. */
     hasLocalKey?: (bundle: string, key: string) => boolean;

package/dist/lib/secrets-policy.js

@@ -122,6 +122,19 @@ export function planAuthBundlePush(localAuthOk, localIsPublisher, devices) {
         return { action: 'push', device: device.name };
     });
 }
+/**
+ * The one device that pushes credentials this tick. A ready HEADED device
+ * (`personal`/`desktop`) wins over any ready worker: the headed box is where
+ * tokens are minted (invariant 7), so it is the copy of record; a worker holds
+ * only what was once pushed to it. Name order breaks ties so every box elects
+ * the same publisher from the same shared verdicts. Before this rule the sort
+ * was by name alone, which elected `mac-mini` (a worker with a 6-day-old copy)
+ * over `zion`, and zion then skipped every peer as a non-publisher.
+ */
+export function electPublisher(ready, roleOf) {
+    const rank = (name) => (isHeadedDeviceRole(roleOf(name)) ? 0 : 1);
+    return [...ready].sort((a, b) => rank(a) - rank(b) || normalizeHost(a).localeCompare(normalizeHost(b)))[0] ?? null;
+}
 function defaultDevices() {
     return Object.values(loadDevicesSync());
 }
@@ -175,8 +188,9 @@ export async function syncReservedAuthBundle(deps = {}) {
     if (localStatus === 'ready' && !readyPublishers.some((name) => normalizeHost(name) === localNorm)) {
         readyPublishers.push(localName);
     }
-    readyPublishers.sort((a, b) => normalizeHost(a).localeCompare(normalizeHost(b)));
-    result.publisher = readyPublishers[0] ?? null;
+    const peerRole = deps.peerRole ?? configuredDeviceRole;
+    const selfRole = deps.selfRole ?? selfConfiguredDeviceRole;
+    result.publisher = electPublisher(readyPublishers, (name) => (normalizeHost(name) === localNorm ? selfRole() : peerRole(name)));
     const localIsPublisher = result.publisher !== null && normalizeHost(result.publisher) === localNorm;
     const pinned = deps.isPinned ?? ((name) => isHostPinned(name, managedKnownHostsPath()));
     const plan = planAuthBundlePush(localStatus === 'ready', localIsPublisher, devices.map((device) => ({
@@ -386,8 +400,9 @@ export async function syncReservedStores(deps = {}) {
         .map((s) => s.device);
     if (localReady && !readyPublishers.some((n) => normalizeHost(n) === localNorm))
         readyPublishers.push(localName);
-    readyPublishers.sort((a, b) => normalizeHost(a).localeCompare(normalizeHost(b)));
-    result.publisher = readyPublishers[0] ?? null;
+    const peerRole = deps.peerRole ?? configuredDeviceRole;
+    const selfRole = deps.selfRole ?? selfConfiguredDeviceRole;
+    result.publisher = electPublisher(readyPublishers, (name) => (normalizeHost(name) === localNorm ? selfRole() : peerRole(name)));
     const localIsPublisher = result.publisher !== null && normalizeHost(result.publisher) === localNorm;
     if (targets.length === 0 || !localIsPublisher) {
         for (const d of devices) {
@@ -397,7 +412,6 @@ export async function syncReservedStores(deps = {}) {
     }
     const memo = readDeliveryMemo(deps.cacheDir);
     const pinned = deps.isPinned ?? ((name) => isHostPinned(name, managedKnownHostsPath()));
-    const peerRole = deps.peerRole ?? configuredDeviceRole;
     const peers = devices.map((d) => ({
         name: d.name,
         headed: isHeadedDeviceRole(peerRole(d.name)),
@@ -459,11 +473,19 @@ export function reconcileLocalWorkerSlots(deps = {}) {
     const slots = readSlots(meta);
     const hasLocalKey = deps.hasLocalKey ?? defaultHasLocalKey;
     const provision = deps.provision ?? provisionWorkerSlot;
-    for (const account of listNativeAccounts(meta)) {
-        const cred = account.workerCredential;
-        if (!cred)
-            continue; // legacy claude worker resolves its token at spawn
-        if (!hasLocalKey(cred.bundle, cred.key)) {
+    const byId = new Map(listNativeAccounts(meta).map((account) => [account.id, account]));
+    // Resolve each account to the one (bundle, key) the push plan uses: a T1 row's
+    // reserved `__<harness>__` key, or the legacy `auth` key by email for a claude
+    // row predating T1. Both are worker credentials this box may already hold, so
+    // both get a slot. Skipping the legacy rows here is what left every registered
+    // pre-T1 account without a slot on every worker while its token sat in `auth`:
+    // the picker then fell back to identity-less version homes and Claude showed a
+    // login screen on a headless box (the mac-mini 2026-09-06 incident).
+    for (const target of reservedSyncTargets(meta)) {
+        const account = byId.get(target.accountId);
+        if (!account)
+            continue;
+        if (!hasLocalKey(target.bundle, target.key)) {
             result.skipped.push({ accountId: account.id, reason: 'durable key not synced yet' });
             continue;
         }

package/dist/lib/self-heal/checks/shims.js

@@ -46,10 +46,12 @@ export const shimsCheck = {
             if (!ctx.dryRun && removeLegacyUserShim(agent))
                 fixed.push(`removed legacy ${cmd} shim`);
         }
-        // Prune orphaned legacy command shims (browser/secrets/sessions/… left by a
-        // removed install) whose baked AGENTS_BIN is dead — the current source never
+        // Prune orphaned legacy command shims (browser/sessions/… left by a removed
+        // install) whose baked AGENTS_BIN is dead — the current source never
         // regenerates them, and they either die with exit 127 or shadow the real
-        // package bin on PATH. Only removes shims whose target install is gone.
+        // package bin on PATH. Only removes shims whose target install is gone — plus
+        // the legacy `secrets` shim regardless: it re-enters `agents secrets`, which is
+        // a passthrough to the standalone binary since PHNX-3989, so it can only recurse.
         if (!ctx.dryRun) {
             for (const name of listShimFileNames()) {
                 if (pruneOrphanedCommandShim(name))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phnx-labs/agents-cli",
-  "version": "1.22.85",
+  "version": "1.22.86",
   "description": "One CLI for all your AI coding agents - versions, config, cloud dispatch, sessions, and teams (now with first-class Grok Build CLI support)",
   "type": "module",
   "main": "dist/index.js",

package/scripts/postinstall.js

@@ -50,9 +50,39 @@ function shellQuote(value) {
 }
 
 // Shorthands that delegate to the installed agents-cli entrypoint.
-const ALIASES = ['sessions', 'secrets', 'browser', 'pty', 'teams'];
+const ALIASES = ['sessions', 'browser', 'pty', 'teams'];
+
+// Aliases this script USED to write and must now remove on every install.
+// `secrets`: the name belongs to the standalone `@phnx-labs/secrets-cli` binary
+// (PHNX-3989); `agents secrets` is a passthrough to it, so an alias shim that
+// `exec`s `agents secrets` can only re-enter the passthrough, and it shadows the
+// real `secrets` bin because the shims dir sits first on PATH. The self-heal
+// shim pass prunes it too, but that only runs from a daemon or a TTY session —
+// postinstall is what every upgrade path actually executes, so it cleans up here.
+const RETIRED_ALIASES = ['secrets'];
+
+function removeRetiredAliasShims() {
+  for (const name of RETIRED_ALIASES) {
+    for (const file of [path.join(SHIMS_DIR, name), path.join(SHIMS_DIR, name + '.cmd')]) {
+      let content;
+      try {
+        content = fs.readFileSync(file, 'utf8');
+      } catch {
+        continue;
+      }
+      // Only ever remove OUR alias — the POSIX shim ends in `<name> "$@"`, the
+      // Windows companion in `<name> %*` — never an unrelated file someone placed
+      // under that name, and never a user's own `agents setup alias` shim, which
+      // is marked `# Alias shim:` (the same guard pruneOrphanedCommandShim keeps).
+      if (content.includes('# Alias shim:')) continue;
+      if (!content.includes(`${name} "$@"`) && !content.includes(`${name} %*`)) continue;
+      fs.rmSync(file, { force: true });
+    }
+  }
+}
 
 function writeAliasShims() {
+  removeRetiredAliasShims();
   const written = [];
   for (const name of ALIASES) {
     const target = path.join(SHIMS_DIR, name);