claude-use 6.2.3 → 7.1.1

package/dist/cli.cjs

@@ -35168,18 +35168,18 @@ function reportFatalError(error62, io) {
     return error62.exitCode === 0 ? 0 : EXIT_USAGE;
   }
   if (error62 instanceof CliError) {
-    io.writeErr(`claude-use: ${error62.message}`);
+    io.writeErr(`agent-shim: ${error62.message}`);
     return error62.exitCode;
   }
   const message = error62 instanceof Error ? error62.message : String(error62);
-  io.writeErr(`claude-use: ${message}`);
+  io.writeErr(`agent-shim: ${message}`);
   if (error62 instanceof Error && error62.stack !== void 0 && debugEnabled(io.env)) {
     io.writeErr(error62.stack);
   }
   return EXIT_FAILURE;
 }
 function debugEnabled(env) {
-  return env.CLAUDE_USE_DEBUG !== void 0 && parseBoolWord(env.CLAUDE_USE_DEBUG) === true;
+  return env.AGENT_SHIM_DEBUG !== void 0 && parseBoolWord(env.AGENT_SHIM_DEBUG) === true;
 }
 
 // src/claudeShim.ts
@@ -54890,7 +54890,7 @@ var import_node_crypto = require("node:crypto");
 
 // src/config/load.ts
 var import_cosmiconfig = __toESM(require_dist(), 1);
-function createExplorer(moduleName = "claude-use") {
+function createExplorer(moduleName = "agent-shim") {
   return (0, import_cosmiconfig.cosmiconfigSync)(moduleName, { searchPlaces: [] });
 }
 function isRecord(value) {
@@ -55135,7 +55135,7 @@ function expandAllCategoryKey(pairs) {
   if (all === void 0) {
     return { ...rest };
   }
-  const expanded = Object.fromEntries(OVERRIDABLE_CATEGORIES.map((category) => [category, all]));
+  const expanded = Object.fromEntries(OVERRIDABLE_CATEGORIES.filter((category) => !all || category !== "runtime").map((category) => [category, all]));
   return { ...expanded, ...rest };
 }
 var CategoryMapSchema = external_exports.strictObject({
@@ -55209,7 +55209,7 @@ var CredentialSchema = external_exports.strictObject({
 var ProviderCredentialSchema = CredentialSchema.extend({ target: external_exports.enum(PROVIDER_CREDENTIAL_TARGETS).optional() });
 var RESERVED_PROVIDER_ENV_KEYS = Object.values(CREDENTIAL_TARGET_VARS);
 var ProviderEnvSchema = external_exports.record(external_exports.string().min(1), external_exports.string()).refine((env) => !Object.keys(env).some((key) => RESERVED_PROVIDER_ENV_KEYS.includes(key)), {
-  message: `env may not set ${RESERVED_PROVIDER_ENV_KEYS.join(", ")}: the credential block's target sets one and claude-use removes the others`
+  message: `env may not set ${RESERVED_PROVIDER_ENV_KEYS.join(", ")}: the credential block's target sets one and agent-shim removes the others`
 });
 var PROVIDER_KINDS = ["http", "codex"];
 var CODEX_TIERS = ["fable", "opus", "sonnet", "haiku"];
@@ -55399,16 +55399,16 @@ function parseJson(raw, schema) {
   const parsed = schema.safeParse(JSON.parse(raw));
   return parsed.success ? parsed.data : void 0;
 }
-function readHeadroomState(fs16, stateFile) {
+function readHeadroomState(fs17, stateFile) {
   try {
-    return parseJson(fs16.readFileUtf8(stateFile), HeadroomStateSchema);
+    return parseJson(fs17.readFileUtf8(stateFile), HeadroomStateSchema);
   } catch {
     return void 0;
   }
 }
-function writeHeadroomState(fs16, stateFile, state) {
-  fs16.mkdirp(import_node_path5.default.dirname(stateFile));
-  fs16.writeFilePrivate(stateFile, `${JSON.stringify(state, null, 2)}
+function writeHeadroomState(fs17, stateFile, state) {
+  fs17.mkdirp(import_node_path5.default.dirname(stateFile));
+  fs17.writeFilePrivate(stateFile, `${JSON.stringify(state, null, 2)}
 `);
 }
 function headroomAllowlist(providers) {
@@ -55428,14 +55428,14 @@ function headroomUpstreams(providers, frontDoorOrigin2) {
 function hashAllowlist(allowlist) {
   return (0, import_node_crypto2.createHash)("sha256").update(allowlist.join("\n")).digest("hex");
 }
-function readAllProviders(fs16, providersDir) {
+function readAllProviders(fs17, providersDir) {
   const result = [];
-  for (const name of fs16.readdir(providersDir)) {
+  for (const name of fs17.readdir(providersDir)) {
     if (!name.endsWith(".json")) {
       continue;
     }
     try {
-      const parsed = parseJson(fs16.readFileUtf8(import_node_path5.default.join(providersDir, name)), ProviderSchema);
+      const parsed = parseJson(fs17.readFileUtf8(import_node_path5.default.join(providersDir, name)), ProviderSchema);
       if (parsed !== void 0) {
         result.push({ name: name.slice(0, -".json".length), provider: parsed });
       }
@@ -55445,22 +55445,22 @@ function readAllProviders(fs16, providersDir) {
   }
   return result;
 }
-function writeSession(fs16, sessionsDir, session) {
-  fs16.mkdirp(sessionsDir);
-  fs16.writeFileUtf8(import_node_path5.default.join(sessionsDir, `${String(session.pid)}.json`), `${JSON.stringify(session, null, 2)}
+function writeSession(fs17, sessionsDir, session) {
+  fs17.mkdirp(sessionsDir);
+  fs17.writeFileUtf8(import_node_path5.default.join(sessionsDir, `${String(session.pid)}.json`), `${JSON.stringify(session, null, 2)}
 `);
 }
-function removeSession(fs16, sessionsDir, pid) {
-  fs16.removeRecursive(import_node_path5.default.join(sessionsDir, `${String(pid)}.json`));
+function removeSession(fs17, sessionsDir, pid) {
+  fs17.removeRecursive(import_node_path5.default.join(sessionsDir, `${String(pid)}.json`));
 }
-function listSessions(fs16, sessionsDir) {
+function listSessions(fs17, sessionsDir) {
   const sessions = [];
-  for (const name of fs16.readdir(sessionsDir)) {
+  for (const name of fs17.readdir(sessionsDir)) {
     if (!name.endsWith(".json")) {
       continue;
     }
     try {
-      const parsed = parseJson(fs16.readFileUtf8(import_node_path5.default.join(sessionsDir, name)), HeadroomSessionSchema);
+      const parsed = parseJson(fs17.readFileUtf8(import_node_path5.default.join(sessionsDir, name)), HeadroomSessionSchema);
       if (parsed !== void 0) {
         sessions.push(parsed);
       }
@@ -55470,22 +55470,22 @@ function listSessions(fs16, sessionsDir) {
   }
   return sessions.sort((a2, b) => a2.pid - b.pid);
 }
-function sessionsForSupervisor(fs16, sessionsDir, supervisorPid) {
-  return listSessions(fs16, sessionsDir).filter((session) => session.supervisorPid === supervisorPid);
+function sessionsForSupervisor(fs17, sessionsDir, supervisorPid) {
+  return listSessions(fs17, sessionsDir).filter((session) => session.supervisorPid === supervisorPid);
 }
-function pruneDeadSessions(fs16, sessionsDir, isRunning) {
+function pruneDeadSessions(fs17, sessionsDir, isRunning) {
   const removed = [];
-  for (const session of listSessions(fs16, sessionsDir)) {
+  for (const session of listSessions(fs17, sessionsDir)) {
     if (!isRunning(session.pid)) {
-      removeSession(fs16, sessionsDir, session.pid);
+      removeSession(fs17, sessionsDir, session.pid);
       removed.push(session.pid);
     }
   }
   return removed;
 }
-function readStartLock(fs16, lockFile) {
+function readStartLock(fs17, lockFile) {
   try {
-    return parseJson(fs16.readFileUtf8(lockFile), HeadroomLockSchema);
+    return parseJson(fs17.readFileUtf8(lockFile), HeadroomLockSchema);
   } catch {
     return void 0;
   }
@@ -55514,7 +55514,7 @@ function ensureHeadroom(params) {
       }
       if (state.lastError !== void 0) {
         throw new HeadroomStartError(
-          `claude-use: the headroom daemon reported a fatal error and is not serving: ${state.lastError} (daemon log: ${paths.headroomLogPath})`
+          `agent-shim: the headroom daemon reported a fatal error and is not serving: ${state.lastError} (daemon log: ${paths.headroomLogPath})`
         );
       }
     } else if (!spawnedSupervisor) {
@@ -55538,7 +55538,7 @@ function ensureHeadroom(params) {
     if (ports.now() >= deadline) {
       const lastError = state?.lastError;
       throw new HeadroomStartError(
-        `claude-use: the headroom daemon did not become ready within ${String(HEADROOM_START_TIMEOUT_MS)}ms` + (lastError === void 0 ? "" : ` (last error: ${lastError})`) + `. Daemon log: ${paths.headroomLogPath}`
+        `agent-shim: the headroom daemon did not become ready within ${String(HEADROOM_START_TIMEOUT_MS)}ms` + (lastError === void 0 ? "" : ` (last error: ${lastError})`) + `. Daemon log: ${paths.headroomLogPath}`
       );
     }
     ports.sleep(HEADROOM_LAUNCHER_POLL_MS);
@@ -55780,7 +55780,7 @@ function spawnDetachedSupervisor(paths, subcommand, logPath) {
   const logFd = import_node_fs3.default.openSync(logPath, "a");
   try {
     const invocation = selfInvocation([subcommand]);
-    const child = (0, import_node_child_process2.spawn)(invocation.command, invocation.args, detachedDaemonSpawnOptions(logFd, { ...process.env, CLAUDE_USE_HOME: paths.root }));
+    const child = (0, import_node_child_process2.spawn)(invocation.command, invocation.args, detachedDaemonSpawnOptions(logFd, { ...process.env, AGENT_SHIM_HOME: paths.root }));
     child.unref();
     if (child.pid === void 0) {
       throw new Error(`spawning ${subcommand} returned no pid`);
@@ -55974,7 +55974,7 @@ var ClaudeShimStateSchema = external_exports.strictObject({
 var ForeignClaudeEntryError = class extends CliError {
   constructor(targetPath, action) {
     super(
-      `${targetPath} already exists and does not look like something claude-use created. Refusing to ${action === "enable" ? "overwrite" : "remove"} it automatically \u2014 inspect it yourself, or pass --force if you're sure.`
+      `${targetPath} already exists and does not look like something agent-shim created. Refusing to ${action === "enable" ? "overwrite" : "remove"} it automatically \u2014 inspect it yourself, or pass --force if you're sure.`
     );
     this.targetPath = targetPath;
     this.action = action;
@@ -55986,7 +55986,7 @@ var ForeignClaudeEntryError = class extends CliError {
 var UnsupportedShimSourceError = class extends CliError {
   constructor(contentSourcePath) {
     super(
-      `Cannot create a working \`claude\` command from ${contentSourcePath} on Windows: an npm-installed claude-use running under Node.js has no .exe to hardlink/copy, and Windows has no shebang-based dispatch the way POSIX does. Install claude-use via Scoop instead (see README), which ships a real claude-use.exe this command can link from.`
+      `Cannot create a working \`claude\` command from ${contentSourcePath} on Windows: an npm-installed agent-shim running under Node.js has no .exe to hardlink/copy, and Windows has no shebang-based dispatch the way POSIX does. Install agent-shim via Scoop instead (see README), which ships a real agent-shim.exe this command can link from.`
     );
     this.contentSourcePath = contentSourcePath;
     this.name = "UnsupportedShimSourceError";
@@ -56100,11 +56100,11 @@ function registerShimCommand(program2, deps) {
   const { paths } = deps;
   const shim = withExamples(
     program2.command("shim").description(
-      "Manage the `claude` command shim: an optional, explicit way to also invoke this launcher as `claude` instead of `claude-use run`. Off by default; every installer ships only `claude-use`."
+      "Manage the `claude` command shim: an optional, explicit way to also invoke this launcher as `claude` instead of `agent-shim run`. Off by default; every installer ships only `agent-shim`."
     ),
-    ["claude-use shim enable", "claude-use shim disable"]
+    ["agent-shim shim enable", "agent-shim shim disable"]
   );
-  const enable = shim.command("enable").description("Create a `claude`-named copy of this same executable, alongside claude-use by default.").option("--dir <path>", "Enable into this directory instead of alongside the running claude-use executable.").option("--force", "Overwrite the target even if it doesn't look like claude-use's own doing.").action((options) => {
+  const enable = shim.command("enable").description("Create a `claude`-named copy of this same executable, alongside agent-shim by default.").option("--dir <path>", "Enable into this directory instead of alongside the running agent-shim executable.").option("--force", "Overwrite the target even if it doesn't look like agent-shim's own doing.").action((options) => {
     const ownExecutablePath = realOwnExecutablePath();
     const contentSourcePath = realContentSourcePath();
     const result = enableClaudeShim({
@@ -56123,15 +56123,15 @@ function registerShimCommand(program2, deps) {
       findExecutableInDir
     });
     if (shadow.status === "not-on-path") {
-      console.warn(`warning: ${import_node_path7.default.dirname(result.targetPath)} is not on PATH \u2014 add it, or use \`claude-use run\` instead.`);
+      console.warn(`warning: ${import_node_path7.default.dirname(result.targetPath)} is not on PATH \u2014 add it, or use \`agent-shim run\` instead.`);
     } else if (shadow.status === "shadowed") {
       console.warn(
         `warning: 'claude' on PATH currently resolves to ${shadow.by}, not ${result.targetPath}. Put ${import_node_path7.default.dirname(result.targetPath)} ahead of it on PATH.`
       );
     }
   });
-  withExamples(enable, ["claude-use shim enable", "claude-use shim enable --dir ~/bin"]);
-  const disable = shim.command("disable").description("Remove the `claude` command shim `shim enable` previously created. A no-op, not an error, if none is enabled.").option("--dir <path>", "Look in this directory instead of trusting the recorded location.").option("--force", "Remove the target even if it doesn't look like claude-use's own doing.").action((options) => {
+  withExamples(enable, ["agent-shim shim enable", "agent-shim shim enable --dir ~/bin"]);
+  const disable = shim.command("disable").description("Remove the `claude` command shim `shim enable` previously created. A no-op, not an error, if none is enabled.").option("--dir <path>", "Look in this directory instead of trusting the recorded location.").option("--force", "Remove the target even if it doesn't look like agent-shim's own doing.").action((options) => {
     const ownExecutablePath = realOwnExecutablePath();
     const contentSourcePath = realContentSourcePath();
     const result = disableClaudeShim({
@@ -56145,11 +56145,37 @@ function registerShimCommand(program2, deps) {
       result.action === "disabled" ? `Removed \`claude\` at ${result.targetPath}.` : `No \`claude\` command enabled at ${result.targetPath}; nothing to do.`
     );
   });
-  withExamples(disable, ["claude-use shim disable"]);
+  withExamples(disable, ["agent-shim shim disable"]);
+}
+
+// src/legacy.ts
+var ENV_PREFIX = "AGENT_SHIM_";
+var LEGACY_ENV_PREFIX = "CLAUDE_USE_";
+var HOME_DIRNAME = ".agent-shim";
+var LEGACY_HOME_DIRNAME = ".claude-use";
+var LEGACY_PORTABLE_CONFIG_FILENAME = ".claude-use.json";
+var LEGACY_PORTABLE_LOCAL_CONFIG_FILENAME = ".claude-use.local.json";
+var LEGACY_FARM_MANIFEST_FILENAME = ".claude-use-farm.json";
+var LEGACY_COMMAND_NAME = "claude-use";
+function aliasLegacyEnv(env) {
+  const aliased = [];
+  for (const name of Object.keys(env).sort()) {
+    if (!name.startsWith(LEGACY_ENV_PREFIX)) {
+      continue;
+    }
+    const value = env[name];
+    const current = `${ENV_PREFIX}${name.slice(LEGACY_ENV_PREFIX.length)}`;
+    if (value === void 0 || env[current] !== void 0) {
+      continue;
+    }
+    env[current] = value;
+    aliased.push(name);
+  }
+  return aliased;
 }
 
 // src/configure.ts
-var import_node_fs7 = __toESM(require("node:fs"), 1);
+var import_node_fs8 = __toESM(require("node:fs"), 1);
 var import_node_os4 = __toESM(require("node:os"), 1);
 var import_node_path19 = __toESM(require("node:path"), 1);
 
@@ -57469,7 +57495,7 @@ function collectCredentialSource(value, previous = []) {
 }
 function addCredentialCacheOptions(command) {
   return command.option("--credential-cache-ttl <ttl>", "Keep the resolved credential for this long (a whole number and s, m, h or d, for example 12h) so a launch need not re-run a source that needs a person. Enables caching.").addOption(
-    new Option("--credential-cache-store <store>", "Where the cached credential is kept: keychain (macOS login Keychain, the default there) or file (mode 0600 under the claude-use home, the default elsewhere). Enables caching.").choices(
+    new Option("--credential-cache-store <store>", "Where the cached credential is kept: keychain (macOS login Keychain, the default there) or file (mode 0600 under the agent-shim home, the default elsewhere). Enables caching.").choices(
       CREDENTIAL_CACHE_STORES
     )
   ).option("--credential-cache", "Cache this credential in the default store with no expiry (add --credential-cache-ttl for one).").option("--no-credential-cache", "Stop caching this credential. Run `credential forget` first to drop the stored copy.");
@@ -57646,7 +57672,7 @@ function trySource(source, params) {
 }
 function warmCommandFor(subject) {
   const [kind, name] = subject.split(" ");
-  return kind === "provider" ? `claude-use credential warm --provider ${name ?? ""}` : `claude-use credential warm ${name ?? ""}`;
+  return kind === "provider" ? `agent-shim credential warm --provider ${name ?? ""}` : `agent-shim credential warm ${name ?? ""}`;
 }
 function resolveCredential(params) {
   const target = params.credential.target ?? "bearer";
@@ -57672,11 +57698,11 @@ function resolveCredential(params) {
     const line = `${describeSource(source)} ${outcome.reason}`;
     attempts.push(line);
     if (outcome.warn) {
-      warnings.push(`claude-use: ${params.subject}: skipped ${line}`);
+      warnings.push(`agent-shim: ${params.subject}: skipped ${line}`);
     }
   }
   const hint = cacheBlock === void 0 ? "" : `; fill the cache from a terminal with \`${warmCommandFor(params.subject)}\``;
-  return { ok: false, message: `claude-use: ${params.subject} has no usable credential: ${attempts.join("; ")}${hint}` };
+  return { ok: false, message: `agent-shim: ${params.subject} has no usable credential: ${attempts.join("; ")}${hint}` };
 }
 function credentialVariables(target, token) {
   return {
@@ -58248,7 +58274,7 @@ function resolveEntry(relPath, params) {
     diagnostics.push({
       code: "UNCLASSIFIED_ENTRY",
       severity: "warning",
-      message: `"${head}" is not in the category map, so it is excluded. Run \`claude-use configure\` to classify it, which records the answer in the local overlay without touching the shipped default map.`,
+      message: `"${head}" is not in the category map, so it is excluded. Run \`agent-shim configure\` to classify it, which records the answer in the local overlay without touching the shipped default map.`,
       subject: head
     });
     return { decision: { relPath, shared: false, via: "unclassified", category }, diagnostics };
@@ -58664,7 +58690,7 @@ var DEFAULT_MAX_ATTEMPTS = 200;
 var IdentityLockBusyError = class extends CliError {
   constructor(identity, lockPath, holderPid) {
     super(
-      `Another claude-use resync is already running for identity "${identity}"` + (holderPid === void 0 ? "" : ` (pid ${String(holderPid)})`) + `. Its lock at ${lockPath} was still held after the full retry budget; nothing was changed.`
+      `Another agent-shim resync is already running for identity "${identity}"` + (holderPid === void 0 ? "" : ` (pid ${String(holderPid)})`) + `. Its lock at ${lockPath} was still held after the full retry budget; nothing was changed.`
     );
     this.identity = identity;
     this.lockPath = lockPath;
@@ -58743,7 +58769,7 @@ function acquireIdentityLock(params) {
 }
 
 // src/launcher/farm.ts
-var FARM_MANIFEST_FILENAME = ".claude-use-farm.json";
+var FARM_MANIFEST_FILENAME = ".agent-shim-farm.json";
 var FarmManifestSchema = external_exports.strictObject({
   version: external_exports.literal(1),
   builtAtMs: external_exports.number(),
@@ -58754,8 +58780,8 @@ var FarmManifestSchema = external_exports.strictObject({
   materialised: external_exports.array(external_exports.string()),
   links: external_exports.array(external_exports.strictObject({ rel: external_exports.string(), target: external_exports.string() }))
 });
-function readFarmManifest(fs16, farmRoot) {
-  const raw = fs16.readFileUtf8(import_node_path11.default.join(farmRoot, FARM_MANIFEST_FILENAME));
+function readFarmManifest(fs17, farmRoot) {
+  const raw = fs17.readFileUtf8(import_node_path11.default.join(farmRoot, FARM_MANIFEST_FILENAME)) ?? fs17.readFileUtf8(import_node_path11.default.join(farmRoot, LEGACY_FARM_MANIFEST_FILENAME));
   if (raw === void 0) {
     return void 0;
   }
@@ -58813,9 +58839,9 @@ function buildEntryFacts(params) {
     entries
   };
 }
-function listSubtree(fs16, root, rel) {
+function listSubtree(fs17, root, rel) {
   const absolute = import_node_path11.default.join(root, rel);
-  const stat = fs16.lstat(absolute);
+  const stat = fs17.lstat(absolute);
   if (stat === void 0) {
     return [];
   }
@@ -58823,10 +58849,10 @@ function listSubtree(fs16, root, rel) {
     return [{ rel, kind: "symlink" }];
   }
   if (stat.kind === "dir") {
-    const children = [...fs16.readdir(absolute)].sort().flatMap((name) => listSubtree(fs16, root, `${rel}/${name}`));
+    const children = [...fs17.readdir(absolute)].sort().flatMap((name) => listSubtree(fs17, root, `${rel}/${name}`));
     return [{ rel, kind: "dir" }, ...children];
   }
-  const contentHash = fs16.hashFile(absolute);
+  const contentHash = fs17.hashFile(absolute);
   return [{ rel, kind: "file", ...contentHash === void 0 ? {} : { contentHash } }];
 }
 function topLevelScopeRoots(roots) {
@@ -58840,25 +58866,25 @@ function topLevelScopeRoots(roots) {
   }
   return kept;
 }
-function reconciliationScope(fs16, farmRoot, manifest) {
+function reconciliationScope(fs17, farmRoot, manifest) {
   if (manifest !== void 0) {
     return topLevelScopeRoots(manifest.materialised);
   }
-  return [...fs16.readdir(farmRoot)].filter((name) => name !== FARM_MANIFEST_FILENAME && fs16.lstat(import_node_path11.default.join(farmRoot, name))?.kind === "dir").sort();
+  return [...fs17.readdir(farmRoot)].filter((name) => name !== FARM_MANIFEST_FILENAME && name !== LEGACY_FARM_MANIFEST_FILENAME && fs17.lstat(import_node_path11.default.join(farmRoot, name))?.kind === "dir").sort();
 }
-function collectFarmListing(fs16, farmRoot, scopeRoots) {
-  return scopeRoots.flatMap((root) => listSubtree(fs16, farmRoot, root));
+function collectFarmListing(fs17, farmRoot, scopeRoots) {
+  return scopeRoots.flatMap((root) => listSubtree(fs17, farmRoot, root));
 }
-function collectCanonicalCounterparts(fs16, claudeHome, farmListing) {
+function collectCanonicalCounterparts(fs17, claudeHome, farmListing) {
   const out = [];
   for (const entry of farmListing) {
     const absolute = import_node_path11.default.join(claudeHome, entry.rel);
-    const stat = fs16.lstat(absolute);
+    const stat = fs17.lstat(absolute);
     if (stat === void 0) {
       continue;
     }
     if (stat.kind === "file") {
-      const contentHash = fs16.hashFile(absolute);
+      const contentHash = fs17.hashFile(absolute);
       out.push({ rel: entry.rel, kind: "file", ...contentHash === void 0 ? {} : { contentHash } });
       continue;
     }
@@ -58868,7 +58894,7 @@ function collectCanonicalCounterparts(fs16, claudeHome, farmListing) {
 }
 function carryOver(params) {
   const manifest = readFarmManifest(params.fs, params.previousRoot);
-  const accounted = /* @__PURE__ */ new Set([FARM_MANIFEST_FILENAME]);
+  const accounted = /* @__PURE__ */ new Set([FARM_MANIFEST_FILENAME, LEGACY_FARM_MANIFEST_FILENAME]);
   for (const rel of manifest?.materialised ?? []) {
     const head = rel.split("/")[0];
     if (head !== void 0 && head !== "") {
@@ -59166,7 +59192,7 @@ function resyncFarm(params) {
       diagnostics.push({
         code: "FARM_PREVIOUS_RETAINED",
         severity: "warning",
-        message: `The superseded farm was left at ${swap.retainedPrevious} because it still holds ${swap.collided.join(", ")}, which the new farm has its own entry for. Nothing was overwritten in either direction; run \`claude-use identity resolve-conflicts ${params.identity}\` to resolve it interactively.`,
+        message: `The superseded farm was left at ${swap.retainedPrevious} because it still holds ${swap.collided.join(", ")}, which the new farm has its own entry for. Nothing was overwritten in either direction; run \`agent-shim identity resolve-conflicts ${params.identity}\` to resolve it interactively.`,
         subject: swap.retainedPrevious
       });
     }
@@ -59203,7 +59229,7 @@ function recoveryDiagnostics(recovery, identity) {
   }
   if (recovery.retained.length > 0) {
     parts.push(
-      `kept ${recovery.retained.join(", ")}, which still holds data the current farm also has an entry for \u2014 run \`claude-use identity resolve-conflicts ${identity}\` to resolve it interactively`
+      `kept ${recovery.retained.join(", ")}, which still holds data the current farm also has an entry for \u2014 run \`agent-shim identity resolve-conflicts ${identity}\` to resolve it interactively`
     );
   }
   return [
@@ -59348,7 +59374,7 @@ function parseDurationOption(value) {
 // src/configProfiles.ts
 var ProfileNotFoundError = class extends CliError {
   constructor(profileName) {
-    super(`No configuration profile named "${profileName}". Run \`claude-use profile add ${profileName}\` first.`);
+    super(`No configuration profile named "${profileName}". Run \`agent-shim profile add ${profileName}\` first.`);
     this.profileName = profileName;
     this.name = "ProfileNotFoundError";
   }
@@ -59535,7 +59561,7 @@ function registerProfileCommand(program2, deps) {
   const { paths } = deps;
   const profile = withExamples(
     program2.command("profile").description("Manage configuration profiles: named, reusable rules for what an identity shares with ~/.claude."),
-    ["claude-use profile add client-acme", "claude-use profile list"]
+    ["agent-shim profile add client-acme", "agent-shim profile list"]
   );
   withExamples(
     profile.command("add [name]").description(
@@ -59556,7 +59582,7 @@ function registerProfileCommand(program2, deps) {
       createProfile(paths, name, options.extends, options.description);
       console.log(`Created configuration profile "${name}".`);
     }),
-    ["claude-use profile add client-acme", "claude-use profile add client-acme --extends work-default --extends strict"]
+    ["agent-shim profile add client-acme", "agent-shim profile add client-acme --extends work-default --extends strict"]
   );
   withExamples(
     profile.command("set <name>").description(
@@ -59578,9 +59604,9 @@ function registerProfileCommand(program2, deps) {
       console.log(`Updated configuration profile "${name}".`);
     }),
     [
-      "claude-use profile set client-acme --category history=false --category knowledge=true",
-      'claude-use profile set client-acme --entry "knowledge/skills/commit=false"',
-      "claude-use profile set client-acme --launch-headroom --launch-provider z"
+      "agent-shim profile set client-acme --category history=false --category knowledge=true",
+      'agent-shim profile set client-acme --entry "knowledge/skills/commit=false"',
+      "agent-shim profile set client-acme --launch-headroom --launch-provider z"
     ]
   );
   withExamples(
@@ -59592,7 +59618,7 @@ function registerProfileCommand(program2, deps) {
         return;
       }
       if (entries.length === 0) {
-        console.log("No configuration profiles yet. Run `claude-use profile add <name>` to create one.");
+        console.log("No configuration profiles yet. Run `agent-shim profile add <name>` to create one.");
         return;
       }
       for (const entry of entries) {
@@ -59601,7 +59627,7 @@ function registerProfileCommand(program2, deps) {
         console.log(`${marker}${entry.name}${extendsSuffix}`);
       }
     }),
-    ["claude-use profile list", "claude-use profile list --json"]
+    ["agent-shim profile list", "agent-shim profile list --json"]
   );
   withExamples(
     profile.command("show <name>").description("Show one configuration profile's contents.").option("--json", "Print the profile as JSON.").action((name, options) => {
@@ -59628,16 +59654,16 @@ function registerProfileCommand(program2, deps) {
         console.log(`${label}: ${pairs.length === 0 ? "(none)" : pairs.map(([key, setting]) => `${key}=${JSON.stringify(setting)}`).join(", ")}`);
       }
     }),
-    ["claude-use profile show client-acme", "claude-use profile show client-acme --json"]
+    ["agent-shim profile show client-acme", "agent-shim profile show client-acme --json"]
   );
   withExamples(
-    profile.command("remove <name>").description("Delete a configuration profile's file. References to it by name are left for `claude-use doctor` to report.").option("--yes", "Remove without asking for confirmation (required when standard input is not a terminal).").action(async (name, options) => {
+    profile.command("remove <name>").description("Delete a configuration profile's file. References to it by name are left for `agent-shim doctor` to report.").option("--yes", "Remove without asking for confirmation (required when standard input is not a terminal).").action(async (name, options) => {
       requireProfileExists(paths, name);
       await confirmRemoval(deps, options.yes, `configuration profile "${name}"`);
       removeProfile(paths, name);
       console.log(`Removed configuration profile "${name}".`);
     }),
-    ["claude-use profile remove client-acme --yes"]
+    ["agent-shim profile remove client-acme --yes"]
   );
   withExamples(
     profile.command("use <name>").description("Make a configuration profile the global default, used when no directory rule or identity selects one.").action(async (name) => {
@@ -59645,7 +59671,7 @@ function registerProfileCommand(program2, deps) {
       setGlobalDefaultProfile(paths, name);
       console.log(`Global default configuration profile is now "${name}".`);
     }),
-    ["claude-use profile use work-default"]
+    ["agent-shim profile use work-default"]
   );
 }
 
@@ -59668,8 +59694,8 @@ function decideIdentity(params) {
   if (isNonEmpty(params.argv0Identity)) {
     return selected(params.argv0Identity, "argv");
   }
-  if (isNonEmpty(params.env.CLAUDE_USE_IDENTITY)) {
-    return selected(params.env.CLAUDE_USE_IDENTITY, "env");
+  if (isNonEmpty(params.env.AGENT_SHIM_IDENTITY)) {
+    return selected(params.env.AGENT_SHIM_IDENTITY, "env");
   }
   if (isNonEmpty(params.directoryPinnedIdentity)) {
     return selected(params.directoryPinnedIdentity, "directory-pin");
@@ -59684,8 +59710,8 @@ function decideConfigProfile(params) {
   if (isNonEmpty(params.cliFlagConfigProfile)) {
     return { name: params.cliFlagConfigProfile, source: "cli-flag" };
   }
-  if (isNonEmpty(params.env.CLAUDE_USE_CONFIG_PROFILE)) {
-    return { name: params.env.CLAUDE_USE_CONFIG_PROFILE, source: "env" };
+  if (isNonEmpty(params.env.AGENT_SHIM_CONFIG_PROFILE)) {
+    return { name: params.env.AGENT_SHIM_CONFIG_PROFILE, source: "env" };
   }
   if (isNonEmpty(params.directoryRuleConfigProfile)) {
     return { name: params.directoryRuleConfigProfile, source: "directory-rule" };
@@ -59698,14 +59724,14 @@ function decideConfigProfile(params) {
   }
   return { source: "none" };
 }
-function loadIdentity(identitiesDir, name, fs16) {
-  return loadConfigFile(import_node_path14.default.join(identitiesDir, name, "identity.json"), IdentitySchema, fs16.readConfigFile);
+function loadIdentity(identitiesDir, name, fs17) {
+  return loadConfigFile(import_node_path14.default.join(identitiesDir, name, "identity.json"), IdentitySchema, fs17.readConfigFile);
 }
 
 // src/poolStore.ts
 var PoolNotFoundError = class extends CliError {
   constructor(poolName) {
-    super(`No pool named "${poolName}". Run \`claude-use pool add ${poolName} --identity <name>...\` first.`);
+    super(`No pool named "${poolName}". Run \`agent-shim pool add ${poolName} --identity <name>...\` first.`);
     this.poolName = poolName;
     this.name = "PoolNotFoundError";
   }
@@ -59713,7 +59739,7 @@ var PoolNotFoundError = class extends CliError {
 };
 var PoolAlreadyExistsError = class extends CliError {
   constructor(poolName) {
-    super(`A pool named "${poolName}" already exists. Use \`claude-use pool set ${poolName}\` to change its members.`);
+    super(`A pool named "${poolName}" already exists. Use \`agent-shim pool set ${poolName}\` to change its members.`);
     this.poolName = poolName;
     this.name = "PoolAlreadyExistsError";
   }
@@ -59767,7 +59793,7 @@ function removePool(paths, name) {
 // src/identityManager.ts
 var IdentityNotFoundError = class extends CliError {
   constructor(name) {
-    super(`No identity named "${name}". Run \`claude-use identity add ${name}\` first.`);
+    super(`No identity named "${name}". Run \`agent-shim identity add ${name}\` first.`);
     this.name = name;
     this.name = "IdentityNotFoundError";
   }
@@ -59995,14 +60021,14 @@ function registerIdentityCommand(program2, deps) {
   const { paths } = deps;
   const identity = withExamples(
     program2.command("identity").description("Manage identities: each one is a separate Claude Code login with its own credentials."),
-    ["claude-use identity add work", "claude-use identity list"]
+    ["agent-shim identity add work", "agent-shim identity list"]
   );
   withExamples(
     identity.command("add <name>").description("Create a new identity. Fails if one with this name already exists.").action((name) => {
       addIdentity(paths, name);
       console.log(`Created identity "${name}".`);
     }),
-    ["claude-use identity add work"]
+    ["agent-shim identity add work"]
   );
   withExamples(
     identity.command("list").description("List every identity, marking the active one with *.").option("--json", "Print the identities as JSON.").action((options) => {
@@ -60012,17 +60038,17 @@ function registerIdentityCommand(program2, deps) {
         return;
       }
       if (entries.length === 0) {
-        console.log("No identities yet. Run `claude-use identity add <name>` to create one.");
+        console.log("No identities yet. Run `agent-shim identity add <name>` to create one.");
         return;
       }
       for (const entry of entries) {
         console.log(formatIdentityLine(entry));
       }
       if (entries.some((entry) => entry.problem !== void 0)) {
-        console.log("\nRun `claude-use doctor` for the full detail on every unreadable entry.");
+        console.log("\nRun `agent-shim doctor` for the full detail on every unreadable entry.");
       }
     }),
-    ["claude-use identity list", "claude-use identity list --json"]
+    ["agent-shim identity list", "agent-shim identity list --json"]
   );
   withExamples(
     identity.command("show <name>").description("Show one identity's settings and directory.").option("--json", "Print the identity as JSON.").action((name, options) => {
@@ -60045,7 +60071,7 @@ function registerIdentityCommand(program2, deps) {
       console.log(`Allows ambient credential: ${view.allowAmbientCredential === true ? "yes" : "no"}`);
       console.log(`Credential: ${entry.identity?.credential === void 0 ? "(none; uses its stored login)" : describeCredential(entry.identity.credential)}`);
     }),
-    ["claude-use identity show work", "claude-use identity show work --json"]
+    ["agent-shim identity show work", "agent-shim identity show work --json"]
   );
   const identitySet = identity.command("set <name>").description("Update an identity's settings.").option("--default-profile <profile>", "Configuration profile this identity uses when nothing more specific selects one.").option("--no-default-profile", "Clear this identity's default configuration profile.").option("--allow-ambient-credential", "Allow this identity to launch even with an ambient credential env var set.").option("--no-allow-ambient-credential", "Disallow ambient credential env vars for this identity (the default).").option(
     "--credential <source>",
@@ -60100,10 +60126,10 @@ function registerIdentityCommand(program2, deps) {
       }
     }),
     [
-      "claude-use identity set work --default-profile client-acme",
-      "claude-use identity set work --allow-ambient-credential",
-      "claude-use identity set work --credential-target oauthToken --credential op:op://vault/claude-work/token",
-      "claude-use identity set work --no-credential"
+      "agent-shim identity set work --default-profile client-acme",
+      "agent-shim identity set work --allow-ambient-credential",
+      "agent-shim identity set work --credential-target oauthToken --credential op:op://vault/claude-work/token",
+      "agent-shim identity set work --no-credential"
     ]
   );
   withExamples(
@@ -60117,13 +60143,13 @@ function registerIdentityCommand(program2, deps) {
       removeIdentity(paths, name);
       console.log(`Removed identity "${name}".`);
     }),
-    ["claude-use identity remove old-client --yes"]
+    ["agent-shim identity remove old-client --yes"]
   );
   withExamples(
     identity.command("use <name>").description("Select the active identity, used by every launch that names none. Offers to create it on a terminal if it does not exist.").action(async (name) => {
       await selectIdentity(deps, name);
     }),
-    ["claude-use identity use work", "claude-use @work"]
+    ["agent-shim identity use work", "agent-shim @work"]
   );
   withExamples(
     identity.command("resolve-conflicts <name>").description("Interactively resolve data a superseded farm left behind when it collides with the current farm's copy.").action(async (name) => {
@@ -60162,7 +60188,7 @@ function registerIdentityCommand(program2, deps) {
         `Resolved ${String(result.resolved.length)} conflict(s): ${String(result.removed.length)} superseded director(ies) fully cleared, ${String(result.retained.length)} still retained pending a skipped conflict.`
       );
     }),
-    ["claude-use identity resolve-conflicts work"]
+    ["agent-shim identity resolve-conflicts work"]
   );
 }
 
@@ -60183,7 +60209,7 @@ var DirectoryRuleMissingTargetError = class extends CliError {
 };
 var DirectoryRuleAlreadyExistsError = class extends CliError {
   constructor(rulePath) {
-    super(`A directory rule for path "${rulePath}" already exists. Use \`claude-use rule set\` to change it.`);
+    super(`A directory rule for path "${rulePath}" already exists. Use \`agent-shim rule set\` to change it.`);
     this.rulePath = rulePath;
     this.name = "DirectoryRuleAlreadyExistsError";
   }
@@ -60271,7 +60297,7 @@ function registerRuleCommand(program2, deps) {
   const { paths } = deps;
   const rule = withExamples(
     program2.command("rule").description("Manage directory rules: pin an identity or configuration profile to every launch under a path."),
-    ["claude-use rule add ~/work/acme --config-profile client-acme", "claude-use rule list"]
+    ["agent-shim rule add ~/work/acme --config-profile client-acme", "agent-shim rule list"]
   );
   withExamples(
     rule.command("add <path>").description("Add a directory rule for a path. Fails if a rule for that exact path already exists.").option("--config-profile <profile>", "Configuration profile to select under this path.").option("--identity <identity>", "Identity to pin under this path.").action(async (rulePath, options) => {
@@ -60279,7 +60305,7 @@ function registerRuleCommand(program2, deps) {
       addDirectoryRule(paths, rulePath, options);
       console.log(`Added directory rule for "${rulePath}".`);
     }),
-    ["claude-use rule add ~/work/acme --config-profile client-acme", "claude-use rule add ~/personal --identity personal"]
+    ["agent-shim rule add ~/work/acme --config-profile client-acme", "agent-shim rule add ~/personal --identity personal"]
   );
   withExamples(
     rule.command("set <path>").description("Update the directory rule for a path.").option("--config-profile <profile>", "Configuration profile to select under this path.").option("--no-config-profile", "Stop selecting a configuration profile under this path.").option("--identity <identity>", "Identity to pin under this path.").option("--no-identity", "Stop pinning an identity under this path.").action(async (rulePath, options) => {
@@ -60290,7 +60316,7 @@ function registerRuleCommand(program2, deps) {
       updateDirectoryRule(paths, rulePath, options);
       console.log(`Updated directory rule for "${rulePath}".`);
     }),
-    ["claude-use rule set ~/work/acme --identity work", "claude-use rule set ~/work/acme --no-config-profile"]
+    ["agent-shim rule set ~/work/acme --identity work", "agent-shim rule set ~/work/acme --no-config-profile"]
   );
   withExamples(
     rule.command("list").description("List every directory rule, in file order.").option("--json", "Print the rules as JSON.").action((options) => {
@@ -60300,14 +60326,14 @@ function registerRuleCommand(program2, deps) {
         return;
       }
       if (entries.length === 0) {
-        console.log("No directory rules yet. Run `claude-use rule add <path>` to create one.");
+        console.log("No directory rules yet. Run `agent-shim rule add <path>` to create one.");
         return;
       }
       for (const entry of entries) {
         console.log(`  ${entry.path} (${describeRule(entry)})`);
       }
     }),
-    ["claude-use rule list", "claude-use rule list --json"]
+    ["agent-shim rule list", "agent-shim rule list --json"]
   );
   withExamples(
     rule.command("show <path>").description("Show the directory rule for a path, matched exactly as it was written.").option("--json", "Print the rule as JSON.").action((rulePath, options) => {
@@ -60322,7 +60348,7 @@ function registerRuleCommand(program2, deps) {
       console.log(`Directory rule: ${found.path}`);
       console.log(`Settings: ${describeRule(found)}`);
     }),
-    ["claude-use rule show ~/work/acme"]
+    ["agent-shim rule show ~/work/acme"]
   );
   withExamples(
     rule.command("remove <path>").description("Remove the directory rule for a path.").option("--yes", "Remove without asking for confirmation (required when standard input is not a terminal).").action(async (rulePath, options) => {
@@ -60333,7 +60359,7 @@ function registerRuleCommand(program2, deps) {
       removeDirectoryRule(paths, rulePath);
       console.log(`Removed directory rule for "${rulePath}".`);
     }),
-    ["claude-use rule remove ~/work/acme --yes"]
+    ["agent-shim rule remove ~/work/acme --yes"]
   );
 }
 
@@ -60363,8 +60389,8 @@ function isAncestorOrSelf(ancestor, descendant) {
 }
 
 // src/launcher/cascade.ts
-var PORTABLE_CONFIG_FILENAME = ".claude-use.json";
-var PORTABLE_LOCAL_CONFIG_FILENAME = ".claude-use.local.json";
+var PORTABLE_CONFIG_FILENAME = ".agent-shim.json";
+var PORTABLE_LOCAL_CONFIG_FILENAME = ".agent-shim.local.json";
 function loadCascadeInput(params) {
   const globalConfig2 = loadConfigFile(params.paths.globalConfigFile, GlobalConfigSchema, params.read);
   const directoryRules = loadConfigFile(params.paths.directoryRulesFile, DirectoryRulesSchema, params.read);
@@ -60384,8 +60410,8 @@ function loadCascadeInput(params) {
   });
   const levels = [];
   for (const dir of dirs) {
-    const portable = loadConfigFile(import_node_path17.default.join(dir, PORTABLE_CONFIG_FILENAME), PortableConfigSchema, params.read);
-    const portableLocal = loadConfigFile(import_node_path17.default.join(dir, PORTABLE_LOCAL_CONFIG_FILENAME), PortableConfigSchema, params.read);
+    const portable = loadConfigFile(import_node_path17.default.join(dir, PORTABLE_CONFIG_FILENAME), PortableConfigSchema, params.read) ?? loadConfigFile(import_node_path17.default.join(dir, LEGACY_PORTABLE_CONFIG_FILENAME), PortableConfigSchema, params.read);
+    const portableLocal = loadConfigFile(import_node_path17.default.join(dir, PORTABLE_LOCAL_CONFIG_FILENAME), PortableConfigSchema, params.read) ?? loadConfigFile(import_node_path17.default.join(dir, LEGACY_PORTABLE_LOCAL_CONFIG_FILENAME), PortableConfigSchema, params.read);
     const rules = (directoryRules?.config.rules ?? []).map((rule, index) => ({ rule, index })).filter(({ rule }) => normaliseRulePath(rule.path, params.home) === dir).map(({ rule, index }) => {
       const entryOrder = directoryRules?.ruleEntryOrders[index];
       return {
@@ -60434,17 +60460,23 @@ function readDirectorySelections(loaded) {
 }
 
 // src/paths.ts
+var import_node_fs7 = __toESM(require("node:fs"), 1);
 var import_node_os3 = __toESM(require("node:os"), 1);
 var import_node_path18 = __toESM(require("node:path"), 1);
-function resolveClaudeUseHome() {
-  const fromEnv = process.env.CLAUDE_USE_HOME;
+function resolveAgentShimHome(env = process.env, home = import_node_os3.default.homedir(), isDirectory = isExistingDirectory) {
+  const fromEnv = env.AGENT_SHIM_HOME;
   if (fromEnv !== void 0 && fromEnv !== "") {
     return fromEnv;
   }
-  return import_node_path18.default.join(import_node_os3.default.homedir(), ".claude-use");
+  const current = import_node_path18.default.join(home, HOME_DIRNAME);
+  const legacy = import_node_path18.default.join(home, LEGACY_HOME_DIRNAME);
+  return !isDirectory(current) && isDirectory(legacy) ? legacy : current;
+}
+function isExistingDirectory(candidate) {
+  return import_node_fs7.default.statSync(candidate, { throwIfNoEntry: false })?.isDirectory() ?? false;
 }
 function resolveClaudeHome() {
-  const fromEnv = process.env.CLAUDE_USE_CLAUDE_HOME;
+  const fromEnv = process.env.AGENT_SHIM_CLAUDE_HOME;
   if (fromEnv !== void 0 && fromEnv !== "") {
     return fromEnv;
   }
@@ -60483,14 +60515,14 @@ function buildLayoutPaths(root) {
   };
 }
 function resolveLayoutPaths() {
-  return buildLayoutPaths(resolveClaudeUseHome());
+  return buildLayoutPaths(resolveAgentShimHome());
 }
 
 // src/configure.ts
 var NoConfigProfileResolvedError = class extends CliError {
   constructor(identityName, cwd) {
     super(
-      `No configuration profile resolves for identity "${identityName}" at "${cwd}". Create one with \`claude-use profile add <name>\` and make it this identity's default with \`claude-use identity set ${identityName} --default-profile <name>\` before running \`configure\`.`
+      `No configuration profile resolves for identity "${identityName}" at "${cwd}". Create one with \`agent-shim profile add <name>\` and make it this identity's default with \`agent-shim identity set ${identityName} --default-profile <name>\` before running \`configure\`.`
     );
     this.identityName = identityName;
     this.cwd = cwd;
@@ -60501,13 +60533,13 @@ var NoConfigProfileResolvedError = class extends CliError {
 };
 var ConfigureNeedsTerminalError = class extends UsageError {
   constructor() {
-    super("`claude-use configure` is interactive and needs a terminal. From a script, use `claude-use profile set` or edit the files it writes.");
+    super("`agent-shim configure` is interactive and needs a terminal. From a script, use `agent-shim profile set` or edit the files it writes.");
     this.name = "ConfigureNeedsTerminalError";
   }
 };
 var NoIdentityResolvedError = class extends UsageError {
   constructor(cwd) {
-    super(`No identity resolves in "${cwd}": pass --identity <name>, or select one with \`claude-use identity use <name>\`.`);
+    super(`No identity resolves in "${cwd}": pass --identity <name>, or select one with \`agent-shim identity use <name>\`.`);
     this.cwd = cwd;
     this.name = "NoIdentityResolvedError";
   }
@@ -60561,7 +60593,7 @@ function chooseWriteTarget(params) {
   for (let index = params.levels.length - 1; index >= 0; index -= 1) {
     const level = params.levels[index];
     if (level !== void 0 && (level.hasPortable || level.hasPortableLocal)) {
-      return { tier: "portable-local", localConfigPath: import_node_path19.default.join(level.dir, PORTABLE_LOCAL_CONFIG_FILENAME) };
+      return { tier: "portable-local", localConfigPath: import_node_path19.default.join(level.dir, level.portableLocalFilename) };
     }
   }
   const normalisedCwd = normaliseRulePath(params.cwd, params.home);
@@ -60653,11 +60685,16 @@ function parentOf3(relPath) {
 function buildWriteTargetLevels(cwd, home, walkUpLimit) {
   const limit = walkUpLimit === void 0 ? void 0 : expandTilde(walkUpLimit, home);
   const dirs = walkDirectoryAncestors(cwd, { home, ...limit === void 0 ? {} : { limit } });
-  return dirs.map((dir) => ({
-    dir,
-    hasPortable: import_node_fs7.default.existsSync(import_node_path19.default.join(dir, PORTABLE_CONFIG_FILENAME)),
-    hasPortableLocal: import_node_fs7.default.existsSync(import_node_path19.default.join(dir, PORTABLE_LOCAL_CONFIG_FILENAME))
-  }));
+  return dirs.map((dir) => {
+    const hasLocal = import_node_fs8.default.existsSync(import_node_path19.default.join(dir, PORTABLE_LOCAL_CONFIG_FILENAME));
+    const hasLegacyLocal = import_node_fs8.default.existsSync(import_node_path19.default.join(dir, LEGACY_PORTABLE_LOCAL_CONFIG_FILENAME));
+    return {
+      dir,
+      hasPortable: import_node_fs8.default.existsSync(import_node_path19.default.join(dir, PORTABLE_CONFIG_FILENAME)) || import_node_fs8.default.existsSync(import_node_path19.default.join(dir, LEGACY_PORTABLE_CONFIG_FILENAME)),
+      hasPortableLocal: hasLocal || hasLegacyLocal,
+      portableLocalFilename: !hasLocal && hasLegacyLocal ? LEGACY_PORTABLE_LOCAL_CONFIG_FILENAME : PORTABLE_LOCAL_CONFIG_FILENAME
+    };
+  });
 }
 function resolveWriteTarget(context) {
   return chooseWriteTarget({
@@ -60821,7 +60858,7 @@ async function runProfileDirectMode(context) {
   const { deps } = context;
   const profiles = listProfiles(deps.paths);
   if (profiles.length === 0) {
-    deps.log.info("No configuration profiles exist yet. Run `claude-use profile add <name>` first.");
+    deps.log.info("No configuration profiles exist yet. Run `agent-shim profile add <name>` first.");
     return;
   }
   const chosen = await deps.prompts.select({
@@ -60979,7 +61016,7 @@ function registerConfigureCommand(program2, deps) {
       }
     );
   });
-  withExamples(command, ["claude-use configure", "claude-use configure --identity work", "claude-use configure projects --identity work"]);
+  withExamples(command, ["agent-shim configure", "agent-shim configure --identity work", "agent-shim configure projects --identity work"]);
 }
 function resolveLaunchIdentity(paths, cwd) {
   const loaded = loadCascadeInput({ paths, home: import_node_os4.default.homedir(), cwd, read: cosmiconfigReader() });
@@ -60997,16 +61034,16 @@ function resolveLaunchIdentity(paths, cwd) {
 // package.json
 var package_default = {
   name: "claude-use",
-  version: "6.2.3",
+  version: "7.1.1",
   description: "A profile manager and launcher for Claude Code that lets one person run multiple logins from one machine while controlling what gets shared between them.",
-  license: "Apache-2.0",
+  license: "MIT",
   author: "Joseph Mearman <joseph@mearman.co.uk>",
   repository: {
     type: "git",
-    url: "git+https://github.com/ExaDev/claude-use.git"
+    url: "git+https://github.com/ExaDev/agent-shim.git"
   },
-  homepage: "https://github.com/ExaDev/claude-use#readme",
-  bugs: "https://github.com/ExaDev/claude-use/issues",
+  homepage: "https://github.com/ExaDev/agent-shim#readme",
+  bugs: "https://github.com/ExaDev/agent-shim/issues",
   keywords: [
     "claude-code",
     "claude",
@@ -61018,6 +61055,7 @@ var package_default = {
     node: "^22.18 || >=24"
   },
   bin: {
+    "agent-shim": "dist/cli.cjs",
     "claude-use": "dist/cli.cjs"
   },
   files: [
@@ -61116,12 +61154,12 @@ function detectAmbientCredential(env, injected) {
   return void 0;
 }
 function formatAmbientCredentialGuardMessage(variable, identityName) {
-  const identitySetCommand = identityName === void 0 ? "claude-use identity set <name> --allow-ambient-credential" : `claude-use identity set ${identityName} --allow-ambient-credential`;
+  const identitySetCommand = identityName === void 0 ? "agent-shim identity set <name> --allow-ambient-credential" : `agent-shim identity set ${identityName} --allow-ambient-credential`;
   return [
     `error: ${variable} is set in the environment. This identity's isolated`,
     "credential would be bypassed \u2014 every identity authenticates as this same key",
     "while it's set. Unset it, or if this is deliberate, opt in per-launch with",
-    "CLAUDE_USE_ALLOW_AMBIENT_CREDENTIAL=1, or persistently for this identity with",
+    "AGENT_SHIM_ALLOW_AMBIENT_CREDENTIAL=1, or persistently for this identity with",
     `\`${identitySetCommand}\`.`
   ].join("\n");
 }
@@ -61184,7 +61222,7 @@ function quotaWarnings(snapshot, provider, nowMs) {
     }
     const reset = window.resetsAt === void 0 ? "" : `, resets ${window.resetsAt}`;
     const verdict = effective.status === "rejected" ? "exhausted" : "nearly used";
-    return [`claude-use: identity ${snapshot.identity}: the ${name} quota is ${verdict}${reset} (last seen ${age} ago)`];
+    return [`agent-shim: identity ${snapshot.identity}: the ${name} quota is ${verdict}${reset} (last seen ${age} ago)`];
   });
 }
 
@@ -61363,12 +61401,12 @@ function isIdentityName(name) {
 function claudeJsonPath(identitiesDir, identity) {
   return import_node_path20.default.join(identitiesDir, identity, CLAUDE_JSON);
 }
-function readAccountMetadata(fs16, identitiesDir, identity) {
+function readAccountMetadata(fs17, identitiesDir, identity) {
   if (!isIdentityName(identity)) {
     throw new Error(`"${identity}" is not a valid identity name.`);
   }
   const file2 = claudeJsonPath(identitiesDir, identity);
-  const raw = fs16.readFileUtf8(file2);
+  const raw = fs17.readFileUtf8(file2);
   if (raw === void 0) {
     return void 0;
   }
@@ -61398,19 +61436,19 @@ function readAccountMetadata(fs16, identitiesDir, identity) {
   }
   return account.data;
 }
-function createAccountReader(fs16, identitiesDir) {
+function createAccountReader(fs17, identitiesDir) {
   const cache = /* @__PURE__ */ new Map();
   return (identity) => {
     if (!isIdentityName(identity)) {
       throw new Error(`"${identity}" is not a valid identity name.`);
     }
-    const stat = fs16.lstat(claudeJsonPath(identitiesDir, identity));
+    const stat = fs17.lstat(claudeJsonPath(identitiesDir, identity));
     const stamp = stat === void 0 ? "absent" : `${String(stat.mtimeMs)}:${String(stat.sizeBytes)}`;
     const cached2 = cache.get(identity);
     if (cached2?.stamp === stamp) {
       return cached2.account;
     }
-    const account = readAccountMetadata(fs16, identitiesDir, identity);
+    const account = readAccountMetadata(fs17, identitiesDir, identity);
     cache.set(identity, { stamp, account });
     return account;
   };
@@ -61441,23 +61479,23 @@ var zlib = __toESM(require("node:zlib"), 1);
 
 // src/frontdoor/route.ts
 var INTERNAL_HEADER_NAMES = [
-  "x-claude-use-identity",
-  "x-claude-use-session",
-  "x-claude-use-headroom",
-  "x-claude-use-auth",
-  "x-claude-use-hop",
-  "x-claude-use-hop-id",
+  "x-agent-shim-identity",
+  "x-agent-shim-session",
+  "x-agent-shim-headroom",
+  "x-agent-shim-auth",
+  "x-agent-shim-hop",
+  "x-agent-shim-hop-id",
   "x-headroom-project-id",
   "x-headroom-base-url"
 ];
-var IDENTITY_HEADER = "x-claude-use-identity";
-var SESSION_HEADER = "x-claude-use-session";
-var HEADROOM_FLAG_HEADER = "x-claude-use-headroom";
+var IDENTITY_HEADER = "x-agent-shim-identity";
+var SESSION_HEADER = "x-agent-shim-session";
+var HEADROOM_FLAG_HEADER = "x-agent-shim-headroom";
 var PROJECT_ID_HEADER = "x-headroom-project-id";
 var HEADROOM_BASE_URL_HEADER = "x-headroom-base-url";
-var AUTH_HEADER = "x-claude-use-auth";
-var HOP_SECRET_HEADER = "x-claude-use-hop";
-var HOP_ID_HEADER = "x-claude-use-hop-id";
+var AUTH_HEADER = "x-agent-shim-auth";
+var HOP_SECRET_HEADER = "x-agent-shim-hop";
+var HOP_ID_HEADER = "x-agent-shim-hop-id";
 function singleHeaderValue(value) {
   if (typeof value === "string") {
     return value;
@@ -62178,8 +62216,8 @@ function segmentDay(epochMs) {
 function segmentName(day, pid) {
   return `${day}.${String(pid)}.jsonl`;
 }
-function listLogSegments(fs16, logDir) {
-  return fs16.readdir(logDir).flatMap((name) => {
+function listLogSegments(fs17, logDir) {
+  return fs17.readdir(logDir).flatMap((name) => {
     const match = SEGMENT_RE.exec(name);
     const day = match?.[1];
     if (day === void 0) {
@@ -62188,15 +62226,15 @@ function listLogSegments(fs16, logDir) {
     return [{ name, day, endsAt: Date.parse(`${day}T00:00:00.000Z`) + DAY_MS }];
   }).sort((left, right) => left.day.localeCompare(right.day) || left.name.localeCompare(right.name));
 }
-function readUsageLog(fs16, logDir, options = {}) {
+function readUsageLog(fs17, logDir, options = {}) {
   const { sinceMs } = options;
   const records = [];
   let invalidLines = 0;
-  for (const segment of listLogSegments(fs16, logDir)) {
+  for (const segment of listLogSegments(fs17, logDir)) {
     if (sinceMs !== void 0 && segment.endsAt <= sinceMs) {
       continue;
     }
-    const contents = fs16.readFileUtf8(import_node_path21.default.join(logDir, segment.name));
+    const contents = fs17.readFileUtf8(import_node_path21.default.join(logDir, segment.name));
     if (contents === void 0) {
       continue;
     }
@@ -62228,7 +62266,7 @@ function readUsageLog(fs16, logDir, options = {}) {
 }
 var UsageSnapshotError = class extends Error {
   constructor(file2, detail) {
-    super(`${file2} is not a usage snapshot this claude-use can read (schema version ${String(USAGE_SCHEMA_VERSION)}): ${detail}`);
+    super(`${file2} is not a usage snapshot this agent-shim can read (schema version ${String(USAGE_SCHEMA_VERSION)}): ${detail}`);
     this.file = file2;
     this.name = "UsageSnapshotError";
   }
@@ -62240,9 +62278,9 @@ function snapshotPath(snapshotsDir, identity) {
   }
   return import_node_path21.default.join(snapshotsDir, `${identity}.json`);
 }
-function readUsageSnapshot(fs16, snapshotsDir, identity) {
+function readUsageSnapshot(fs17, snapshotsDir, identity) {
   const file2 = snapshotPath(snapshotsDir, identity);
-  const raw = fs16.readFileUtf8(file2);
+  const raw = fs17.readFileUtf8(file2);
   if (raw === void 0) {
     return void 0;
   }
@@ -62258,8 +62296,8 @@ function readUsageSnapshot(fs16, snapshotsDir, identity) {
   }
   return snapshot.data;
 }
-function listUsageSnapshots(fs16, snapshotsDir) {
-  return fs16.readdir(snapshotsDir).flatMap((name) => {
+function listUsageSnapshots(fs17, snapshotsDir) {
+  return fs17.readdir(snapshotsDir).flatMap((name) => {
     if (!name.endsWith(".json")) {
       return [];
     }
@@ -62267,7 +62305,7 @@ function listUsageSnapshots(fs16, snapshotsDir) {
     if (!isIdentityName(identity)) {
       return [];
     }
-    const snapshot = readUsageSnapshot(fs16, snapshotsDir, identity);
+    const snapshot = readUsageSnapshot(fs17, snapshotsDir, identity);
     return snapshot === void 0 ? [] : [snapshot];
   }).sort((left, right) => left.identity.localeCompare(right.identity));
 }
@@ -62326,11 +62364,11 @@ var import_node_path22 = __toESM(require("node:path"), 1);
 var DAY_MS2 = 864e5;
 var DAYS_IN_WEEK = 7;
 var USAGE_RETENTION_MS = DAYS_IN_WEEK * DAY_MS2;
-function pruneUsageLog(fs16, logDir, nowMs) {
+function pruneUsageLog(fs17, logDir, nowMs) {
   const cutoff = nowMs - USAGE_RETENTION_MS;
-  for (const segment of listLogSegments(fs16, logDir)) {
+  for (const segment of listLogSegments(fs17, logDir)) {
     if (segment.endsAt <= cutoff) {
-      fs16.removeRecursive(import_node_path22.default.join(logDir, segment.name));
+      fs17.removeRecursive(import_node_path22.default.join(logDir, segment.name));
     }
   }
 }
@@ -62359,7 +62397,7 @@ function foldProviderState(current, record2) {
   };
 }
 function createUsageStore(deps) {
-  const { fs: fs16, paths } = deps;
+  const { fs: fs17, paths } = deps;
   let prunedDay;
   const rewriteSnapshot = (identity, fold) => {
     if (!isIdentityName(identity)) {
@@ -62368,7 +62406,7 @@ function createUsageStore(deps) {
     }
     let current;
     try {
-      current = readUsageSnapshot(fs16, paths.usageSnapshotsDir, identity);
+      current = readUsageSnapshot(fs17, paths.usageSnapshotsDir, identity);
     } catch (error62) {
       if (!(error62 instanceof UsageSnapshotError)) {
         throw error62;
@@ -62395,8 +62433,8 @@ function createUsageStore(deps) {
       ...account === void 0 ? {} : { account },
       providers
     });
-    fs16.mkdirPrivate(paths.usageSnapshotsDir);
-    fs16.writeFilePrivate(snapshotPath(paths.usageSnapshotsDir, identity), `${JSON.stringify(snapshot, null, 2)}
+    fs17.mkdirPrivate(paths.usageSnapshotsDir);
+    fs17.writeFilePrivate(snapshotPath(paths.usageSnapshotsDir, identity), `${JSON.stringify(snapshot, null, 2)}
 `);
     return true;
   };
@@ -62404,14 +62442,14 @@ function createUsageStore(deps) {
     record: (input2) => {
       const record2 = UsageRecordSchema.parse(input2);
       const nowMs = deps.now();
-      fs16.mkdirPrivate(paths.usageDir);
-      fs16.mkdirPrivate(paths.usageLogDir);
+      fs17.mkdirPrivate(paths.usageDir);
+      fs17.mkdirPrivate(paths.usageLogDir);
       const day = segmentDay(nowMs);
       if (prunedDay !== day) {
-        pruneUsageLog(fs16, paths.usageLogDir, nowMs);
+        pruneUsageLog(fs17, paths.usageLogDir, nowMs);
         prunedDay = day;
       }
-      fs16.appendFilePrivate(import_node_path22.default.join(paths.usageLogDir, segmentName(day, deps.pid)), `${JSON.stringify(record2)}
+      fs17.appendFilePrivate(import_node_path22.default.join(paths.usageLogDir, segmentName(day, deps.pid)), `${JSON.stringify(record2)}
 `);
       if (record2.identity !== void 0) {
         rewriteSnapshot(record2.identity, (current) => ({ ...current?.providers, [record2.provider]: foldProviderState(current?.providers[record2.provider], record2) }));
@@ -62438,14 +62476,14 @@ var PicksFileSchema = external_exports.strictObject({
 function errorMessage(error62) {
   return error62 instanceof Error ? error62.message : String(error62);
 }
-function loadPoolMembers(fs16, paths, identities, nowMs) {
+function loadPoolMembers(fs17, paths, identities, nowMs) {
   const windowStartMs = nowMs - FIVE_HOUR_WINDOW_MS;
-  const log = readUsageLog(fs16, paths.usageLogDir, { sinceMs: windowStartMs });
+  const log = readUsageLog(fs17, paths.usageLogDir, { sinceMs: windowStartMs });
   return identities.map((identity) => {
     const records = log.records.filter((record2) => record2.identity === identity && record2.provider === ANTHROPIC_PROVIDER && Date.parse(record2.at) >= windowStartMs);
     try {
-      const snapshot = readUsageSnapshot(fs16, paths.usageSnapshotsDir, identity);
-      const account = readAccountMetadata(fs16, paths.identitiesDir, identity) ?? snapshot?.account;
+      const snapshot = readUsageSnapshot(fs17, paths.usageSnapshotsDir, identity);
+      const account = readAccountMetadata(fs17, paths.identitiesDir, identity) ?? snapshot?.account;
       return { identity, records, ...snapshot === void 0 ? {} : { snapshot }, ...account === void 0 ? {} : { account } };
     } catch (error62) {
       if (error62 instanceof UsageSnapshotError || error62 instanceof AccountMetadataError) {
@@ -62463,9 +62501,9 @@ function rankPoolFromStore(params) {
     ...params.sticky === void 0 ? {} : { sticky: params.sticky }
   });
 }
-function readPicksFile(fs16, file2) {
+function readPicksFile(fs17, file2) {
   const empty = { schemaVersion: SCHEMA_VERSION, picks: {} };
-  const raw = fs16.readFileUtf8(file2);
+  const raw = fs17.readFileUtf8(file2);
   if (raw === void 0) {
     return { file: empty };
   }
@@ -62476,19 +62514,19 @@ function readPicksFile(fs16, file2) {
     return { file: empty, problem: `${file2} is not valid JSON` };
   }
   const result = PicksFileSchema.safeParse(parsed);
-  return result.success ? { file: result.data } : { file: empty, problem: `${file2} is not a picks file this claude-use can read` };
+  return result.success ? { file: result.data } : { file: empty, problem: `${file2} is not a picks file this agent-shim can read` };
 }
-function readStickyPick(fs16, picksFile, directory) {
-  const read = readPicksFile(fs16, picksFile);
+function readStickyPick(fs17, picksFile, directory) {
+  const read = readPicksFile(fs17, picksFile);
   const entry = read.file.picks[directory];
   return { ...entry === void 0 ? {} : { sticky: entry }, ...read.problem === void 0 ? {} : { problem: read.problem } };
 }
-function recordStickyPick(fs16, picksFile, directory, identity, nowMs) {
-  const current = readPicksFile(fs16, picksFile).file.picks;
+function recordStickyPick(fs17, picksFile, directory, identity, nowMs) {
+  const current = readPicksFile(fs17, picksFile).file.picks;
   const kept = Object.entries(current).filter(([, entry]) => nowMs - Date.parse(entry.at) <= USAGE_RETENTION_MS);
   const next = { schemaVersion: SCHEMA_VERSION, picks: { ...Object.fromEntries(kept), [directory]: { identity, at: new Date(nowMs).toISOString() } } };
-  fs16.mkdirPrivate(import_node_path23.default.dirname(picksFile));
-  fs16.writeFilePrivate(picksFile, `${JSON.stringify(next, null, 2)}
+  fs17.mkdirPrivate(import_node_path23.default.dirname(picksFile));
+  fs17.writeFilePrivate(picksFile, `${JSON.stringify(next, null, 2)}
 `);
 }
 
@@ -62496,8 +62534,8 @@ function recordStickyPick(fs16, picksFile, directory, identity, nowMs) {
 var RESUME_FLAGS = /* @__PURE__ */ new Set(["--continue", "-c", "--resume", "-r"]);
 var TERMINATOR = "--";
 var REASONS_LOGGED = 3;
-function splitMembers(pool, paths, fs16) {
-  const exists = (name) => loadIdentity(paths.identitiesDir, name, fs16) !== void 0;
+function splitMembers(pool, paths, fs17) {
+  const exists = (name) => loadIdentity(paths.identitiesDir, name, fs17) !== void 0;
   return { present: pool.identities.filter(exists), missing: pool.identities.filter((name) => !exists(name)) };
 }
 function isResuming(passthrough) {
@@ -62508,19 +62546,19 @@ function resolvePoolLaunch(params) {
   const { poolName, log } = params;
   const pool = params.pools?.[poolName];
   if (pool === void 0) {
-    return { ok: false, message: `claude-use: no pool named "${poolName}" (selected via ${params.selectedVia}). Run \`claude-use pool add ${poolName} --identity <name>...\` first.` };
+    return { ok: false, message: `agent-shim: no pool named "${poolName}" (selected via ${params.selectedVia}). Run \`agent-shim pool add ${poolName} --identity <name>...\` first.` };
   }
   const { present: identities, missing } = splitMembers(pool, params.paths, params.fs);
   for (const name of missing) {
-    log.warn(`claude-use: pool "${poolName}" names identity "${name}", which does not exist; skipping it`);
+    log.warn(`agent-shim: pool "${poolName}" names identity "${name}", which does not exist; skipping it`);
   }
   if (identities.length === 0) {
-    return { ok: false, message: `claude-use: no member of pool "${poolName}" is an existing identity.` };
+    return { ok: false, message: `agent-shim: no member of pool "${poolName}" is an existing identity.` };
   }
   const resuming = isResuming(params.passthrough);
   const stickyRead = readStickyPick(params.usageFs, params.paths.usagePicksFile, params.cwd);
   if (stickyRead.problem !== void 0) {
-    log.warn(`claude-use: ${stickyRead.problem}; ignoring the last-pick record`);
+    log.warn(`agent-shim: ${stickyRead.problem}; ignoring the last-pick record`);
   }
   for (; ; ) {
     const nowMs = params.now();
@@ -62531,16 +62569,16 @@ function resolvePoolLaunch(params) {
       return { ok: true, identity: pick2.identity, explanation: `pool ${poolName}: ${pick2.reasons.slice(0, REASONS_LOGGED).join("; ")}` };
     }
     if (earliestReturn === void 0) {
-      return { ok: false, message: `claude-use: no member of pool "${poolName}" can be picked.` };
+      return { ok: false, message: `agent-shim: no member of pool "${poolName}" can be picked.` };
     }
     const until = new Date(earliestReturn.atMs).toISOString();
     if (!params.wait) {
       return {
         ok: false,
-        message: `claude-use: every member of pool "${poolName}" is refused right now; the earliest, ${earliestReturn.identity}, returns at ${until} (in ${formatAge(earliestReturn.atMs - nowMs)}). Pass --wait to sleep until then.`
+        message: `agent-shim: every member of pool "${poolName}" is refused right now; the earliest, ${earliestReturn.identity}, returns at ${until} (in ${formatAge(earliestReturn.atMs - nowMs)}). Pass --wait to sleep until then.`
       };
     }
-    log.info(`claude-use: every member of pool "${poolName}" is refused; waiting until ${until} for ${earliestReturn.identity}`);
+    log.info(`agent-shim: every member of pool "${poolName}" is refused; waiting until ${until} for ${earliestReturn.identity}`);
     params.sleep(Math.max(earliestReturn.atMs - nowMs, 0));
   }
 }
@@ -62606,7 +62644,7 @@ function registerPoolCommand(program2, deps) {
   const { paths } = deps;
   const pool = withExamples(
     program2.command("pool").description("Manage pools: named sets of identities that a launch picks one member of, by remaining quota, with `claude @pool:<name>`."),
-    ["claude-use pool add subs --identity work --identity personal", "claude-use pool pick subs"]
+    ["agent-shim pool add subs --identity work --identity personal", "agent-shim pool pick subs"]
   );
   withExamples(
     pool.command("add <name>").description("Define a pool. Fails if one with this name already exists.").option("--identity <name>", "A member identity (repeatable).", collectRepeated).action((name, options) => {
@@ -62615,7 +62653,7 @@ function registerPoolCommand(program2, deps) {
       addPool(paths, name, members2);
       console.log(`Created pool "${name}" with ${members2.join(", ")}.`);
     }),
-    ["claude-use pool add subs --identity work --identity personal"]
+    ["agent-shim pool add subs --identity work --identity personal"]
   );
   withExamples(
     pool.command("set <name>").description("Replace a pool's members.").option("--identity <name>", "A member identity (repeatable); the full new list.", collectRepeated).action((name, options) => {
@@ -62624,7 +62662,7 @@ function registerPoolCommand(program2, deps) {
       setPool(paths, name, members2);
       console.log(`Pool "${name}" now has ${members2.join(", ")}.`);
     }),
-    ["claude-use pool set subs --identity work --identity personal --identity spare"]
+    ["agent-shim pool set subs --identity work --identity personal --identity spare"]
   );
   withExamples(
     pool.command("list").description("List every pool and its members, marking the active selection with *.").option("--json", "Print the pools as JSON.").action((options) => {
@@ -62636,14 +62674,14 @@ function registerPoolCommand(program2, deps) {
       }
       const names = Object.keys(pools).sort();
       if (names.length === 0) {
-        console.log("No pools yet. Run `claude-use pool add <name> --identity <name>...` to create one.");
+        console.log("No pools yet. Run `agent-shim pool add <name> --identity <name>...` to create one.");
         return;
       }
       for (const name of names) {
         console.log(`${active === `${POOL_SELECTOR_PREFIX}${name}` ? "*" : " "} ${name}: ${(pools[name]?.identities ?? []).join(", ")}`);
       }
     }),
-    ["claude-use pool list", "claude-use pool list --json"]
+    ["agent-shim pool list", "agent-shim pool list --json"]
   );
   withExamples(
     pool.command("show <name>").description("Show one pool's members.").option("--json", "Print the pool as JSON.").action((name, options) => {
@@ -62655,7 +62693,7 @@ function registerPoolCommand(program2, deps) {
       console.log(`Pool: ${name}`);
       console.log(`Members: ${entry.identities.join(", ")}`);
     }),
-    ["claude-use pool show subs"]
+    ["agent-shim pool show subs"]
   );
   withExamples(
     pool.command("remove <name>").description("Delete a pool. Its member identities are untouched.").option("--yes", "Skip the confirmation prompt.").action(async (name, options) => {
@@ -62664,14 +62702,14 @@ function registerPoolCommand(program2, deps) {
       removePool(paths, name);
       console.log(`Removed pool "${name}".`);
     }),
-    ["claude-use pool remove subs --yes"]
+    ["agent-shim pool remove subs --yes"]
   );
   withExamples(
     pool.command("use <name>").description("Make launches with no other selection pick a member of this pool.").action((name) => {
       useIdentity(paths, `${POOL_SELECTOR_PREFIX}${name}`);
       console.log(`Active selection is now pool "${name}".`);
     }),
-    ["claude-use pool use subs"]
+    ["agent-shim pool use subs"]
   );
   withExamples(
     pool.command("pick <name>").description("Show how a launch from this directory would rank the pool's members right now, and which it would run as. Read-only: it records nothing.").option("--json", "Print the ranking as JSON.").action((name, options) => {
@@ -62685,12 +62723,12 @@ function registerPoolCommand(program2, deps) {
         console.log(line);
       }
     }),
-    ["claude-use pool pick subs", "claude-use pool pick subs --json"]
+    ["agent-shim pool pick subs", "agent-shim pool pick subs --json"]
   );
 }
 
 // src/providers.ts
-var import_node_fs8 = __toESM(require("node:fs"), 1);
+var import_node_fs9 = __toESM(require("node:fs"), 1);
 var import_node_path24 = __toESM(require("node:path"), 1);
 
 // src/codex/translate.ts
@@ -62933,7 +62971,7 @@ function translateRequest(body, config2) {
 // src/providers.ts
 var ProviderNotFoundError = class extends CliError {
   constructor(name) {
-    super(`No provider named "${name}". Run \`claude-use provider add ${name}\` first.`);
+    super(`No provider named "${name}". Run \`agent-shim provider add ${name}\` first.`);
     this.name = name;
     this.name = "ProviderNotFoundError";
   }
@@ -62962,7 +63000,7 @@ function providerJsonPath(paths, name) {
   return import_node_path24.default.join(paths.providersDir, `${name}.json`);
 }
 function providerExists(paths, name) {
-  return import_node_fs8.default.existsSync(providerJsonPath(paths, name));
+  return import_node_fs9.default.existsSync(providerJsonPath(paths, name));
 }
 var LEGACY_PROVIDER_FIELDS = ["tokenEnv", "tokenCommand", "authScheme"];
 var LEGACY_ENV_CREDENTIAL_KEYS = Object.values(CREDENTIAL_TARGET_VARS);
@@ -63028,10 +63066,10 @@ function parseProviderFile(filePath, raw) {
 }
 function readProvider(paths, name) {
   const filePath = providerJsonPath(paths, name);
-  if (!import_node_fs8.default.existsSync(filePath)) {
+  if (!import_node_fs9.default.existsSync(filePath)) {
     return void 0;
   }
-  const raw = JSON.parse(import_node_fs8.default.readFileSync(filePath, "utf8"));
+  const raw = JSON.parse(import_node_fs9.default.readFileSync(filePath, "utf8"));
   return parseProviderFile(filePath, raw);
 }
 function loadProvider(providersDir, name, port) {
@@ -63041,7 +63079,7 @@ function loadProvider(providersDir, name, port) {
 }
 function listProviders(paths) {
   const names = listProviderNames(
-    (dir) => import_node_fs8.default.readdirSync(dir),
+    (dir) => import_node_fs9.default.readdirSync(dir),
     paths.providersDir
   );
   const result = [];
@@ -63053,7 +63091,7 @@ function listProviders(paths) {
       if (!(error62 instanceof ConfigValidationError || error62 instanceof LegacyProviderFileError)) {
         throw error62;
       }
-      console.error(`claude-use: providers/${name}.json is invalid and was skipped: ${error62.message}`);
+      console.error(`agent-shim: providers/${name}.json is invalid and was skipped: ${error62.message}`);
       continue;
     }
     if (provider !== void 0) {
@@ -63160,7 +63198,7 @@ function removeProvider(paths, name) {
   if (!providerExists(paths, name)) {
     throw new ProviderNotFoundError(name);
   }
-  import_node_fs8.default.rmSync(providerJsonPath(paths, name));
+  import_node_fs9.default.rmSync(providerJsonPath(paths, name));
 }
 function cascadeProviderName(cascade) {
   let name;
@@ -63183,11 +63221,11 @@ function resolveProvider(params) {
     return {
       ok: false,
       status: 1,
-      message: `claude-use: no provider named "${name}". ` + (known.length > 0 ? `Known providers: ${known.join(", ")}.` : "No providers are defined yet; run `claude-use provider add`.")
+      message: `agent-shim: no provider named "${name}". ` + (known.length > 0 ? `Known providers: ${known.join(", ")}.` : "No providers are defined yet; run `agent-shim provider add`.")
     };
   }
   if (params.credentials === void 0) {
-    return { ok: false, status: 1, message: `claude-use: provider ${name} needs its credential resolved, but this launcher has no credential port wired` };
+    return { ok: false, status: 1, message: `agent-shim: provider ${name} needs its credential resolved, but this launcher has no credential port wired` };
   }
   const resolution = resolveCredential({ credential: definition.credential, env: params.env, port: params.credentials, subject: `provider ${name}` });
   if (!resolution.ok) {
@@ -63224,10 +63262,10 @@ function registerProviderCommand(program2, deps) {
   const { paths } = deps;
   const provider = withExamples(
     program2.command("provider").description("Manage API providers: Anthropic-compatible endpoints a launch can route through with --provider."),
-    ["claude-use provider add z --display-name z.ai --base-url https://api.z.ai/api/anthropic --credential env:Z_API_TOKEN", "claude-use provider list"]
+    ["agent-shim provider add z --display-name z.ai --base-url https://api.z.ai/api/anthropic --credential env:Z_API_TOKEN", "agent-shim provider list"]
   );
   withExamples(
-    provider.command("add <name>").description("Create a new API provider definition. Fails if one with this name already exists.").addOption(new Option("--kind <kind>", "http (default): an Anthropic-compatible endpoint at --base-url; codex: ChatGPT's Codex backend through the front-door daemon.").choices(PROVIDER_KINDS)).requiredOption("--display-name <name>", "Human-readable name, exported to the child as CLAUDE_USE_PROVIDER.").option("--base-url <url>", "Anthropic-compatible base URL the child's requests are sent to (http providers only, and required for them).").requiredOption(
+    provider.command("add <name>").description("Create a new API provider definition. Fails if one with this name already exists.").addOption(new Option("--kind <kind>", "http (default): an Anthropic-compatible endpoint at --base-url; codex: ChatGPT's Codex backend through the front-door daemon.").choices(PROVIDER_KINDS)).requiredOption("--display-name <name>", "Human-readable name, exported to the child as AGENT_SHIM_PROVIDER.").option("--base-url <url>", "Anthropic-compatible base URL the child's requests are sent to (http providers only, and required for them).").requiredOption(
       "--credential <source>",
       `Where the provider's token comes from (repeatable; tried in the order given until one yields a token): ${CREDENTIAL_SOURCE_SYNTAX}. Never the token itself.`,
       collectCredentialSource
@@ -63249,12 +63287,12 @@ function registerProviderCommand(program2, deps) {
       console.log(`Created provider "${name}" (${describeProviderEndpoint(created)}, credential ${describeCredential(created.credential)}).`);
     }),
     [
-      "claude-use provider add z --display-name z.ai --base-url https://api.z.ai/api/anthropic --credential env:Z_API_TOKEN",
-      "claude-use provider add z --display-name z.ai --base-url https://api.z.ai/api/anthropic --credential env:Z_API_TOKEN --credential op:op://vault/z/credential",
-      "claude-use provider add anthropic-api --display-name Anthropic --base-url https://api.anthropic.com --credential-target apiKey --credential keychain:anthropic-api-key",
-      "claude-use provider add local --display-name Local --base-url http://127.0.0.1:4000 --credential literal:dummy",
-      "claude-use provider add codex --kind codex --display-name Codex --credential literal:codex",
-      "claude-use provider add codex --kind codex --display-name Codex --credential literal:codex --codex-model sonnet=gpt-5.6-sol --codex-effort medium"
+      "agent-shim provider add z --display-name z.ai --base-url https://api.z.ai/api/anthropic --credential env:Z_API_TOKEN",
+      "agent-shim provider add z --display-name z.ai --base-url https://api.z.ai/api/anthropic --credential env:Z_API_TOKEN --credential op:op://vault/z/credential",
+      "agent-shim provider add anthropic-api --display-name Anthropic --base-url https://api.anthropic.com --credential-target apiKey --credential keychain:anthropic-api-key",
+      "agent-shim provider add local --display-name Local --base-url http://127.0.0.1:4000 --credential literal:dummy",
+      "agent-shim provider add codex --kind codex --display-name Codex --credential literal:codex",
+      "agent-shim provider add codex --kind codex --display-name Codex --credential literal:codex --codex-model sonnet=gpt-5.6-sol --codex-effort medium"
     ]
   );
   const providerSet = provider.command("set <name>").description("Update an existing API provider definition.").option("--display-name <name>", "Replace the human-readable name.").option("--base-url <url>", "Replace the base URL (http providers only).").option(
@@ -63289,11 +63327,11 @@ function registerProviderCommand(program2, deps) {
       console.log(`Updated provider "${name}" (${describeProviderEndpoint(updated)}, credential ${describeCredential(updated.credential)}).`);
     }),
     [
-      "claude-use provider set z --base-url https://api.z.ai/api/anthropic",
-      "claude-use provider set z --env API_TIMEOUT_MS=600000",
-      "claude-use provider set z --credential op:op://vault/z/credential --credential-cache-ttl 12h",
-      "claude-use provider set anthropic-api --credential-target apiKey",
-      "claude-use provider set codex --codex-model haiku=gpt-5.6-terra"
+      "agent-shim provider set z --base-url https://api.z.ai/api/anthropic",
+      "agent-shim provider set z --env API_TIMEOUT_MS=600000",
+      "agent-shim provider set z --credential op:op://vault/z/credential --credential-cache-ttl 12h",
+      "agent-shim provider set anthropic-api --credential-target apiKey",
+      "agent-shim provider set codex --codex-model haiku=gpt-5.6-terra"
     ]
   );
   withExamples(
@@ -63304,14 +63342,14 @@ function registerProviderCommand(program2, deps) {
         return;
       }
       if (entries.length === 0) {
-        console.log("No providers yet. Run `claude-use provider add <name>` to create one.");
+        console.log("No providers yet. Run `agent-shim provider add <name>` to create one.");
         return;
       }
       for (const entry of entries) {
         console.log(`  ${entry.name} (${entry.provider.displayName}, ${describeProviderEndpoint(entry.provider)})`);
       }
     }),
-    ["claude-use provider list", "claude-use provider list --json"]
+    ["agent-shim provider list", "agent-shim provider list --json"]
   );
   withExamples(
     provider.command("show <name>").description("Show one provider's definition. Credentials are described by source, never printed.").option("--json", "Print the provider as JSON.").action((name, options) => {
@@ -63337,7 +63375,7 @@ function registerProviderCommand(program2, deps) {
       const env = Object.entries(found.env ?? {});
       console.log(`Environment: ${env.length === 0 ? "(none)" : env.map(([key, value]) => `${key}=${value}`).join(", ")}`);
     }),
-    ["claude-use provider show z", "claude-use provider show z --json"]
+    ["agent-shim provider show z", "agent-shim provider show z --json"]
   );
   withExamples(
     provider.command("remove <name>").description("Delete a provider definition.").option("--yes", "Remove without asking for confirmation (required when standard input is not a terminal).").action(async (name, options) => {
@@ -63348,7 +63386,7 @@ function registerProviderCommand(program2, deps) {
       removeProvider(paths, name);
       console.log(`Removed provider "${name}".`);
     }),
-    ["claude-use provider remove z --yes"]
+    ["agent-shim provider remove z --yes"]
   );
 }
 
@@ -63510,7 +63548,7 @@ function runCheck(params) {
   const ambientCredential = evaluateAmbientCredentialGuard({
     env: params.env,
     allowAmbientCredential: params.identity?.allowAmbientCredential ?? false,
-    allowAmbientCredentialOverride: parseEnvBool("CLAUDE_USE_ALLOW_AMBIENT_CREDENTIAL", params.env.CLAUDE_USE_ALLOW_AMBIENT_CREDENTIAL) === true,
+    allowAmbientCredentialOverride: parseEnvBool("AGENT_SHIM_ALLOW_AMBIENT_CREDENTIAL", params.env.AGENT_SHIM_ALLOW_AMBIENT_CREDENTIAL) === true,
     ...params.identityName === void 0 ? {} : { identityName: params.identityName }
   });
   const settingsShared = resolved.flattened.categories.get("settings") ?? SHIPPED_CATEGORY_DEFAULTS.settings;
@@ -63723,12 +63761,12 @@ function registerCheckCommand(program2, deps) {
       process.exitCode = 1;
     }
   });
-  withExamples(command, ["claude-use check", "claude-use check ~/work/acme --identity work --json", "claude-use check --strict"]);
+  withExamples(command, ["agent-shim check", "agent-shim check ~/work/acme --identity work --json", "agent-shim check --strict"]);
 }
 
 // src/codex/commands.ts
 var import_node_crypto7 = require("node:crypto");
-var import_node_fs9 = __toESM(require("node:fs"), 1);
+var import_node_fs10 = __toESM(require("node:fs"), 1);
 var import_node_os6 = __toESM(require("node:os"), 1);
 var import_node_path27 = __toESM(require("node:path"), 1);
 
@@ -63761,10 +63799,10 @@ var FrontDoorStateSchema = external_exports.strictObject({
   /** The last fatal error, kept across shutdowns so `frontdoor status` can explain a front door that is not running. */
   lastError: external_exports.string().optional()
 });
-function readFrontDoorState(fs16, stateFile) {
+function readFrontDoorState(fs17, stateFile) {
   let raw;
   try {
-    raw = fs16.readFileUtf8(stateFile);
+    raw = fs17.readFileUtf8(stateFile);
   } catch {
     return void 0;
   }
@@ -63778,28 +63816,28 @@ function readFrontDoorState(fs16, stateFile) {
     return void 0;
   }
 }
-function writeFrontDoorState(fs16, stateFile, state) {
-  fs16.mkdirp(import_node_path26.default.dirname(stateFile));
-  fs16.writeFileUtf8(stateFile, `${JSON.stringify(state, null, 2)}
+function writeFrontDoorState(fs17, stateFile, state) {
+  fs17.mkdirp(import_node_path26.default.dirname(stateFile));
+  fs17.writeFileUtf8(stateFile, `${JSON.stringify(state, null, 2)}
 `);
 }
 function frontDoorOrigin(state) {
   const port = state?.directPort ?? state?.lastDirectPort;
   return port === void 0 ? void 0 : `http://127.0.0.1:${String(port)}`;
 }
-function writeFrontDoorSession(fs16, sessionsDir, session) {
-  fs16.mkdirPrivate(sessionsDir);
-  fs16.writeFilePrivate(import_node_path26.default.join(sessionsDir, `${String(session.pid)}.json`), `${JSON.stringify(session, null, 2)}
+function writeFrontDoorSession(fs17, sessionsDir, session) {
+  fs17.mkdirPrivate(sessionsDir);
+  fs17.writeFilePrivate(import_node_path26.default.join(sessionsDir, `${String(session.pid)}.json`), `${JSON.stringify(session, null, 2)}
 `);
 }
-function listFrontDoorSessions(fs16, sessionsDir) {
+function listFrontDoorSessions(fs17, sessionsDir) {
   const sessions = [];
-  for (const name of fs16.readdir(sessionsDir)) {
+  for (const name of fs17.readdir(sessionsDir)) {
     if (!name.endsWith(".json")) {
       continue;
     }
     try {
-      const parsed = FrontDoorSessionSchema.safeParse(JSON.parse(fs16.readFileUtf8(import_node_path26.default.join(sessionsDir, name)) ?? ""));
+      const parsed = FrontDoorSessionSchema.safeParse(JSON.parse(fs17.readFileUtf8(import_node_path26.default.join(sessionsDir, name)) ?? ""));
       if (parsed.success) {
         sessions.push({ pid: parsed.data.pid, startedAt: parsed.data.startedAt });
       }
@@ -63809,27 +63847,27 @@ function listFrontDoorSessions(fs16, sessionsDir) {
   }
   return sessions.sort((a2, b) => a2.pid - b.pid);
 }
-function removeFrontDoorSession(fs16, sessionsDir, pid) {
-  fs16.removeRecursive(import_node_path26.default.join(sessionsDir, `${String(pid)}.json`));
+function removeFrontDoorSession(fs17, sessionsDir, pid) {
+  fs17.removeRecursive(import_node_path26.default.join(sessionsDir, `${String(pid)}.json`));
 }
-function pruneDeadFrontDoorSessions(fs16, sessionsDir, isRunning) {
+function pruneDeadFrontDoorSessions(fs17, sessionsDir, isRunning) {
   const removed = [];
-  for (const session of listFrontDoorSessions(fs16, sessionsDir)) {
+  for (const session of listFrontDoorSessions(fs17, sessionsDir)) {
     if (!isRunning(session.pid)) {
-      removeFrontDoorSession(fs16, sessionsDir, session.pid);
+      removeFrontDoorSession(fs17, sessionsDir, session.pid);
       removed.push(session.pid);
     }
   }
   return removed;
 }
-function liveSessionTokens(fs16, sessionsDir) {
+function liveSessionTokens(fs17, sessionsDir) {
   const tokens = /* @__PURE__ */ new Set();
-  for (const name of fs16.readdir(sessionsDir)) {
+  for (const name of fs17.readdir(sessionsDir)) {
     if (!name.endsWith(".json")) {
       continue;
     }
     try {
-      const parsed = FrontDoorSessionSchema.safeParse(JSON.parse(fs16.readFileUtf8(import_node_path26.default.join(sessionsDir, name)) ?? ""));
+      const parsed = FrontDoorSessionSchema.safeParse(JSON.parse(fs17.readFileUtf8(import_node_path26.default.join(sessionsDir, name)) ?? ""));
       if (parsed.success) {
         tokens.add(parsed.data.token);
       }
@@ -64041,7 +64079,7 @@ function sessionIdFor(userId, randomId) {
   if (userId === void 0 || userId === "") {
     return randomId();
   }
-  const hex3 = (0, import_node_crypto6.createHash)("sha256").update(`claude-use codex session
+  const hex3 = (0, import_node_crypto6.createHash)("sha256").update(`agent-shim codex session
 ${userId}`).digest("hex");
   let next = 0;
   return UUID_TEMPLATE.replace(/x/g, () => hex3.charAt(next++));
@@ -64089,7 +64127,7 @@ var PRIVATE_FILE_MODE = 384;
 var realCodexAuthFs = {
   read: (filePath) => {
     try {
-      return import_node_fs9.default.readFileSync(filePath, "utf8");
+      return import_node_fs10.default.readFileSync(filePath, "utf8");
     } catch (error62) {
       if (isEnoent4(error62)) {
         return void 0;
@@ -64098,21 +64136,21 @@ var realCodexAuthFs = {
     }
   },
   writePrivate: (filePath, contents) => {
-    import_node_fs9.default.writeFileSync(filePath, contents, { encoding: "utf8", mode: PRIVATE_FILE_MODE });
-    import_node_fs9.default.chmodSync(filePath, PRIVATE_FILE_MODE);
+    import_node_fs10.default.writeFileSync(filePath, contents, { encoding: "utf8", mode: PRIVATE_FILE_MODE });
+    import_node_fs10.default.chmodSync(filePath, PRIVATE_FILE_MODE);
   },
   rename: (from, to) => {
-    import_node_fs9.default.renameSync(from, to);
+    import_node_fs10.default.renameSync(from, to);
   }
 };
 function writeUsageSnapshot(log, snapshot) {
   const target = codexUsageSnapshotPath();
   const temp = `${target}.${String(process.pid)}.tmp`;
   try {
-    import_node_fs9.default.mkdirSync(import_node_path27.default.dirname(target), { recursive: true });
-    import_node_fs9.default.writeFileSync(temp, `${JSON.stringify(snapshot, null, 2)}
+    import_node_fs10.default.mkdirSync(import_node_path27.default.dirname(target), { recursive: true });
+    import_node_fs10.default.writeFileSync(temp, `${JSON.stringify(snapshot, null, 2)}
 `);
-    import_node_fs9.default.renameSync(temp, target);
+    import_node_fs10.default.renameSync(temp, target);
   } catch (error62) {
     log(`usage snapshot write failed: ${error62 instanceof Error ? error62.message : String(error62)}`);
   }
@@ -64177,7 +64215,7 @@ function formatCodexStatus(status) {
 }
 function registerCodexCommand(program2, deps) {
   const { paths } = deps;
-  const codex = withExamples(program2.command("codex").description("Inspect the codex translation the front-door daemon serves for codex providers."), ["claude-use codex status"]);
+  const codex = withExamples(program2.command("codex").description("Inspect the codex translation the front-door daemon serves for codex providers."), ["agent-shim codex status"]);
   withExamples(
     codex.command("status").description("Report the front door serving codex providers, its sessions, and the usage snapshot. Read-only.").option("--json", "Print the status as JSON.").action((options) => {
       const status = collectCodexStatus(realFarmFs, paths, realIsProcessRunning);
@@ -64189,17 +64227,17 @@ function registerCodexCommand(program2, deps) {
         console.log(line);
       }
     }),
-    ["claude-use codex status", "claude-use codex status --json"]
+    ["agent-shim codex status", "agent-shim codex status --json"]
   );
 }
 
 // src/frontdoor/commands.ts
 var import_node_crypto13 = require("node:crypto");
-var import_node_fs10 = __toESM(require("node:fs"), 1);
+var import_node_fs11 = __toESM(require("node:fs"), 1);
 
 // src/frontdoor/custody.ts
 var CREDENTIAL_HEADERS = ["authorization", "x-api-key"];
-var SEQUESTERED_CREDENTIAL = "claude-use-sequestered";
+var SEQUESTERED_CREDENTIAL = "agent-shim-sequestered";
 function placeholderFor(name, value) {
   const first = typeof value === "string" ? value : value[0] ?? "";
   if (name === "authorization") {
@@ -64259,19 +64297,19 @@ function singleValue(value) {
 function admitLaunch(isLiveToken) {
   return (request6) => {
     const token = singleValue(request6.headers[AUTH_HEADER]);
-    return token !== void 0 && isLiveToken(token) ? { ok: true, headers: { ...request6.forwardable } } : { ok: false, message: "claude-use front door: this request carries no capability from a live claude-use launch" };
+    return token !== void 0 && isLiveToken(token) ? { ok: true, headers: { ...request6.forwardable } } : { ok: false, message: "agent-shim front door: this request carries no capability from a live agent-shim launch" };
   };
 }
 function admitHop(hopSecret, custody) {
   return (request6) => {
     if (singleValue(request6.headers[HOP_SECRET_HEADER]) !== hopSecret) {
-      return { ok: false, message: "claude-use front door: the direct listener serves only this door's own headroom hop" };
+      return { ok: false, message: "agent-shim front door: the direct listener serves only this door's own headroom hop" };
     }
     const hopId = singleValue(request6.headers[HOP_ID_HEADER]);
     const provider = parseProviderPath(new URL(request6.url, "http://127.0.0.1").pathname)?.provider;
     const credentials = hopId === void 0 || provider === void 0 ? void 0 : custody.redeem(hopId, provider);
     if (credentials === void 0) {
-      return { ok: false, message: "claude-use front door: this request names no live headroom hop for its provider" };
+      return { ok: false, message: "agent-shim front door: this request names no live headroom hop for its provider" };
     }
     return { ok: true, headers: restoreCredentials(request6.forwardable, credentials) };
   };
@@ -64299,8 +64337,8 @@ function createDoorPipelines(deps) {
 
 // src/frontdoor/capability.ts
 var import_node_crypto8 = require("node:crypto");
-var CONNECT_PROXY_USER = "claude-use";
-var CONNECT_PROXY_REALM = "claude-use front door";
+var CONNECT_PROXY_USER = "agent-shim";
+var CONNECT_PROXY_REALM = "agent-shim front door";
 var BASIC_SCHEME = "basic";
 function connectProxyUrl(port, token) {
   return `http://${encodeURIComponent(CONNECT_PROXY_USER)}:${encodeURIComponent(token)}@127.0.0.1:${String(port)}`;
@@ -64334,7 +64372,7 @@ function isLiveCapability(presented, live) {
 
 // src/frontdoor/connect.ts
 var import_node_crypto10 = require("node:crypto");
-var fs10 = __toESM(require("node:fs"), 1);
+var fs11 = __toESM(require("node:fs"), 1);
 var http = __toESM(require("node:http"), 1);
 var https = __toESM(require("node:https"), 1);
 var net3 = __toESM(require("node:net"), 1);
@@ -64616,8 +64654,8 @@ var FRONTDOOR_SUPERVISOR_STILL_RUNNING = -1;
 var FRONTDOOR_POLL_MS = 1e3;
 var MS_PER_MINUTE = 6e4;
 async function runFrontDoorSupervisor(idleShutdownMinutes, ports, options = {}) {
-  const { fs: fs16, paths } = ports;
-  const previous = readFrontDoorState(fs16, paths.frontdoorStateFile);
+  const { fs: fs17, paths } = ports;
+  const previous = readFrontDoorState(fs17, paths.frontdoorStateFile);
   let lastPort = previous?.lastPort;
   let lastConnectPort = previous?.lastConnectPort;
   let lastDirectPort = previous?.lastDirectPort;
@@ -64627,12 +64665,12 @@ async function runFrontDoorSupervisor(idleShutdownMinutes, ports, options = {})
     ...lastDirectPort === void 0 ? {} : { lastDirectPort }
   });
   const fail = (message) => {
-    writeFrontDoorState(fs16, paths.frontdoorStateFile, { lastError: message, ...sticky() });
-    fs16.removeRecursive(paths.frontdoorLockFile);
-    ports.log(`claude-use frontdoor supervisor: ${message}`);
+    writeFrontDoorState(fs17, paths.frontdoorStateFile, { lastError: message, ...sticky() });
+    fs17.removeRecursive(paths.frontdoorLockFile);
+    ports.log(`agent-shim frontdoor supervisor: ${message}`);
     return 1;
   };
-  writeFrontDoorState(fs16, paths.frontdoorStateFile, { supervisorPid: ports.ownPid, ...sticky() });
+  writeFrontDoorState(fs17, paths.frontdoorStateFile, { supervisorPid: ports.ownPid, ...sticky() });
   const previousSticky = lastPort;
   let http5;
   try {
@@ -64641,7 +64679,7 @@ async function runFrontDoorSupervisor(idleShutdownMinutes, ports, options = {})
     return fail(`could not start the provider listener: ${error62 instanceof Error ? error62.message : String(error62)}`);
   }
   if (previousSticky !== void 0 && http5.port !== previousSticky) {
-    ports.log(`claude-use frontdoor supervisor: sticky port ${String(previousSticky)} was occupied; moving to ${String(http5.port)} (sessions launched against the old port are stale until they relaunch)`);
+    ports.log(`agent-shim frontdoor supervisor: sticky port ${String(previousSticky)} was occupied; moving to ${String(http5.port)} (sessions launched against the old port are stale until they relaunch)`);
   }
   lastPort = http5.port;
   const previousStickyConnect = lastConnectPort;
@@ -64653,7 +64691,7 @@ async function runFrontDoorSupervisor(idleShutdownMinutes, ports, options = {})
     return fail(`could not start the CONNECT surface: ${error62 instanceof Error ? error62.message : String(error62)}`);
   }
   if (previousStickyConnect !== void 0 && connect2.port !== previousStickyConnect) {
-    ports.log(`claude-use frontdoor supervisor: sticky CONNECT port ${String(previousStickyConnect)} was occupied; moving to ${String(connect2.port)} (OAuth sessions launched against the old port are stale until they relaunch)`);
+    ports.log(`agent-shim frontdoor supervisor: sticky CONNECT port ${String(previousStickyConnect)} was occupied; moving to ${String(connect2.port)} (OAuth sessions launched against the old port are stale until they relaunch)`);
   }
   lastConnectPort = connect2.port;
   const previousStickyDirect = lastDirectPort;
@@ -64666,12 +64704,12 @@ async function runFrontDoorSupervisor(idleShutdownMinutes, ports, options = {})
     return fail(`could not start the direct listener: ${error62 instanceof Error ? error62.message : String(error62)}`);
   }
   if (previousStickyDirect !== void 0 && direct.port !== previousStickyDirect) {
-    ports.log(`claude-use frontdoor supervisor: sticky direct port ${String(previousStickyDirect)} was occupied; moving to ${String(direct.port)} (headroom must be restarted to admit the new address)`);
+    ports.log(`agent-shim frontdoor supervisor: sticky direct port ${String(previousStickyDirect)} was occupied; moving to ${String(direct.port)} (headroom must be restarted to admit the new address)`);
   }
   lastDirectPort = direct.port;
-  writeFrontDoorState(fs16, paths.frontdoorStateFile, { supervisorPid: ports.ownPid, port: http5.port, connectPort: connect2.port, directPort: direct.port, ...sticky() });
-  fs16.removeRecursive(paths.frontdoorLockFile);
-  ports.log(`claude-use frontdoor supervisor ${String(ports.ownPid)}: front door on 127.0.0.1:${String(http5.port)}, CONNECT surface on 127.0.0.1:${String(connect2.port)}`);
+  writeFrontDoorState(fs17, paths.frontdoorStateFile, { supervisorPid: ports.ownPid, port: http5.port, connectPort: connect2.port, directPort: direct.port, ...sticky() });
+  fs17.removeRecursive(paths.frontdoorLockFile);
+  ports.log(`agent-shim frontdoor supervisor ${String(ports.ownPid)}: front door on 127.0.0.1:${String(http5.port)}, CONNECT surface on 127.0.0.1:${String(connect2.port)}`);
   let idleSince;
   let ticks = 0;
   for (; ; ) {
@@ -64679,15 +64717,15 @@ async function runFrontDoorSupervisor(idleShutdownMinutes, ports, options = {})
       return FRONTDOOR_SUPERVISOR_STILL_RUNNING;
     }
     ticks += 1;
-    pruneDeadFrontDoorSessions(fs16, paths.frontdoorSessionsDir, ports.isRunning);
-    if (listFrontDoorSessions(fs16, paths.frontdoorSessionsDir).length === 0) {
+    pruneDeadFrontDoorSessions(fs17, paths.frontdoorSessionsDir, ports.isRunning);
+    if (listFrontDoorSessions(fs17, paths.frontdoorSessionsDir).length === 0) {
       idleSince ??= ports.now();
       if (ports.now() - idleSince >= idleShutdownMinutes * MS_PER_MINUTE) {
-        ports.log(`claude-use frontdoor supervisor: no sessions for ${String(idleShutdownMinutes)} minute(s); closing the front door and exiting`);
+        ports.log(`agent-shim frontdoor supervisor: no sessions for ${String(idleShutdownMinutes)} minute(s); closing the front door and exiting`);
         await direct.close();
         await connect2.close();
         await http5.close();
-        writeFrontDoorState(fs16, paths.frontdoorStateFile, sticky());
+        writeFrontDoorState(fs17, paths.frontdoorStateFile, sticky());
         return 0;
       }
     } else {
@@ -64723,7 +64761,7 @@ var CONNECT_LIMITS = {
 };
 var CA_VALIDITY_DAYS = 3650;
 var LEAF_VALIDITY_DAYS = 397;
-var CA_SUBJECT_COMMON_NAME = "claude-use front door CA";
+var CA_SUBJECT_COMMON_NAME = "agent-shim front door CA";
 var MS_PER_DAY = 864e5;
 function parseConnectTarget(authority) {
   const colon = authority.lastIndexOf(":");
@@ -65118,7 +65156,7 @@ function realConnectEffects() {
           response.destroy(error62);
           return;
         }
-        const body = `claude-use headroom: upstream unreachable (${error62.message})`;
+        const body = `agent-shim headroom: upstream unreachable (${error62.message})`;
         response.writeHead(HTTP_BAD_GATEWAY, { "content-type": "text/plain", "content-length": String(body.length) });
         response.end(body);
       });
@@ -65136,7 +65174,7 @@ function isEnoent5(error62) {
 function realConnectCertStore(paths) {
   const read = (file2) => {
     try {
-      return fs10.readFileSync(file2, "utf8");
+      return fs11.readFileSync(file2, "utf8");
     } catch (error62) {
       if (isEnoent5(error62)) {
         return void 0;
@@ -65151,10 +65189,10 @@ function realConnectCertStore(paths) {
       return certPem === void 0 || keyPem2 === void 0 ? void 0 : { certPem, keyPem: keyPem2 };
     },
     writeCa: (ca) => {
-      fs10.mkdirSync(paths.frontdoorCaDir, { recursive: true });
-      fs10.writeFileSync(paths.frontdoorCaCertFile, ca.certPem, "utf8");
-      fs10.writeFileSync(paths.frontdoorCaKeyFile, ca.keyPem, { encoding: "utf8", mode: CA_KEY_FILE_MODE });
-      fs10.chmodSync(paths.frontdoorCaKeyFile, CA_KEY_FILE_MODE);
+      fs11.mkdirSync(paths.frontdoorCaDir, { recursive: true });
+      fs11.writeFileSync(paths.frontdoorCaCertFile, ca.certPem, "utf8");
+      fs11.writeFileSync(paths.frontdoorCaKeyFile, ca.keyPem, { encoding: "utf8", mode: CA_KEY_FILE_MODE });
+      fs11.chmodSync(paths.frontdoorCaKeyFile, CA_KEY_FILE_MODE);
     }
   };
 }
@@ -65188,13 +65226,13 @@ function ensureFrontDoor(params) {
         }
         lastRejection = `the listener on 127.0.0.1:${String(state.port)} (recorded for pid ${String(supervisorPid)}) failed authentication: ${verdict.reason}`;
         if (spawned) {
-          throw new FrontDoorStartError(`claude-use: ${lastRejection}; refusing to send this session's credentials to it. Daemon log: ${paths.frontdoorLogPath}`);
+          throw new FrontDoorStartError(`agent-shim: ${lastRejection}; refusing to send this session's credentials to it. Daemon log: ${paths.frontdoorLogPath}`);
         }
         distrusted.add(supervisorPid);
         continue;
       }
       if (state?.lastError !== void 0) {
-        throw new FrontDoorStartError(`claude-use: the front door reported a fatal error and is not serving: ${state.lastError} (daemon log: ${paths.frontdoorLogPath})`);
+        throw new FrontDoorStartError(`agent-shim: the front door reported a fatal error and is not serving: ${state.lastError} (daemon log: ${paths.frontdoorLogPath})`);
       }
     } else if (!spawned) {
       ports.fs.mkdirp(paths.frontdoorDir);
@@ -65214,7 +65252,7 @@ function ensureFrontDoor(params) {
     if (ports.now() >= deadline) {
       const lastError = state?.lastError;
       throw new FrontDoorStartError(
-        `claude-use: the front door did not become ready within ${String(FRONTDOOR_START_TIMEOUT_MS)}ms` + (lastError === void 0 ? "" : ` (last error: ${lastError})`) + (lastRejection === void 0 ? "" : ` (${lastRejection})`) + `. Daemon log: ${paths.frontdoorLogPath}`
+        `agent-shim: the front door did not become ready within ${String(FRONTDOOR_START_TIMEOUT_MS)}ms` + (lastError === void 0 ? "" : ` (last error: ${lastError})`) + (lastRejection === void 0 ? "" : ` (${lastRejection})`) + `. Daemon log: ${paths.frontdoorLogPath}`
       );
     }
     ports.sleep(FRONTDOOR_LAUNCHER_POLL_MS);
@@ -65253,7 +65291,7 @@ function createFrontDoorServer(pipeline, log, tls2) {
       log(`request ${request6.method ?? "?"} ${request6.url ?? "?"} failed: ${error62 instanceof Error ? `${error62.name}: ${error62.message}` : String(error62)}`);
       if (!response.headersSent) {
         response.writeHead(HTTP_STATUS.internalServerError, { "Content-Type": "application/json" });
-        response.end(JSON.stringify({ type: "error", error: { type: "api_error", message: "internal error in the claude-use front door" } }));
+        response.end(JSON.stringify({ type: "error", error: { type: "api_error", message: "internal error in the agent-shim front door" } }));
       } else {
         response.destroy();
       }
@@ -65368,7 +65406,7 @@ async function applyHeadroomHop(request6, response, upstream, deps) {
   const port = deps.headroomPort();
   if (port === void 0) {
     response.start(HTTP_BAD_GATEWAY2, { "Content-Type": "application/json" });
-    await response.write(JSON.stringify({ type: "error", error: { type: "api_error", message: "claude-use front door: the headroom daemon is restarting" } }));
+    await response.write(JSON.stringify({ type: "error", error: { type: "api_error", message: "agent-shim front door: the headroom daemon is restarting" } }));
     response.end();
     return;
   }
@@ -65426,7 +65464,7 @@ async function forwardThroughHeadroom(request6, response, target) {
       target.log(`front door: headroom hop to 127.0.0.1:${String(port)} failed: ${error62.message}`);
       if (!response.headersSent) {
         response.start(HTTP_BAD_GATEWAY2, { "Content-Type": "application/json" });
-        void response.write(JSON.stringify({ type: "error", error: { type: "api_error", message: `claude-use front door: the headroom daemon is unreachable (${error62.message})` } })).then(() => {
+        void response.write(JSON.stringify({ type: "error", error: { type: "api_error", message: `agent-shim front door: the headroom daemon is unreachable (${error62.message})` } })).then(() => {
           response.end();
         });
       } else {
@@ -65599,7 +65637,7 @@ async function serveRouted(request6, deps) {
     deps.log(`front door: route ${resolution.route.name} failed: ${error62 instanceof Error ? `${error62.name}: ${error62.message}` : String(error62)}`);
     if (!response.headersSent) {
       response.start(HTTP_STATUS.internalServerError, { "Content-Type": "application/json" });
-      await response.write(errorBody(HTTP_STATUS.internalServerError, "internal error in the claude-use front door"));
+      await response.write(errorBody(HTTP_STATUS.internalServerError, "internal error in the agent-shim front door"));
       response.end();
       return;
     }
@@ -66268,6 +66306,7 @@ function responseHeaders2(headers) {
 function createPassthroughRoute(name, target) {
   const base = new URL(target.baseUrl);
   const tls2 = base.protocol === "https:";
+  const basePath = base.pathname.replace(/\/+$/, "");
   const agent = tls2 ? new https3.Agent({ keepAlive: true }) : new http4.Agent({ keepAlive: true });
   return {
     name,
@@ -66283,7 +66322,7 @@ function createPassthroughRoute(name, target) {
           host: base.hostname,
           port: base.port === "" ? void 0 : Number(base.port),
           method: request6.method,
-          path: `${path36}${incoming.search}`,
+          path: `${basePath}${path36}${incoming.search}`,
           headers,
           agent
         };
@@ -66392,18 +66431,18 @@ var import_node_crypto12 = require("node:crypto");
 var import_node_path28 = __toESM(require("node:path"), 1);
 var BUNDLE_NAME_HEX_DIGITS = 16;
 function resolveTrustBundle(params) {
-  const { caCertFile, bundlesDir, inherited, fs: fs16 } = params;
+  const { caCertFile, bundlesDir, inherited, fs: fs17 } = params;
   if (inherited === void 0 || inherited === "" || import_node_path28.default.resolve(inherited) === import_node_path28.default.resolve(caCertFile)) {
     return { path: caCertFile };
   }
-  const caPem = fs16.readFileUtf8(caCertFile);
+  const caPem = fs17.readFileUtf8(caCertFile);
   let inheritedPem;
   try {
-    inheritedPem = fs16.readFileUtf8(inherited);
+    inheritedPem = fs17.readFileUtf8(inherited);
   } catch (error62) {
     return {
       path: caCertFile,
-      warning: `claude-use: NODE_EXTRA_CA_CERTS names ${inherited}, which could not be read (${error62 instanceof Error ? error62.message : String(error62)}); the child trusts claude-use's front-door CA on top of the system store, and nothing from that file`
+      warning: `agent-shim: NODE_EXTRA_CA_CERTS names ${inherited}, which could not be read (${error62 instanceof Error ? error62.message : String(error62)}); the child trusts agent-shim's front-door CA on top of the system store, and nothing from that file`
     };
   }
   if (inheritedPem.includes(caPem.trim())) {
@@ -66412,9 +66451,9 @@ function resolveTrustBundle(params) {
   const combined = `${inheritedPem.trimEnd()}
 ${caPem}`;
   const bundle = import_node_path28.default.join(bundlesDir, `${(0, import_node_crypto12.createHash)("sha256").update(combined).digest("hex").slice(0, BUNDLE_NAME_HEX_DIGITS)}.pem`);
-  if (!fs16.exists(bundle)) {
-    fs16.mkdirp(bundlesDir);
-    fs16.writeFileAtomic(bundle, combined);
+  if (!fs17.exists(bundle)) {
+    fs17.mkdirp(bundlesDir);
+    fs17.writeFileAtomic(bundle, combined);
   }
   return { path: bundle };
 }
@@ -66702,8 +66741,8 @@ function createRealQuotaRefresher(params) {
 
 // src/frontdoor/commands.ts
 function appendLog(paths, line) {
-  import_node_fs10.default.mkdirSync(paths.logsDir, { recursive: true });
-  import_node_fs10.default.appendFileSync(paths.frontdoorLogPath, `${(/* @__PURE__ */ new Date()).toISOString()} ${line}
+  import_node_fs11.default.mkdirSync(paths.logsDir, { recursive: true });
+  import_node_fs11.default.appendFileSync(paths.frontdoorLogPath, `${(/* @__PURE__ */ new Date()).toISOString()} ${line}
 `);
 }
 function liveHeadroomPort(paths) {
@@ -66794,7 +66833,7 @@ function realFrontDoorSupervisorPorts(paths) {
                 log(`connect request ${request6.method ?? "?"} ${request6.url ?? "?"} failed: ${error62 instanceof Error ? `${error62.name}: ${error62.message}` : String(error62)}`);
                 if (!response.headersSent) {
                   response.writeHead(HTTP_STATUS.badGateway, { "Content-Type": "application/json" });
-                  response.end(JSON.stringify({ type: "error", error: { type: "api_error", message: "internal error in the claude-use front door" } }));
+                  response.end(JSON.stringify({ type: "error", error: { type: "api_error", message: "internal error in the agent-shim front door" } }));
                   return;
                 }
                 response.destroy();
@@ -66830,10 +66869,10 @@ function realFrontDoorSupervisorPorts(paths) {
   };
 }
 var realTrustBundleFs = {
-  readFileUtf8: (file2) => import_node_fs10.default.readFileSync(file2, "utf8"),
-  exists: (file2) => import_node_fs10.default.existsSync(file2),
+  readFileUtf8: (file2) => import_node_fs11.default.readFileSync(file2, "utf8"),
+  exists: (file2) => import_node_fs11.default.existsSync(file2),
   mkdirp: (dir) => {
-    import_node_fs10.default.mkdirSync(dir, { recursive: true });
+    import_node_fs11.default.mkdirSync(dir, { recursive: true });
   },
   writeFileAtomic: (file2, contents) => {
     realFarmFs.writeFilePrivate(file2, contents);
@@ -66852,7 +66891,7 @@ function realFrontDoorPort(paths) {
           sleep: realSleepSync,
           spawnSupervisor: (layout) => spawnDetachedSupervisor(layout, "__frontdoor-supervisor", layout.frontdoorLogPath),
           // Read fresh for each probe: a replacement supervisor may have regenerated an unparseable CA, and the probe must trust exactly what the serving door's leaf chains to.
-          verifyListener: (port) => probeFrontDoorSync(port, import_node_fs10.default.readFileSync(paths.frontdoorCaCertFile, "utf8"))
+          verifyListener: (port) => probeFrontDoorSync(port, import_node_fs11.default.readFileSync(paths.frontdoorCaCertFile, "utf8"))
         }
       });
       const trust = resolveTrustBundle({ caCertFile: paths.frontdoorCaCertFile, bundlesDir: paths.frontdoorCaBundlesDir, inherited: inheritedExtraCaCerts, fs: realTrustBundleFs });
@@ -66914,8 +66953,8 @@ function formatFrontDoorStatus(status, caCertPath) {
 }
 function registerFrontDoorCommand(program2, deps) {
   const { paths } = deps;
-  const frontdoor = withExamples(program2.command("frontdoor").description("Inspect the front-door daemon that routes every claude-use session."), [
-    "claude-use frontdoor status"
+  const frontdoor = withExamples(program2.command("frontdoor").description("Inspect the front-door daemon that routes every agent-shim session."), [
+    "agent-shim frontdoor status"
   ]);
   withExamples(
     frontdoor.command("status").description("Report the front door's supervisor, listeners, sessions, and last error. Read-only.").option("--json", "Print the status as JSON.").action((options) => {
@@ -66928,7 +66967,7 @@ function registerFrontDoorCommand(program2, deps) {
         console.log(line);
       }
     }),
-    ["claude-use frontdoor status", "claude-use frontdoor status --json"]
+    ["agent-shim frontdoor status", "agent-shim frontdoor status --json"]
   );
   program2.command("__frontdoor-supervisor", { hidden: true }).description("Internal: serve the front-door routing listeners. Started by the launcher; never run by hand.").allowUnknownOption().action(async () => {
     const idleShutdownMinutes = readGlobalConfig(paths)?.frontdoor?.idleShutdownMinutes ?? FRONTDOOR_DEFAULT_IDLE_SHUTDOWN_MINUTES;
@@ -67087,7 +67126,7 @@ function collectNodes(program2) {
   const visit2 = (command, id) => {
     const subcommands = help.visibleCommands(command).filter((sub) => sub.name() !== "help");
     const children = new Map(subcommands.map((sub) => [sub.name(), `${id}/${sub.name()}`]));
-    const optionWords = command.name() === "run" && id !== "root" ? LAUNCHER_FLAG_NAMES.map((flag) => ({ word: flag, description: "claude-use launch flag" })) : help.visibleOptions(command).flatMap((option) => option.long === void 0 ? [] : [{ word: option.long, description: firstSentence(option.description) }]);
+    const optionWords = command.name() === "run" && id !== "root" ? LAUNCHER_FLAG_NAMES.map((flag) => ({ word: flag, description: "agent-shim launch flag" })) : help.visibleOptions(command).flatMap((option) => option.long === void 0 ? [] : [{ word: option.long, description: firstSentence(option.description) }]);
     nodes.push({
       id,
       words: [...subcommands.map((sub) => ({ word: sub.name(), description: firstSentence(sub.description()) })), ...optionWords],
@@ -67111,8 +67150,8 @@ function transitionArms(nodes, indent) {
 }
 function bashScript(nodes) {
   const arms = nodes.map((node2) => `    ${singleQuote(node2.id)}) candidates=${singleQuote(node2.words.map((word) => word.word).join(" "))} ;;`).join("\n");
-  return `# claude-use bash completion. Load with: source <(claude-use completion bash)
-_claude_use() {
+  return `# agent-shim bash completion. Load with: source <(agent-shim completion bash)
+_agent_shim() {
   local cur="\${COMP_WORDS[COMP_CWORD]}" node=root candidates="" i
   for ((i = 1; i < COMP_CWORD; i++)); do
     case "\${node}:\${COMP_WORDS[i]}" in
@@ -67124,7 +67163,7 @@ ${arms}
   esac
   COMPREPLY=($(compgen -W "\${candidates}" -- "\${cur}"))
 }
-complete -o default -F _claude_use claude-use
+complete -o default -F _agent_shim agent-shim ${LEGACY_COMMAND_NAME}
 `;
 }
 function zshScript(nodes) {
@@ -67132,9 +67171,9 @@ function zshScript(nodes) {
     const entries = node2.words.map((word) => singleQuote(`${word.word}:${word.description.replaceAll(":", "\\:")}`)).join(" ");
     return `    ${singleQuote(node2.id)}) candidates=(${entries}) ;;`;
   }).join("\n");
-  return `#compdef claude-use
-# claude-use zsh completion. Load with: source <(claude-use completion zsh), after compinit.
-_claude_use() {
+  return `#compdef agent-shim ${LEGACY_COMMAND_NAME}
+# agent-shim zsh completion. Load with: source <(agent-shim completion zsh), after compinit.
+_agent_shim() {
   local node=root word
   local -a candidates
   for word in "\${(@)words[2,CURRENT-1]}"; do
@@ -67145,12 +67184,12 @@ ${transitionArms(nodes, "      ")}
   case "\${node}" in
 ${arms}
   esac
-  _describe -t commands 'claude-use' candidates
+  _describe -t commands 'agent-shim' candidates
 }
-if [ "\${funcstack[1]}" = "_claude_use" ]; then
-  _claude_use "$@"
+if [ "\${funcstack[1]}" = "_agent_shim" ]; then
+  _agent_shim "$@"
 else
-  compdef _claude_use claude-use
+  compdef _agent_shim agent-shim ${LEGACY_COMMAND_NAME}
 fi
 `;
 }
@@ -67161,13 +67200,13 @@ function fishScript(nodes) {
   ).join("\n");
   const completions = nodes.flatMap(
     (node2) => node2.words.map((word) => {
-      const condition = fishQuote(`test (__claude_use_node) = ${node2.id}`);
+      const condition = fishQuote(`test (__agent_shim_node) = ${node2.id}`);
       const target = word.word.startsWith("--") ? `-l ${fishQuote(word.word.slice(2))}` : `-a ${fishQuote(word.word)}`;
-      return `complete -c claude-use -n ${condition} ${target} -d ${fishQuote(word.description)}`;
+      return ["agent-shim", LEGACY_COMMAND_NAME].map((command) => `complete -c ${command} -n ${condition} ${target} -d ${fishQuote(word.description)}`).join("\n");
     })
   ).join("\n");
-  return `# claude-use fish completion. Load with: claude-use completion fish | source
-function __claude_use_node
+  return `# agent-shim fish completion. Load with: agent-shim completion fish | source
+function __agent_shim_node
     set -l node root
     for word in (commandline -opc)[2..-1]
         switch "$node:$word"
@@ -67176,7 +67215,7 @@ ${transitions}
     end
     echo $node
 end
-complete -c claude-use -f
+complete -c agent-shim -f
 ${completions}
 `;
 }
@@ -67212,7 +67251,7 @@ function registerCompletionCommand(program2) {
     process.stdout.write(generateCompletion(program2, shell));
   }).addHelpText(
     "after",
-    "\nExamples:\n  $ source <(claude-use completion bash)   # in ~/.bashrc\n  $ source <(claude-use completion zsh)    # in ~/.zshrc, after compinit\n  $ claude-use completion fish | source    # in ~/.config/fish/config.fish"
+    "\nExamples:\n  $ source <(agent-shim completion bash)   # in ~/.bashrc\n  $ source <(agent-shim completion zsh)    # in ~/.zshrc, after compinit\n  $ agent-shim completion fish | source    # in ~/.config/fish/config.fish"
   );
 }
 
@@ -67220,7 +67259,7 @@ function registerCompletionCommand(program2) {
 var import_node_child_process4 = require("node:child_process");
 
 // src/identityToken.ts
-var import_node_fs11 = __toESM(require("node:fs"), 1);
+var import_node_fs12 = __toESM(require("node:fs"), 1);
 var import_node_path29 = __toESM(require("node:path"), 1);
 var TOKEN_FILE_MODE = 384;
 var TOKEN_DIR_MODE = 448;
@@ -67237,21 +67276,21 @@ function storeIdentityToken(paths, identityName, raw) {
     throw new UsageError("That is not a claude setup-token token (expected it to start with sk-ant-oat). Run `claude setup-token` and pass its token on standard input.");
   }
   const dir = identityTokenDir(paths);
-  import_node_fs11.default.mkdirSync(dir, { recursive: true, mode: TOKEN_DIR_MODE });
-  import_node_fs11.default.chmodSync(dir, TOKEN_DIR_MODE);
+  import_node_fs12.default.mkdirSync(dir, { recursive: true, mode: TOKEN_DIR_MODE });
+  import_node_fs12.default.chmodSync(dir, TOKEN_DIR_MODE);
   const target = identityTokenPath(paths, identityName);
   const temp = import_node_path29.default.join(dir, `.${identityName}.${String(process.pid)}.tmp`);
-  import_node_fs11.default.writeFileSync(temp, `${token}
+  import_node_fs12.default.writeFileSync(temp, `${token}
 `, { mode: TOKEN_FILE_MODE });
-  import_node_fs11.default.renameSync(temp, target);
+  import_node_fs12.default.renameSync(temp, target);
   return target;
 }
 
 // src/realCredentialCache.ts
 var import_node_child_process3 = require("node:child_process");
-var import_node_fs12 = __toESM(require("node:fs"), 1);
+var import_node_fs13 = __toESM(require("node:fs"), 1);
 var import_node_path30 = __toESM(require("node:path"), 1);
-var KEYCHAIN_CACHE_SERVICE = "claude-use-credential-cache";
+var KEYCHAIN_CACHE_SERVICE = "agent-shim-credential-cache";
 var CACHE_DIR_MODE = 448;
 var CACHE_FILE_MODE = 384;
 function cacheFileNameFor(owner) {
@@ -67283,7 +67322,7 @@ function createRealCredentialCache(root) {
     read(store, owner) {
       if (store === "file") {
         try {
-          return parseEntry(import_node_fs12.default.readFileSync(filePath(owner), "utf8"));
+          return parseEntry(import_node_fs13.default.readFileSync(filePath(owner), "utf8"));
         } catch {
           return void 0;
         }
@@ -67295,12 +67334,12 @@ function createRealCredentialCache(root) {
     write(store, owner, entry) {
       const serialised = JSON.stringify(entry);
       if (store === "file") {
-        import_node_fs12.default.mkdirSync(dir, { recursive: true, mode: CACHE_DIR_MODE });
-        import_node_fs12.default.chmodSync(dir, CACHE_DIR_MODE);
+        import_node_fs13.default.mkdirSync(dir, { recursive: true, mode: CACHE_DIR_MODE });
+        import_node_fs13.default.chmodSync(dir, CACHE_DIR_MODE);
         const target = filePath(owner);
         const temp = `${target}.${String(process.pid)}.tmp`;
-        import_node_fs12.default.writeFileSync(temp, serialised, { mode: CACHE_FILE_MODE });
-        import_node_fs12.default.renameSync(temp, target);
+        import_node_fs13.default.writeFileSync(temp, serialised, { mode: CACHE_FILE_MODE });
+        import_node_fs13.default.renameSync(temp, target);
         return;
       }
       requireKeychain();
@@ -67313,7 +67352,7 @@ function createRealCredentialCache(root) {
     },
     remove(store, owner) {
       if (store === "file") {
-        import_node_fs12.default.rmSync(filePath(owner), { force: true });
+        import_node_fs13.default.rmSync(filePath(owner), { force: true });
         return;
       }
       requireKeychain();
@@ -67350,6 +67389,7 @@ function realCommandPorts(deps) {
     ssh: (host, remoteCommand, input2) => (0, import_node_child_process4.spawnSync)("ssh", ["--", host, remoteCommand], { input: input2, stdio: ["pipe", "inherit", "inherit"] }).status
   };
 }
+var REMOTE_ROOT_SCRIPT = 'root="${AGENT_SHIM_HOME:-${CLAUDE_USE_HOME:-}}"; if [ -z "$root" ]; then if [ ! -d "$HOME/.agent-shim" ] && [ -d "$HOME/.claude-use" ]; then root="$HOME/.claude-use"; else root="$HOME/.agent-shim"; fi; fi';
 var SSH_HOST_RE = /^[A-Za-z0-9._@:][A-Za-z0-9._@:-]*$/;
 function credentialSubject(deps, name, asProvider) {
   if (asProvider) {
@@ -67364,7 +67404,7 @@ function credentialSubject(deps, name, asProvider) {
     throw new IdentityNotFoundError(name);
   }
   if (identity.credential === void 0) {
-    throw new CredentialCommandError(`Identity "${name}" has no credential block to cache; it uses its stored login. Give it one with \`claude-use identity set ${name} --credential ...\`.`);
+    throw new CredentialCommandError(`Identity "${name}" has no credential block to cache; it uses its stored login. Give it one with \`agent-shim identity set ${name} --credential ...\`.`);
   }
   return { name, subject: `identity ${name}`, credential: identity.credential };
 }
@@ -67372,14 +67412,14 @@ function requireCaching(subject) {
   const cache = subject.credential.cache;
   if (cache === void 0) {
     const flag = subject.subject.startsWith("provider") ? `provider set ${subject.name}` : `identity set ${subject.name}`;
-    throw new CredentialCommandError(`The credential for ${subject.subject} is not cached. Turn caching on with \`claude-use ${flag} --credential-cache-ttl 12h\` (or --credential-cache for no expiry).`);
+    throw new CredentialCommandError(`The credential for ${subject.subject} is not cached. Turn caching on with \`agent-shim ${flag} --credential-cache-ttl 12h\` (or --credential-cache for no expiry).`);
   }
   return cache;
 }
 function registerCredentialCommand(program2, deps, ports = realCommandPorts(deps)) {
   const credential = withExamples(program2.command("credential").description("Manage the credentials identities authenticate with."), [
-    "claude-use credential store work < token.txt",
-    "claude-use credential warm work"
+    "agent-shim credential store work < token.txt",
+    "agent-shim credential warm work"
   ]);
   withExamples(
     credential.command("store <identity>").description("Store a `claude setup-token` token for an identity and make it that identity's credential. The token is read from standard input and never printed.").action(async (name) => {
@@ -67395,7 +67435,7 @@ function registerCredentialCommand(program2, deps, ports = realCommandPorts(deps
         console.log(`Identity "${name}" now authenticates with credential ${describeCredential(updated.credential)}.`);
       }
     }),
-    ["pbpaste | claude-use credential store work", "claude-use credential store work < token.txt"]
+    ["pbpaste | agent-shim credential store work", "agent-shim credential store work < token.txt"]
   );
   withExamples(
     credential.command("warm [identity]").description("Fetch an identity's or provider's credential from its sources now, prompting if a source needs a person, and fill its cache so later launches need no prompt. Never prints the token.").option("--provider <name>", "Warm a provider's credential instead of an identity's.").action((name, options) => {
@@ -67410,7 +67450,7 @@ function registerCredentialCommand(program2, deps, ports = realCommandPorts(deps
         `Cached the credential for ${subject.subject} in the ${effectiveStore(block2, ports.platform)} store (${limit === void 0 ? "no expiry" : `expires after ${block2.ttl ?? ""}`}).`
       );
     }),
-    ["claude-use credential warm work", "claude-use credential warm --provider z"]
+    ["agent-shim credential warm work", "agent-shim credential warm --provider z"]
   );
   withExamples(
     credential.command("forget [identity]").description("Remove an identity's or provider's cached credential from every store. The next launch fetches from the sources again.").option("--provider <name>", "Forget a provider's credential instead of an identity's.").action((name, options) => {
@@ -67421,7 +67461,7 @@ function registerCredentialCommand(program2, deps, ports = realCommandPorts(deps
       }
       console.log(`Removed the cached credential for ${subject.subject}.`);
     }),
-    ["claude-use credential forget work", "claude-use credential forget --provider z"]
+    ["agent-shim credential forget work", "agent-shim credential forget --provider z"]
   );
   withExamples(
     credential.command("push <identity> <host>").description("Read an identity's credential here and write it to the credential cache on another host over SSH (mode 0600, token on standard input), so that host needs no 1Password. The identity must cache with the file store on that host.").option("--provider <name>", "Push a provider's credential instead; <identity> is then ignored.").action((name, host, options) => {
@@ -67435,15 +67475,15 @@ function registerCredentialCommand(program2, deps, ports = realCommandPorts(deps
         throw new CredentialCommandError(resolution.message, CREDENTIAL_UNAVAILABLE_EXIT);
       }
       const entry = JSON.stringify({ token: resolution.credential.token, fetchedAt: resolution.credential.cachedAt ?? ports.now(), source: resolution.credential.source });
-      const remoteFile = `"\${CLAUDE_USE_HOME:-$HOME/.claude-use}/credential-cache/${cacheFileNameFor(subject.subject)}"`;
-      const remoteDir = `"\${CLAUDE_USE_HOME:-$HOME/.claude-use}/credential-cache"`;
-      const status = ports.ssh(host, `umask 077 && mkdir -p ${remoteDir} && cat > ${remoteFile}`, entry);
+      const remoteFile = `"$root/credential-cache/${cacheFileNameFor(subject.subject)}"`;
+      const remoteDir = '"$root/credential-cache"';
+      const status = ports.ssh(host, `${REMOTE_ROOT_SCRIPT} && umask 077 && mkdir -p ${remoteDir} && cat > ${remoteFile}`, entry);
       if (status !== 0) {
         throw new CredentialCommandError(`Could not write the credential cache for ${subject.subject} on ${host} (ssh exited ${status === null ? "without a status" : String(status)}).`);
       }
-      console.log(`Wrote the credential for ${subject.subject} to ${host}. There, set the credential's cache store to file: \`claude-use ${subject.subject.startsWith("provider") ? "provider" : "identity"} set ${subject.name} --credential-cache-store file\`.`);
+      console.log(`Wrote the credential for ${subject.subject} to ${host}. There, set the credential's cache store to file: \`agent-shim ${subject.subject.startsWith("provider") ? "provider" : "identity"} set ${subject.name} --credential-cache-store file\`.`);
     }),
-    ["claude-use credential push work build-host", "claude-use credential push x build-host --provider z"]
+    ["agent-shim credential push work build-host", "agent-shim credential push x build-host --provider z"]
   );
 }
 function subjectName(positional, provider) {
@@ -67455,7 +67495,7 @@ function subjectName(positional, provider) {
 }
 
 // src/doctor.ts
-var import_node_fs13 = __toESM(require("node:fs"), 1);
+var import_node_fs14 = __toESM(require("node:fs"), 1);
 var import_node_path31 = __toESM(require("node:path"), 1);
 
 // src/headroom/source.ts
@@ -67508,24 +67548,24 @@ function validateJson(schema, input2) {
 }
 function pushPathResolution(push, resolution) {
   const ownDir = import_node_path31.default.dirname(resolution.ownExecutablePath);
-  switch (resolution.claudeUse.status) {
+  switch (resolution.agentShim.status) {
     case "ok":
-      push("path-resolution", "pass", `\`claude-use\` on PATH resolves to this running executable, ${resolution.ownExecutablePath}.`, "claude-use");
+      push("path-resolution", "pass", `\`agent-shim\` on PATH resolves to this running executable, ${resolution.ownExecutablePath}.`, "agent-shim");
       break;
     case "not-on-path":
       push(
         "path-resolution",
         "warn",
-        `${ownDir} is not on PATH, so a bare \`claude-use\` does not reach ${resolution.ownExecutablePath}. Add it to PATH, or keep invoking this executable by its full path.`,
-        "claude-use"
+        `${ownDir} is not on PATH, so a bare \`agent-shim\` does not reach ${resolution.ownExecutablePath}. Add it to PATH, or keep invoking this executable by its full path.`,
+        "agent-shim"
       );
       break;
     case "shadowed":
       push(
         "path-resolution",
         "fail",
-        `\`claude-use\` on PATH resolves to ${resolution.claudeUse.by}, not this running executable, ${resolution.ownExecutablePath}. Every command you type runs that one instead, at whatever version it happens to be \u2014 including the checks in this report, which describe this executable. Remove ${resolution.claudeUse.by}, repoint it at ${resolution.ownExecutablePath}, or put ${ownDir} ahead of it on PATH.`,
-        "claude-use"
+        `\`agent-shim\` on PATH resolves to ${resolution.agentShim.by}, not this running executable, ${resolution.ownExecutablePath}. Every command you type runs that one instead, at whatever version it happens to be \u2014 including the checks in this report, which describe this executable. Remove ${resolution.agentShim.by}, repoint it at ${resolution.ownExecutablePath}, or put ${ownDir} ahead of it on PATH.`,
+        "agent-shim"
       );
       break;
   }
@@ -67537,13 +67577,13 @@ function pushPathResolution(push, resolution) {
       push("path-resolution", "pass", "`claude` on PATH resolves to the enabled shim.", "claude");
       break;
     case "not-on-path":
-      push("path-resolution", "warn", "The enabled `claude` shim's directory is not on PATH \u2014 add it, or use `claude-use run` instead.", "claude");
+      push("path-resolution", "warn", "The enabled `claude` shim's directory is not on PATH \u2014 add it, or use `agent-shim run` instead.", "claude");
       break;
     case "shadowed":
       push(
         "path-resolution",
         "warn",
-        `\`claude\` on PATH resolves to ${resolution.claude.by}, not the enabled shim. Put the shim's directory ahead of it on PATH, or run \`claude-use shim disable\` if you meant to launch that one directly.`,
+        `\`claude\` on PATH resolves to ${resolution.claude.by}, not the enabled shim. Put the shim's directory ahead of it on PATH, or run \`agent-shim shim disable\` if you meant to launch that one directly.`,
         "claude"
       );
       break;
@@ -67573,6 +67613,23 @@ function pushProvider(push, entry) {
   }
   push("provider", "pass", `${entry.name} is valid (${describeProviderEndpoint(validated.data)}, credential ${describeCredential(validated.data.credential)}).`, entry.name);
 }
+function pushLegacyName(push, params) {
+  const legacyVariables = Object.keys(params.env).filter((name) => name.startsWith(LEGACY_ENV_PREFIX) && params.env[name] !== void 0).sort();
+  if (legacyVariables.length === 0 && import_node_path31.default.basename(params.rootPath) !== LEGACY_HOME_DIRNAME) {
+    push("legacy-name", "pass", "Nothing here still uses the former `claude-use` name.");
+    return;
+  }
+  for (const name of legacyVariables) {
+    push("legacy-name", "warn", `${name} is the former name of ${name.replace(LEGACY_ENV_PREFIX, ENV_PREFIX)}. Rename it; the old name still works but is only a fallback.`, name);
+  }
+  if (import_node_path31.default.basename(params.rootPath) === LEGACY_HOME_DIRNAME) {
+    push(
+      "legacy-name",
+      "warn",
+      `The state root is the former ${params.rootPath}, used in place. Leave it where it is: macOS Claude Code keys each identity's Keychain login on its exact configuration directory path, so moving it signs every identity out.`
+    );
+  }
+}
 function runDoctor(params) {
   const findings = [];
   const push = (section, severity, message, subject) => {
@@ -67592,21 +67649,22 @@ function runDoctor(params) {
     push("binary-discovery", "fail", params.binaryDiscovery.message);
   }
   if (params.claudeShim.state === void 0) {
-    push("claude-shim", "pass", "No `claude` command shim enabled (the default). Run `claude-use shim enable` to add one.");
+    push("claude-shim", "pass", "No `claude` command shim enabled (the default). Run `agent-shim shim enable` to add one.");
   } else if (!params.claudeShim.targetExists) {
     push(
       "claude-shim",
       "warn",
-      `claude-shim.json records a \`claude\` shim at ${params.claudeShim.state.targetPath}, but nothing is there. Run \`claude-use shim enable\` again, or \`claude-use shim disable\` to clear the stale record.`
+      `claude-shim.json records a \`claude\` shim at ${params.claudeShim.state.targetPath}, but nothing is there. Run \`agent-shim shim enable\` again, or \`agent-shim shim disable\` to clear the stale record.`
     );
   } else {
     push(
       "claude-shim",
       "pass",
-      `\`claude\` is enabled at ${params.claudeShim.state.targetPath} (${params.claudeShim.state.method}). If you've upgraded claude-use since, re-run \`claude-use shim enable\` to refresh it.`
+      `\`claude\` is enabled at ${params.claudeShim.state.targetPath} (${params.claudeShim.state.method}). If you've upgraded agent-shim since, re-run \`agent-shim shim enable\` to refresh it.`
     );
   }
   pushPathResolution(push, params.pathResolution);
+  pushLegacyName(push, params);
   const profileSources = /* @__PURE__ */ new Map();
   for (const entry of params.configProfiles) {
     const validated = validateJson(ConfigProfileSchema, entry);
@@ -67804,6 +67862,7 @@ var SECTION_TITLES = {
   "binary-discovery": "Claude Code binary discovery",
   "claude-shim": "`claude` command shim",
   "path-resolution": "PATH resolution",
+  "legacy-name": "Former `claude-use` name",
   "config-profile": "Configuration profiles",
   identity: "Identities",
   pool: "Pools",
@@ -67862,7 +67921,7 @@ function formatDoctorReport(report) {
 }
 function realpathOrSelf(target) {
   try {
-    return import_node_fs13.default.realpathSync(target);
+    return import_node_fs14.default.realpathSync(target);
   } catch {
     return target;
   }
@@ -67870,20 +67929,20 @@ function realpathOrSelf(target) {
 function registerDoctorCommand(program2, deps) {
   const { paths } = deps;
   const command = program2.command("doctor").description(
-    "Audit the whole ~/.claude-use config graph: every identity, every configuration profile's extends chain, every provider, directory-rules.json, config.json, categories.local.json, active-identity, and real Claude Code binary discoverability. Identity/directory-agnostic, unlike `check`. Exits 1 when any check fails."
+    "Audit the whole ~/.agent-shim config graph: every identity, every configuration profile's extends chain, every provider, directory-rules.json, config.json, categories.local.json, active-identity, and real Claude Code binary discoverability. Identity/directory-agnostic, unlike `check`. Exits 1 when any check fails."
   ).option("--json", "Print the report as JSON.").action((options) => {
-    const identityNames = import_node_fs13.default.existsSync(paths.identitiesDir) ? import_node_fs13.default.readdirSync(paths.identitiesDir, { withFileTypes: true }).filter((entry) => entry.isDirectory() && isIdentityDirectoryName(entry.name)).map((entry) => entry.name).sort() : [];
+    const identityNames = import_node_fs14.default.existsSync(paths.identitiesDir) ? import_node_fs14.default.readdirSync(paths.identitiesDir, { withFileTypes: true }).filter((entry) => entry.isDirectory() && isIdentityDirectoryName(entry.name)).map((entry) => entry.name).sort() : [];
     const identities = identityNames.map((name) => {
       const farmRoot = import_node_path31.default.join(paths.identitiesDir, name);
       const identityPath = import_node_path31.default.join(farmRoot, "identity.json");
       return { name, path: identityPath, raw: realFsPort.readFileUtf8(identityPath), farmRoot };
     });
-    const profileNames = import_node_fs13.default.existsSync(paths.configProfilesDir) ? import_node_fs13.default.readdirSync(paths.configProfilesDir, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => entry.name.slice(0, -".json".length)).sort() : [];
+    const profileNames = import_node_fs14.default.existsSync(paths.configProfilesDir) ? import_node_fs14.default.readdirSync(paths.configProfilesDir, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => entry.name.slice(0, -".json".length)).sort() : [];
     const configProfiles = profileNames.map((name) => {
       const profilePath = import_node_path31.default.join(paths.configProfilesDir, `${name}.json`);
       return { name, path: profilePath, raw: realFsPort.readFileUtf8(profilePath) };
     });
-    const providerNames = import_node_fs13.default.existsSync(paths.providersDir) ? import_node_fs13.default.readdirSync(paths.providersDir, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => entry.name.slice(0, -".json".length)).sort() : [];
+    const providerNames = import_node_fs14.default.existsSync(paths.providersDir) ? import_node_fs14.default.readdirSync(paths.providersDir, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => entry.name.slice(0, -".json".length)).sort() : [];
     const providers = providerNames.map((name) => {
       const providerPath = import_node_path31.default.join(paths.providersDir, `${name}.json`);
       return { name, path: providerPath, raw: realFsPort.readFileUtf8(providerPath) };
@@ -67918,14 +67977,15 @@ function registerDoctorCommand(program2, deps) {
       categoriesLocal: { path: paths.categoriesLocalFile, raw: realFsPort.readFileUtf8(paths.categoriesLocalFile) },
       activeIdentity: { path: paths.activeIdentityFile, raw: realFsPort.readFileUtf8(paths.activeIdentityFile) },
       binaryDiscovery,
-      claudeShim: { state: shimState, targetExists: shimState !== void 0 && import_node_fs13.default.existsSync(shimState.targetPath) },
+      claudeShim: { state: shimState, targetExists: shimState !== void 0 && import_node_fs14.default.existsSync(shimState.targetPath) },
+      rootPath: paths.root,
       pathResolution: {
         ownExecutablePath,
-        claudeUse: refinePathShadow(
+        agentShim: refinePathShadow(
           findPathShadow({
             pathDirs,
             targetDir: import_node_path31.default.dirname(ownExecutablePath),
-            targetFilename: commandFilename(ownExecutablePath, "claude-use"),
+            targetFilename: commandFilename(ownExecutablePath, "agent-shim"),
             findExecutableInDir
           }),
           ownExecutablePath,
@@ -67951,11 +68011,11 @@ function registerDoctorCommand(program2, deps) {
       process.exitCode = 1;
     }
   });
-  withExamples(command, ["claude-use doctor", "claude-use doctor --json"]);
+  withExamples(command, ["agent-shim doctor", "agent-shim doctor --json"]);
 }
 
 // src/headroom/commands.ts
-var import_node_fs14 = __toESM(require("node:fs"), 1);
+var import_node_fs15 = __toESM(require("node:fs"), 1);
 var import_node_net3 = __toESM(require("node:net"), 1);
 var import_node_path32 = __toESM(require("node:path"), 1);
 var import_node_child_process5 = require("node:child_process");
@@ -68088,32 +68148,32 @@ function compareVersions2(a2, b) {
 }
 var HEADROOM_SUPERVISOR_STILL_RUNNING = -1;
 async function runSupervisor(initialConfig, ports, options = {}) {
-  const { fs: fs16, paths } = ports;
+  const { fs: fs17, paths } = ports;
   let config2 = initialConfig;
-  const previousState = readHeadroomState(fs16, paths.headroomStateFile);
+  const previousState = readHeadroomState(fs17, paths.headroomStateFile);
   if (previousState?.supervisorPid !== void 0 && previousState.supervisorPid !== ports.ownPid && ports.isRunning(previousState.supervisorPid)) {
-    ports.log(`claude-use headroom supervisor ${String(ports.ownPid)}: supervisor ${String(previousState.supervisorPid)} already owns the daemon; exiting`);
+    ports.log(`agent-shim headroom supervisor ${String(ports.ownPid)}: supervisor ${String(previousState.supervisorPid)} already owns the daemon; exiting`);
     return 0;
   }
   let installedSource = previousState?.installedSource;
   let lastPort = previousState?.lastPort;
   const sticky = () => lastPort === void 0 ? {} : { lastPort };
   const ownsState = () => {
-    const owner = readHeadroomState(fs16, paths.headroomStateFile)?.supervisorPid;
+    const owner = readHeadroomState(fs17, paths.headroomStateFile)?.supervisorPid;
     return owner === void 0 || owner === ports.ownPid || !ports.isRunning(owner);
   };
   const writeOwnState = (state) => {
     if (!ownsState()) {
       return false;
     }
-    writeHeadroomState(fs16, paths.headroomStateFile, state);
+    writeHeadroomState(fs17, paths.headroomStateFile, state);
     return true;
   };
   const fail = (message) => {
     if (writeOwnState({ lastError: message, ...sticky() })) {
-      fs16.removeRecursive(paths.headroomLockFile);
+      fs17.removeRecursive(paths.headroomLockFile);
     }
-    ports.log(`claude-use headroom supervisor: ${message}`);
+    ports.log(`agent-shim headroom supervisor: ${message}`);
     return 1;
   };
   const ensureInstalled = () => {
@@ -68125,7 +68185,7 @@ async function runSupervisor(initialConfig, ports, options = {}) {
       installedSource = config2.source;
       return true;
     }
-    ports.log(`claude-use headroom supervisor: installing headroom from ${config2.source}`);
+    ports.log(`agent-shim headroom supervisor: installing headroom from ${config2.source}`);
     const result = ports.install(config2.source);
     if (!result.ok) {
       return false;
@@ -68138,10 +68198,10 @@ async function runSupervisor(initialConfig, ports, options = {}) {
   }
   const version2 = ports.headroomVersion() ?? "unknown";
   writeOwnState({ supervisorPid: ports.ownPid, version: version2, installedSource, ...sticky() });
-  ports.log(`claude-use headroom supervisor ${String(ports.ownPid)}: managing headroom on allowlist [${allowlistOf(ports).join(", ")}]`);
+  ports.log(`agent-shim headroom supervisor ${String(ports.ownPid)}: managing headroom on allowlist [${allowlistOf(ports).join(", ")}]`);
   const orphanPid = previousState?.headroomPid;
   if (orphanPid !== void 0 && ports.isRunning(orphanPid)) {
-    ports.log(`claude-use headroom supervisor: stopping daemon pid ${String(orphanPid)} left behind by the previous supervisor`);
+    ports.log(`agent-shim headroom supervisor: stopping daemon pid ${String(orphanPid)} left behind by the previous supervisor`);
     ports.stopProcess(orphanPid);
   }
   let headroomPid;
@@ -68160,16 +68220,16 @@ async function runSupervisor(initialConfig, ports, options = {}) {
     const settingsHash = hashSettings(config2.settings);
     const allowlist = allowlistOf(ports);
     const allowlistHash = hashAllowlist(allowlist);
-    pruneDeadSessions(fs16, paths.headroomSessionsDir, ports.isRunning);
+    pruneDeadSessions(fs17, paths.headroomSessionsDir, ports.isRunning);
     const ownsNow = ownsState();
     if (!ownsNow && !superseded) {
-      ports.log("claude-use headroom supervisor: another supervisor now owns state.json; serving this daemon's own sessions until they end");
+      ports.log("agent-shim headroom supervisor: another supervisor now owns state.json; serving this daemon's own sessions until they end");
     }
     superseded = !ownsNow;
     const crashed = headroomPid !== void 0 && !ports.isRunning(headroomPid);
     if (headroomPid === void 0 || crashed) {
       if (crashed) {
-        ports.log(`claude-use headroom supervisor: headroom pid ${String(headroomPid)} died`);
+        ports.log(`agent-shim headroom supervisor: headroom pid ${String(headroomPid)} died`);
         headroomPid = void 0;
         runningHash = void 0;
         runningSettingsHash = void 0;
@@ -68198,7 +68258,7 @@ async function runSupervisor(initialConfig, ports, options = {}) {
         lastPort = port;
         if (previousSticky !== void 0 && port !== previousSticky) {
           ports.log(
-            `claude-use headroom supervisor: sticky port ${String(previousSticky)} was occupied; moving to ${String(port)} (sessions launched against the old port are stale until they relaunch)`
+            `agent-shim headroom supervisor: sticky port ${String(previousSticky)} was occupied; moving to ${String(port)} (sessions launched against the old port are stale until they relaunch)`
           );
         }
         const recorded = writeOwnState({
@@ -68212,23 +68272,23 @@ async function runSupervisor(initialConfig, ports, options = {}) {
           ...sticky()
         });
         if (recorded) {
-          fs16.removeRecursive(paths.headroomLockFile);
+          fs17.removeRecursive(paths.headroomLockFile);
         }
         idleSince = void 0;
-        ports.log(`claude-use headroom supervisor: headroom pid ${String(pid)} ready on 127.0.0.1:${String(port)}`);
+        ports.log(`agent-shim headroom supervisor: headroom pid ${String(pid)} ready on 127.0.0.1:${String(port)}`);
       } else {
         ports.stopProcess(pid);
         consecutiveFailures += 1;
         ports.log(
-          `claude-use headroom supervisor: headroom did not become ready on port ${String(port)} (attempt ${String(consecutiveFailures)} of ${String(HEADROOM_START_RETRY_BUDGET)})`
+          `agent-shim headroom supervisor: headroom did not become ready on port ${String(port)} (attempt ${String(consecutiveFailures)} of ${String(HEADROOM_START_RETRY_BUDGET)})`
         );
         await ports.sleep(backoffForAttempt(consecutiveFailures));
         continue;
       }
     } else {
       if (runningHash !== allowlistHash || runningSettingsHash !== settingsHash || installedSource !== config2.source) {
-        if (sessionsForSupervisor(fs16, paths.headroomSessionsDir, ports.ownPid).length === 0) {
-          ports.log("claude-use headroom supervisor: configuration drifted and no sessions are live; restarting headroom");
+        if (sessionsForSupervisor(fs17, paths.headroomSessionsDir, ports.ownPid).length === 0) {
+          ports.log("agent-shim headroom supervisor: configuration drifted and no sessions are live; restarting headroom");
           ports.stopProcess(headroomPid);
           headroomPid = void 0;
           runningHash = void 0;
@@ -68236,13 +68296,13 @@ async function runSupervisor(initialConfig, ports, options = {}) {
           continue;
         }
       }
-      const sessions = sessionsForSupervisor(fs16, paths.headroomSessionsDir, ports.ownPid);
+      const sessions = sessionsForSupervisor(fs17, paths.headroomSessionsDir, ports.ownPid);
       if (sessions.length === 0) {
         idleSince ??= ports.now();
         const idleMs = ports.now() - idleSince;
         if (idleMs >= config2.idleShutdownMinutes * MS_PER_MINUTE2) {
           ports.log(
-            `claude-use headroom supervisor: no sessions for ${String(config2.idleShutdownMinutes)} minute(s); stopping headroom and exiting`
+            `agent-shim headroom supervisor: no sessions for ${String(config2.idleShutdownMinutes)} minute(s); stopping headroom and exiting`
           );
           ports.stopProcess(headroomPid);
           writeOwnState({
@@ -68258,9 +68318,9 @@ async function runSupervisor(initialConfig, ports, options = {}) {
     await ports.sleep(HEADROOM_POLL_MS);
   }
 }
-function currentHeadroomAllowlist(fs16, paths) {
-  const providers = readAllProviders(fs16, paths.providersDir).map((entry) => entry.provider);
-  return headroomAllowlist(headroomUpstreams(providers, frontDoorOrigin(readFrontDoorState(fs16, paths.frontdoorStateFile))));
+function currentHeadroomAllowlist(fs17, paths) {
+  const providers = readAllProviders(fs17, paths.providersDir).map((entry) => entry.provider);
+  return headroomAllowlist(headroomUpstreams(providers, frontDoorOrigin(readFrontDoorState(fs17, paths.frontdoorStateFile))));
 }
 function allowlistOf(ports) {
   return currentHeadroomAllowlist(ports.fs, ports.paths);
@@ -68401,8 +68461,8 @@ function realSupervisorPorts(paths) {
     isPortFree: realIsPortFree,
     readConfig: () => resolveSupervisorConfig(readGlobalConfig(paths)?.headroom ?? {}),
     spawnHeadroom: (port, allowlist, settings2) => {
-      import_node_fs14.default.mkdirSync(paths.logsDir, { recursive: true });
-      const logFd = import_node_fs14.default.openSync(paths.headroomLogPath, "a");
+      import_node_fs15.default.mkdirSync(paths.logsDir, { recursive: true });
+      const logFd = import_node_fs15.default.openSync(paths.headroomLogPath, "a");
       try {
         const child = (0, import_node_child_process5.spawn)("headroom", ["proxy", "--host", "127.0.0.1", "--port", String(port), ...settingsArgs(settings2)], {
           detached: true,
@@ -68417,12 +68477,12 @@ function realSupervisorPorts(paths) {
         child.once("exit", (code, signal) => {
           ownedHeadroom.delete(pid);
           exitedHeadroom.add(pid);
-          import_node_fs14.default.appendFileSync(paths.headroomLogPath, `${(/* @__PURE__ */ new Date()).toISOString()} claude-use headroom supervisor: headroom exited (${signal ?? `code ${String(code)}`})
+          import_node_fs15.default.appendFileSync(paths.headroomLogPath, `${(/* @__PURE__ */ new Date()).toISOString()} agent-shim headroom supervisor: headroom exited (${signal ?? `code ${String(code)}`})
 `);
         });
         return pid;
       } finally {
-        import_node_fs14.default.closeSync(logFd);
+        import_node_fs15.default.closeSync(logFd);
       }
     },
     stopProcess: (pid) => {
@@ -68435,9 +68495,9 @@ function realSupervisorPorts(paths) {
         now: () => Date.now()
       });
       if (outcome === "still-running") {
-        import_node_fs14.default.appendFileSync(
+        import_node_fs15.default.appendFileSync(
           paths.headroomLogPath,
-          `${(/* @__PURE__ */ new Date()).toISOString()} claude-use headroom supervisor: pid ${String(pid)} survived SIGKILL within its grace; it is stuck uninterruptibly
+          `${(/* @__PURE__ */ new Date()).toISOString()} agent-shim headroom supervisor: pid ${String(pid)} survived SIGKILL within its grace; it is stuck uninterruptibly
 `
         );
       }
@@ -68456,10 +68516,10 @@ function realSupervisorPorts(paths) {
         return { ok: false, error: `uv is not installed or not on PATH (${result.error.message})` };
       }
       if (result.stdout !== "") {
-        import_node_fs14.default.appendFileSync(paths.headroomLogPath, result.stdout);
+        import_node_fs15.default.appendFileSync(paths.headroomLogPath, result.stdout);
       }
       if (result.stderr !== "") {
-        import_node_fs14.default.appendFileSync(paths.headroomLogPath, result.stderr);
+        import_node_fs15.default.appendFileSync(paths.headroomLogPath, result.stderr);
       }
       return result.status === 0 ? { ok: true } : { ok: false, error: `uv tool install exited ${String(result.status)}` };
     },
@@ -68469,8 +68529,8 @@ function realSupervisorPorts(paths) {
     },
     installedCommit: readInstalledHeadroomCommit,
     log: (line) => {
-      import_node_fs14.default.mkdirSync(paths.logsDir, { recursive: true });
-      import_node_fs14.default.appendFileSync(paths.headroomLogPath, `${(/* @__PURE__ */ new Date()).toISOString()} ${line}
+      import_node_fs15.default.mkdirSync(paths.logsDir, { recursive: true });
+      import_node_fs15.default.appendFileSync(paths.headroomLogPath, `${(/* @__PURE__ */ new Date()).toISOString()} ${line}
 `);
     }
   };
@@ -68478,7 +68538,7 @@ function realSupervisorPorts(paths) {
 function registerHeadroomCommand(program2, deps) {
   const { paths } = deps;
   const headroom = withExamples(program2.command("headroom").description("Inspect the headroom routing daemon."), [
-    "claude-use headroom status"
+    "agent-shim headroom status"
   ]);
   withExamples(
     headroom.command("status").description("Report the headroom daemon's supervisor, process, port, sessions, and last error. Read-only.").option("--json", "Print the status as JSON.").action((options) => {
@@ -68491,7 +68551,7 @@ function registerHeadroomCommand(program2, deps) {
         console.log(line);
       }
     }),
-    ["claude-use headroom status", "claude-use headroom status --json"]
+    ["agent-shim headroom status", "agent-shim headroom status --json"]
   );
   program2.command("__headroom-supervisor", { hidden: true }).description("Internal: supervise the headroom daemon. Started by the launcher; never run by hand.").allowUnknownOption().action(async () => {
     const globalConfig2 = readGlobalConfig(paths);
@@ -68518,7 +68578,7 @@ function registerHeadroomCommand(program2, deps) {
 // src/runCommand.ts
 function registerRunCommand(program2, handler) {
   program2.command("run").description(
-    "Launch Claude Code under an identity, without needing a `claude`-named binary on PATH. Launch flags (see `claude-use --help`) are consumed first; every other argument is forwarded exactly as `claude` would receive it."
+    "Launch Claude Code under an identity, without needing a `claude`-named binary on PATH. Launch flags (see `agent-shim --help`) are consumed first; every other argument is forwarded exactly as `claude` would receive it."
   ).allowUnknownOption().passThroughOptions().helpOption(false).argument("[args...]", "Arguments to forward, e.g. @<name>, --config-profile <name>, or any Claude Code flag.").action(async (args) => {
     await handler(args);
   });
@@ -68531,14 +68591,14 @@ function requireIdentity(paths, name) {
     throw new IdentityNotFoundError(name);
   }
 }
-function collectUsageReport(fs16, paths, filters) {
+function collectUsageReport(fs17, paths, filters) {
   const { identity, provider, sinceMs } = filters;
   if (identity !== void 0) {
     requireIdentity(paths, identity);
   }
-  const log = readUsageLog(fs16, paths.usageLogDir, sinceMs === void 0 ? {} : { sinceMs });
+  const log = readUsageLog(fs17, paths.usageLogDir, sinceMs === void 0 ? {} : { sinceMs });
   const records = log.records.filter((record2) => (identity === void 0 || record2.identity === identity) && (provider === void 0 || record2.provider === provider));
-  const snapshots = (identity === void 0 ? listUsageSnapshots(fs16, paths.usageSnapshotsDir) : [readUsageSnapshot(fs16, paths.usageSnapshotsDir, identity)].flatMap((snapshot) => snapshot === void 0 ? [] : [snapshot])).map((snapshot) => provider === void 0 ? snapshot : { ...snapshot, providers: Object.fromEntries(Object.entries(snapshot.providers).filter(([name]) => name === provider)) }).filter((snapshot) => Object.keys(snapshot.providers).length > 0);
+  const snapshots = (identity === void 0 ? listUsageSnapshots(fs17, paths.usageSnapshotsDir) : [readUsageSnapshot(fs17, paths.usageSnapshotsDir, identity)].flatMap((snapshot) => snapshot === void 0 ? [] : [snapshot])).map((snapshot) => provider === void 0 ? snapshot : { ...snapshot, providers: Object.fromEntries(Object.entries(snapshot.providers).filter(([name]) => name === provider)) }).filter((snapshot) => Object.keys(snapshot.providers).length > 0);
   return {
     since: sinceMs === void 0 ? void 0 : new Date(sinceMs).toISOString(),
     logDir: paths.usageLogDir,
@@ -68634,15 +68694,15 @@ function formatUsageReport(report) {
   }
   return lines;
 }
-function collectAccounts(fs16, paths, identity) {
+function collectAccounts(fs17, paths, identity) {
   if (identity !== void 0) {
     requireIdentity(paths, identity);
   }
   const names = identity === void 0 ? listIdentities(paths).map((entry) => entry.name) : [identity];
   return names.map((name) => ({
     identity: name,
-    account: readAccountMetadata(fs16, paths.identitiesDir, name),
-    usage: readUsageSnapshot(fs16, paths.usageSnapshotsDir, name)
+    account: readAccountMetadata(fs17, paths.identitiesDir, name),
+    usage: readUsageSnapshot(fs17, paths.usageSnapshotsDir, name)
   }));
 }
 function formatAccounts(views) {
@@ -68722,10 +68782,10 @@ function registerUsageCommands(program2, deps) {
         console.log(line);
       }
     }),
-    ["claude-use usage", "claude-use usage --identity work --since 5h", "claude-use usage --provider z --refresh --json"]
+    ["agent-shim usage", "agent-shim usage --identity work --since 5h", "agent-shim usage --provider z --refresh --json"]
   );
   const account = withExamples(program2.command("account").description("Inspect the Claude account behind each identity: plan, tier and latest quota."), [
-    "claude-use account show work"
+    "agent-shim account show work"
   ]);
   withExamples(
     account.command("show [identity]").description("Show an identity's account metadata (read live from its stored login) and its latest recorded quota; every identity when none is named. Read-only.").option("--refresh", "First fetch the quota of providers that report it through their own usage endpoint (z.ai), regardless of how fresh the stored one is.").option("--json", "Print the accounts as JSON.").action(async (identity, options) => {
@@ -68743,21 +68803,21 @@ function registerUsageCommands(program2, deps) {
         console.log(line);
       }
     }),
-    ["claude-use account show", "claude-use account show work", "claude-use account show work --json"]
+    ["agent-shim account show", "agent-shim account show work", "agent-shim account show work --json"]
   );
 }
 
 // src/program.ts
 var ROOT_HELP_AFTER = `
 Grammar:
-  claude-use <noun> <verb> [name] [options], where the nouns are identity, profile,
+  agent-shim <noun> <verb> [name] [options], where the nouns are identity, profile,
   provider and rule, and the verbs are add, set, list, show, remove and use.
   credential is the exception: it acts on the credentials identities use (store).
 
 Launching:
-  claude-use run [@<identity>] [launch flags] [claude arguments]
-  Everything after run is forwarded to Claude Code, so \`claude-use run --help\` shows
-  claude's own help. claude-use consumes these launch flags first, and only before a
+  agent-shim run [@<identity>] [launch flags] [claude arguments]
+  Everything after run is forwarded to Claude Code, so \`agent-shim run --help\` shows
+  claude's own help. agent-shim consumes these launch flags first, and only before a
   \`--\` terminator (everything from \`--\` on is forwarded untouched):
     --identity <name>            the identity (same as a leading @<name>)
     --config-profile <name>      the configuration profile for this launch
@@ -68768,22 +68828,22 @@ Launching:
     --[no-]wait                  with @pool:<name>, sleep until the earliest member returns when all are refused
 
 Environment:
-  CLAUDE_USE_IDENTITY, CLAUDE_USE_CONFIG_PROFILE, CLAUDE_USE_SKIP_PERMISSIONS,
-  CLAUDE_USE_REMOTE_CONTROL, CLAUDE_USE_HEADROOM, CLAUDE_USE_TRACK_USAGE, CLAUDE_USE_ALLOW_AMBIENT_CREDENTIAL,
-  CLAUDE_USE_CATEGORY_OVERRIDE, CLAUDE_USE_ENTRY_OVERRIDE, CLAUDE_USE_HOME,
-  CLAUDE_USE_DEBUG (print stack traces), NO_COLOR. Booleans are true, false, 1 or 0.
+  AGENT_SHIM_IDENTITY, AGENT_SHIM_CONFIG_PROFILE, AGENT_SHIM_SKIP_PERMISSIONS,
+  AGENT_SHIM_REMOTE_CONTROL, AGENT_SHIM_HEADROOM, AGENT_SHIM_TRACK_USAGE, AGENT_SHIM_ALLOW_AMBIENT_CREDENTIAL,
+  AGENT_SHIM_CATEGORY_OVERRIDE, AGENT_SHIM_ENTRY_OVERRIDE, AGENT_SHIM_HOME,
+  AGENT_SHIM_DEBUG (print stack traces), NO_COLOR. Booleans are true, false, 1 or 0.
 
 Exit status:
   0 success, 1 failure, 2 usage error, 64 a selected provider's or identity's credential
   yields no token.
 
 Examples:
-  $ claude-use identity add work
-  $ claude-use run @work
-  $ claude-use run --identity work --provider z -p "hello"`;
+  $ agent-shim identity add work
+  $ agent-shim run @work
+  $ agent-shim run --identity work --provider z -p "hello"`;
 function buildProgram(deps) {
   const program2 = new Command();
-  program2.name("claude-use").description("Run Claude Code under several logins from one machine, controlling what each one shares with ~/.claude.").version(package_default.version).exitOverride().enablePositionalOptions().addHelpText("after", ROOT_HELP_AFTER);
+  program2.name("agent-shim").description("Run Claude Code under several logins from one machine, controlling what each one shares with ~/.claude.").version(package_default.version).exitOverride().enablePositionalOptions().addHelpText("after", ROOT_HELP_AFTER);
   registerIdentityCommand(program2, deps);
   registerProfileCommand(program2, deps);
   registerPoolCommand(program2, deps);
@@ -68859,8 +68919,8 @@ function parseOverride(source, raw, parse3) {
 }
 function buildCliOverride(params) {
   let categoryPairs = {};
-  if (params.env.CLAUDE_USE_CATEGORY_OVERRIDE !== void 0 && params.env.CLAUDE_USE_CATEGORY_OVERRIDE !== "") {
-    categoryPairs = parseOverride("CLAUDE_USE_CATEGORY_OVERRIDE", params.env.CLAUDE_USE_CATEGORY_OVERRIDE, parseBoolPairList);
+  if (params.env.AGENT_SHIM_CATEGORY_OVERRIDE !== void 0 && params.env.AGENT_SHIM_CATEGORY_OVERRIDE !== "") {
+    categoryPairs = parseOverride("AGENT_SHIM_CATEGORY_OVERRIDE", params.env.AGENT_SHIM_CATEGORY_OVERRIDE, parseBoolPairList);
   }
   for (const flagValue of params.categoryFlags) {
     const pair = parseOverride("--category", flagValue, (raw) => {
@@ -68870,8 +68930,8 @@ function buildCliOverride(params) {
     categoryPairs[pair.key] = pair.value;
   }
   let entryPairs = {};
-  if (params.env.CLAUDE_USE_ENTRY_OVERRIDE !== void 0 && params.env.CLAUDE_USE_ENTRY_OVERRIDE !== "") {
-    entryPairs = parseOverride("CLAUDE_USE_ENTRY_OVERRIDE", params.env.CLAUDE_USE_ENTRY_OVERRIDE, parseBoolPairList);
+  if (params.env.AGENT_SHIM_ENTRY_OVERRIDE !== void 0 && params.env.AGENT_SHIM_ENTRY_OVERRIDE !== "") {
+    entryPairs = parseOverride("AGENT_SHIM_ENTRY_OVERRIDE", params.env.AGENT_SHIM_ENTRY_OVERRIDE, parseBoolPairList);
   }
   for (const entryPath of params.shareFlags) {
     entryPairs[entryPath] = true;
@@ -68930,10 +68990,10 @@ function parseCustomHeaderLine(line) {
 // src/launcher/flags.ts
 function resolveLaunchFlags(params) {
   return {
-    skipPermissions: params.flags?.skipPermissions ?? parseEnvBool("CLAUDE_USE_SKIP_PERMISSIONS", params.env.CLAUDE_USE_SKIP_PERMISSIONS) ?? params.cascade?.skipPermissions ?? false,
-    remoteControl: params.flags?.remoteControl ?? parseEnvBool("CLAUDE_USE_REMOTE_CONTROL", params.env.CLAUDE_USE_REMOTE_CONTROL) ?? params.cascade?.remoteControl ?? false,
-    headroom: params.flags?.headroom ?? parseEnvBool("CLAUDE_USE_HEADROOM", params.env.CLAUDE_USE_HEADROOM) ?? params.cascade?.headroom ?? false,
-    trackUsage: params.flags?.trackUsage ?? parseEnvBool("CLAUDE_USE_TRACK_USAGE", params.env.CLAUDE_USE_TRACK_USAGE) ?? params.cascade?.trackUsage ?? params.trackUsageDefault ?? false
+    skipPermissions: params.flags?.skipPermissions ?? parseEnvBool("AGENT_SHIM_SKIP_PERMISSIONS", params.env.AGENT_SHIM_SKIP_PERMISSIONS) ?? params.cascade?.skipPermissions ?? false,
+    remoteControl: params.flags?.remoteControl ?? parseEnvBool("AGENT_SHIM_REMOTE_CONTROL", params.env.AGENT_SHIM_REMOTE_CONTROL) ?? params.cascade?.remoteControl ?? false,
+    headroom: params.flags?.headroom ?? parseEnvBool("AGENT_SHIM_HEADROOM", params.env.AGENT_SHIM_HEADROOM) ?? params.cascade?.headroom ?? false,
+    trackUsage: params.flags?.trackUsage ?? parseEnvBool("AGENT_SHIM_TRACK_USAGE", params.env.AGENT_SHIM_TRACK_USAGE) ?? params.cascade?.trackUsage ?? params.trackUsageDefault ?? false
   };
 }
 function buildFlagArgs(flags) {
@@ -68973,7 +69033,7 @@ function buildEnv(params) {
       env.NO_PROXY = withLoopbackHosts(params.baseEnv.NO_PROXY);
       env.no_proxy = withLoopbackHosts(params.baseEnv.no_proxy);
     }
-    env.CLAUDE_USE_PROVIDER = params.provider.definition.displayName;
+    env.AGENT_SHIM_PROVIDER = params.provider.definition.displayName;
     for (const [key, value] of Object.entries(providerEnv)) {
       env[key] = value;
     }
@@ -69049,19 +69109,19 @@ function spawnClaude(params) {
 // src/launcher.ts
 function resolveIdentityCredential(identity, credential, env, port) {
   if (port === void 0) {
-    return { ok: false, status: 1, message: `claude-use: identity ${identity} needs its credential resolved, but this launcher has no credential port wired` };
+    return { ok: false, status: 1, message: `agent-shim: identity ${identity} needs its credential resolved, but this launcher has no credential port wired` };
   }
   const resolution = resolveCredential({ credential, env, port, subject: `identity ${identity}` });
   return resolution.ok ? resolution : { ok: false, status: CREDENTIAL_UNAVAILABLE_EXIT, message: resolution.message };
 }
 function pickFromPool(decided, params, parsedArgv) {
-  const { paths, fs: fs16, proc, log } = params;
+  const { paths, fs: fs17, proc, log } = params;
   if (decided.pool === void 0) {
     return { identityDecision: decided };
   }
   const farmRuntime = params.farm;
   if (farmRuntime === void 0) {
-    log.error(`claude-use: pool "${decided.pool}" was selected, but this launcher has no farm wired to read usage and pick a member with.`);
+    log.error(`agent-shim: pool "${decided.pool}" was selected, but this launcher has no farm wired to read usage and pick a member with.`);
     return proc.exit(1);
   }
   const resolution = resolvePoolLaunch({
@@ -69069,7 +69129,7 @@ function pickFromPool(decided, params, parsedArgv) {
     selectedVia: decided.source,
     pools: params.pools,
     paths,
-    fs: fs16,
+    fs: fs17,
     usageFs: farmRuntime.fs,
     cwd: farmRuntime.cwd,
     now: farmRuntime.now,
@@ -69085,7 +69145,7 @@ function pickFromPool(decided, params, parsedArgv) {
   return { identityDecision: { ...decided, name: resolution.identity }, poolExplanation: resolution.explanation };
 }
 function runLauncher(params) {
-  const { paths, fs: fs16, spawn: spawn3, proc, log } = params;
+  const { paths, fs: fs17, spawn: spawn3, proc, log } = params;
   const { env, argv } = proc;
   const parsedArgv = parseLauncherArgv(argv);
   const cliOverride = buildCliOverride({
@@ -69100,7 +69160,7 @@ function runLauncher(params) {
     argv0Identity: parsedArgv.identity,
     directoryPinnedIdentity: params.directoryPinnedIdentity,
     readActiveIdentityFile: () => {
-      const raw = fs16.readFileUtf8(paths.activeIdentityFile);
+      const raw = fs17.readFileUtf8(paths.activeIdentityFile);
       if (raw === void 0) {
         return void 0;
       }
@@ -69130,15 +69190,15 @@ function runLauncher(params) {
       throw error62;
     }
     for (const diagnostic of recoveryDiagnostics(recovery, farmIdentity)) {
-      log.warn(`claude-use: ${diagnostic.code}: ${diagnostic.message}`);
+      log.warn(`agent-shim: ${diagnostic.code}: ${diagnostic.message}`);
     }
   }
   let loadedIdentity;
   if (identityDecision.name !== void 0) {
-    loadedIdentity = loadIdentity(paths.identitiesDir, identityDecision.name, fs16);
+    loadedIdentity = loadIdentity(paths.identitiesDir, identityDecision.name, fs17);
     if (loadedIdentity === void 0) {
       log.error(
-        `claude-use: no identity named "${identityDecision.name}" (selected via ${identityDecision.source}). Run \`claude-use identity add ${identityDecision.name}\` first.`
+        `agent-shim: no identity named "${identityDecision.name}" (selected via ${identityDecision.source}). Run \`agent-shim identity add ${identityDecision.name}\` first.`
       );
       proc.exit(1);
     }
@@ -69150,16 +69210,16 @@ function runLauncher(params) {
     identityDefaultConfigProfile: loadedIdentity?.config.defaultConfigProfile,
     globalDefaultConfigProfile: params.globalDefaultConfigProfile
   });
-  if (configProfileDecision.name !== void 0 && params.allowMissingConfigProfile !== true && fs16.readConfigFile(import_node_path34.default.join(paths.configProfilesDir, `${configProfileDecision.name}.json`)) === void 0) {
+  if (configProfileDecision.name !== void 0 && params.allowMissingConfigProfile !== true && fs17.readConfigFile(import_node_path34.default.join(paths.configProfilesDir, `${configProfileDecision.name}.json`)) === void 0) {
     log.error(
-      `claude-use: no configuration profile named "${configProfileDecision.name}" (selected via ${configProfileDecision.source}). Run \`claude-use profile add ${configProfileDecision.name}\` first.`
+      `agent-shim: no configuration profile named "${configProfileDecision.name}" (selected via ${configProfileDecision.source}). Run \`agent-shim profile add ${configProfileDecision.name}\` first.`
     );
     proc.exit(1);
   }
   const farmContext = farm !== void 0 && farmIdentity !== void 0 ? { farm, identity: farmIdentity, cascade: farm.loadCascade(configProfileDecision.name, cliOverride) } : void 0;
   const provider = parsedArgv.provider === false ? void 0 : resolveProvider({
     paths,
-    port: fs16,
+    port: fs17,
     env,
     ...params.credentials === void 0 ? {} : { credentials: params.credentials },
     ...parsedArgv.provider === void 0 ? {} : { cliProvider: parsedArgv.provider },
@@ -69183,7 +69243,7 @@ function runLauncher(params) {
       if (!(error62 instanceof UsageSnapshotError)) {
         throw error62;
       }
-      log.warn(`claude-use: ${error62.message}`);
+      log.warn(`agent-shim: ${error62.message}`);
     }
   }
   const identityCredentialBlock = loadedIdentity?.config.credential;
@@ -69199,7 +69259,7 @@ function runLauncher(params) {
   const guardResult = evaluateAmbientCredentialGuard({
     env,
     allowAmbientCredential: loadedIdentity?.config.allowAmbientCredential ?? false,
-    allowAmbientCredentialOverride: parseEnvBool("CLAUDE_USE_ALLOW_AMBIENT_CREDENTIAL", env.CLAUDE_USE_ALLOW_AMBIENT_CREDENTIAL) === true,
+    allowAmbientCredentialOverride: parseEnvBool("AGENT_SHIM_ALLOW_AMBIENT_CREDENTIAL", env.AGENT_SHIM_ALLOW_AMBIENT_CREDENTIAL) === true,
     identityName: identityDecision.name,
     providerSelected: resolvedProvider !== void 0,
     ...identityCredential === void 0 ? {} : { injectedCredential: { variable: CREDENTIAL_TARGET_VARS[identityCredential.target], token: identityCredential.token } }
@@ -69209,7 +69269,7 @@ function runLauncher(params) {
     proc.exit(1);
   }
   log.info(
-    `claude-use: identity ${identityDecision.name ?? "(none)"} (${identityDecision.source}${poolExplanation === void 0 ? "" : `, ${poolExplanation}`}), config profile ${configProfileDecision.name ?? "(none)"} (${configProfileDecision.source})` + (resolvedProvider === void 0 ? "" : `, provider ${resolvedProvider.name} (credential ${resolvedProvider.credential.target} from ${describeSource(resolvedProvider.credential.source)})`) + (identityCredential === void 0 ? "" : `, identity credential ${identityCredential.target} from ${describeSource(identityCredential.source)}`)
+    `agent-shim: identity ${identityDecision.name ?? "(none)"} (${identityDecision.source}${poolExplanation === void 0 ? "" : `, ${poolExplanation}`}), config profile ${configProfileDecision.name ?? "(none)"} (${configProfileDecision.source})` + (resolvedProvider === void 0 ? "" : `, provider ${resolvedProvider.name} (credential ${resolvedProvider.credential.target} from ${describeSource(resolvedProvider.credential.source)})`) + (identityCredential === void 0 ? "" : `, identity credential ${identityCredential.target} from ${describeSource(identityCredential.source)}`)
   );
   let cascadeLaunch;
   if (farmContext !== void 0) {
@@ -69242,13 +69302,13 @@ function runLauncher(params) {
     }
     for (const diagnostic of result.diagnostics) {
       if (diagnostic.severity === "error") {
-        log.error(`claude-use: ${diagnostic.code}: ${diagnostic.message}`);
+        log.error(`agent-shim: ${diagnostic.code}: ${diagnostic.message}`);
       } else if (diagnostic.severity === "warning") {
-        log.warn(`claude-use: ${diagnostic.code}: ${diagnostic.message}`);
+        log.warn(`agent-shim: ${diagnostic.code}: ${diagnostic.message}`);
       }
     }
     log.info(
-      result.noOp ? `claude-use: farm at ${result.farmRoot} already matches the resolved cascade` : `claude-use: farm at ${result.farmRoot} resynced (${String(result.manifest.links.length)} link(s), ${String(result.manifest.materialised.length)} built director(ies)${result.adopted.length === 0 ? "" : `, ${String(result.adopted.length)} adopted into ${resyncFarmRuntime.claudeHome}`})`
+      result.noOp ? `agent-shim: farm at ${result.farmRoot} already matches the resolved cascade` : `agent-shim: farm at ${result.farmRoot} resynced (${String(result.manifest.links.length)} link(s), ${String(result.manifest.materialised.length)} built director(ies)${result.adopted.length === 0 ? "" : `, ${String(result.adopted.length)} adopted into ${resyncFarmRuntime.claudeHome}`})`
     );
     cascadeLaunch = result.resolved.flattened.launch;
   } else if (params.farm !== void 0) {
@@ -69270,7 +69330,7 @@ function runLauncher(params) {
   const frontDoorPort = params.frontdoor;
   const frontDoorEngaged = resolvedProvider !== void 0 || resolvedFlags.headroom || resolvedFlags.trackUsage;
   if (frontDoorEngaged && frontDoorPort === void 0) {
-    log.error("claude-use: this launch routes through the front-door daemon, but this launcher has no front-door port wired; refusing to launch without it.");
+    log.error("agent-shim: this launch routes through the front-door daemon, but this launcher has no front-door port wired; refusing to launch without it.");
     proc.exit(1);
   }
   const frontDoor = frontDoorEngaged && frontDoorPort !== void 0 ? frontDoorPort.ensure(env.NODE_EXTRA_CA_CERTS) : void 0;
@@ -69286,12 +69346,12 @@ function runLauncher(params) {
   if (resolvedFlags.headroom && headroomPort !== void 0) {
     headroom = headroomPort.ensure();
     const via = resolvedProvider === void 0 ? `OAuth via the door's CONNECT surface on 127.0.0.1:${String(frontDoor?.connectPort ?? 0)}` : `provider ${resolvedProvider.name}`;
-    log.info(`claude-use: routing through the front door on 127.0.0.1:${String(frontDoor?.port ?? 0)} with headroom on 127.0.0.1:${String(headroom.port)} (${via}, project ${headroom.projectId})`);
+    log.info(`agent-shim: routing through the front door on 127.0.0.1:${String(frontDoor?.port ?? 0)} with headroom on 127.0.0.1:${String(headroom.port)} (${via}, project ${headroom.projectId})`);
   } else if (resolvedFlags.headroom) {
-    log.error("claude-use: headroom routing was requested but this launcher has no headroom port wired; refusing to launch without it.");
+    log.error("agent-shim: headroom routing was requested but this launcher has no headroom port wired; refusing to launch without it.");
     proc.exit(1);
   } else if (frontDoor !== void 0) {
-    log.info(`claude-use: routing through the front door on 127.0.0.1:${String(frontDoor.port)}${resolvedProvider === void 0 ? ` (OAuth via the door's CONNECT surface on 127.0.0.1:${String(frontDoor.connectPort)}, usage recorded)` : ` (provider ${resolvedProvider.name})`}`);
+    log.info(`agent-shim: routing through the front door on 127.0.0.1:${String(frontDoor.port)}${resolvedProvider === void 0 ? ` (OAuth via the door's CONNECT surface on 127.0.0.1:${String(frontDoor.connectPort)}, usage recorded)` : ` (provider ${resolvedProvider.name})`}`);
   }
   const frontDoorRelease = frontDoor === void 0 ? void 0 : frontDoorPort?.release;
   const finalArgv = buildArgv({
@@ -69442,7 +69502,8 @@ async function runClaude(argvOverride) {
 
 // src/cli.ts
 async function main() {
-  const invokedName = import_node_path35.default.basename(process.argv[1] ?? "claude-use");
+  aliasLegacyEnv(process.env);
+  const invokedName = import_node_path35.default.basename(process.argv[1] ?? "agent-shim");
   if (isInvokedAsClaude(invokedName)) {
     await runClaude();
     return;