agent-shim 11.78.0 → 11.79.0

package/README.md

@@ -57,7 +57,7 @@ That's it — with no further configuration, everything in `~/.claude` that isn'
 - **An identity** is a login: the thing that owns credentials and daemon state, selected with `agent-shim run @<name>` or, once `agent-shim shim enable` has run, `claude @<name>`.
 - **A configuration profile** is a reusable, named bundle of sharing rules, independent of any identity, resolved per working directory via directory rules or a committed `.agent-shim.json`.
 
-A third, optional thing sits on top of identities: **a pool** is a named list of them. Select `pool:<name>` where an identity name goes (`claude @pool:subs`) and agent-shim picks the member whose unused quota is closest to expiring, skipping any that are refused right now, using the usage it already records. A pool can instead declare `--preference listed`, which tries the members in the order the pool lists them, skipping only one that is refused right now. A member entry may itself name another pool (`pool:<name>`), which is ranked with its own policy and contributes its pick at that position, so "this identity first, then the fleet" nests the fleet rather than copying its member list; cycles are refused. See [docs/configuration-model.md](docs/configuration-model.md#pools-picking-an-account-at-launch).
+A third, optional thing sits on top of identities: **a pool** is a named list of them. Select `pool:<name>` where an identity name goes (`claude @pool:subs`) and agent-shim picks the member whose unused quota is closest to expiring, skipping any that are refused right now, using the usage it already records. A pool can instead declare `--preference listed`, which tries the members in the order the pool lists them, skipping only one that is refused right now. A member entry may itself name another pool (`pool:<name>`), which is ranked with its own policy and contributes its pick at that position, so "this identity first, then the fleet" nests the fleet rather than copying its member list; cycles are refused. See [docs/configuration-model.md](docs/configuration-model.md#pools-picking-an-account-at-launch). On a terminal, `agent-shim run` asks which identity to run as when none resolves, when a pool pick would change account, or when the identity is refused right now (`--pick` forces the question, `--no-pick` never asks); see [docs/configuration-model.md](docs/configuration-model.md#choosing-the-identity-at-launch-the-picker).
 
 Every top-level entry in `~/.claude` is classified into one of five categories, shipped as a default map (`config/categories.default.json`):
 
@@ -200,6 +200,7 @@ agent-shim run [@<identity>] [launch flags] [claude arguments]
   #   --claude-version <version>   run exactly this installed Claude Code version
   #   --delay <duration>   wait this long after the launcher's own output before starting claude; --[no-]pause waits for a key press instead
   #   --[no-]explain   with @pool:<name>, list every member the pick ranked and why, not only the one picked
+  #   --[no-]pick   on a terminal, ask which identity to run as, even when one resolved (--no-pick never asks); a launch also asks by itself when no identity resolves, a pool pick would change account or organisation, or the identity is refused right now
   #   --native   run the real claude with nothing from agent-shim applied; cannot be combined with the flags above
 claude @<identity> ...                      # the same, once `agent-shim shim enable` has run
 ```

package/dist/cli.cjs

@@ -38198,7 +38198,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "agent-shim",
-      version: "11.78.0",
+      version: "11.79.0",
       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: "MIT",
       author: "Joseph Mearman <joseph@mearman.co.uk>",
@@ -67175,7 +67175,8 @@ var init_argv = __esm({
       { flag: "--remote-control", key: "remoteControl" },
       { flag: "--wait", key: "wait" },
       { flag: "--pause", key: "pause" },
-      { flag: "--explain", key: "explain" }
+      { flag: "--explain", key: "explain" },
+      { flag: "--pick", key: "pick" }
     ];
     LAUNCHER_FLAG_NAMES = [
       ...VALUED_FLAGS,
@@ -69956,7 +69957,7 @@ function decideLaunch(params, readOnly) {
   const configDirEscapeHatchApplies = env.CLAUDE_CONFIG_DIR !== void 0 && env.CLAUDE_CONFIG_DIR !== "";
   const decidedIdentity = decideIdentity({
     env,
-    argv0Identity: parsedArgv.identity,
+    argv0Identity: params.pickedIdentity ?? parsedArgv.identity,
     directoryPinnedIdentity: params.directoryPinnedIdentity,
     readActiveIdentityFile: () => {
       const raw = fs31.readFileUtf8(paths.activeIdentityFile);
@@ -157820,6 +157821,241 @@ function buildProgram(deps) {
 // src/runClaude.ts
 init_cliError();
 init_configProfilesStore();
+
+// src/launcher/pickerPrompt.ts
+function promptsIdentityPicker(prompts) {
+  return {
+    pick: async (request7) => {
+      const answer = await prompts.select({
+        message: request7.message,
+        options: request7.entries.map((entry) => ({ value: entry.value, label: entry.label })),
+        ...request7.initial === void 0 ? {} : { initialValue: request7.initial }
+      });
+      return prompts.isCancel(answer) ? { kind: "cancelled" } : { kind: "picked", value: answer };
+    }
+  };
+}
+
+// src/launcher/runPicker.ts
+init_cliError();
+init_schema();
+init_account();
+init_candidateText();
+init_pick();
+init_poolPick();
+init_identity();
+init_launchReport();
+init_hold();
+
+// src/launcher/pickerEntries.ts
+var PART_SEPARATOR = " | ";
+function pickerLabel(facts) {
+  const name = [facts.rank === void 0 ? void 0 : `${String(facts.rank)}.`, facts.identity, facts.heading, facts.picked === true ? "(picked)" : void 0].filter((part) => part !== void 0).join(" ");
+  return [name, facts.detail, facts.account, facts.quota].filter((part) => part !== void 0).join(PART_SEPARATOR);
+}
+
+// src/launcher/pickerDecision.ts
+init_claudeSubcommand();
+function decidePicker(facts) {
+  if (!facts.interactive || facts.configDirEscapeHatch || facts.pick === false) {
+    return void 0;
+  }
+  if (facts.pick === true) {
+    return "requested";
+  }
+  if (facts.unattended) {
+    return void 0;
+  }
+  const { selection } = facts;
+  switch (selection.kind) {
+    case "none":
+      return "no-identity";
+    case "identity":
+      return selection.limited ? "no-eligible-identity" : void 0;
+    case "pool":
+      if (selection.outcome === "none-eligible") {
+        return facts.waiting ? void 0 : "no-eligible-identity";
+      }
+      return selection.outcome === "changes-account" ? "account-change" : void 0;
+    default:
+      return selection;
+  }
+}
+var TERMINATOR4 = "--";
+var UNATTENDED_FLAGS = /* @__PURE__ */ new Set(["-p", "--print", "--bg"]);
+function isUnattendedLaunch(passthrough) {
+  const end = passthrough.indexOf(TERMINATOR4);
+  const head = end === -1 ? passthrough : passthrough.slice(0, end);
+  return head.some((token) => UNATTENDED_FLAGS.has(token)) || isClaudeSubcommand(passthrough);
+}
+
+// src/launcher/runPicker.ts
+init_pool();
+var IdentityPickerCancelledError = class extends CliError {
+  exitCode = LAUNCH_CANCELLED_EXIT;
+  constructor() {
+    super("launch cancelled at the identity picker: no identity was chosen.");
+    this.name = "IdentityPickerCancelledError";
+  }
+};
+function memberTexts(member, nowMs) {
+  if (member === void 0) {
+    return {};
+  }
+  const billing = { login: member.account, snapshot: member.snapshot, provider: void 0, nowMs };
+  const account = accountRows(billing)[0]?.value;
+  const quotaRow2 = quotaRows(billing)[0];
+  return {
+    ...account === void 0 ? {} : { account },
+    ...quotaRow2 === void 0 ? {} : { quota: quotaRow2.detail === void 0 ? quotaRow2.value : `${quotaRow2.value} (${quotaRow2.detail})` }
+  };
+}
+function refusalOf(candidate) {
+  return candidate.class === "ineligible" ? candidate.reasons[0] : void 0;
+}
+function accountsDiffer(members2, left, right) {
+  const keyOf3 = (identity) => {
+    const account = members2.find((member) => member.identity === identity)?.account;
+    return account === void 0 ? void 0 : loginKeyOf(account);
+  };
+  const leftKey = keyOf3(left);
+  const rightKey = keyOf3(right);
+  return leftKey !== void 0 && rightKey !== void 0 && leftKey !== rightKey;
+}
+function poolContext(params, poolName, resuming, nowMs) {
+  const { paths, usageFs } = params;
+  const { sticky } = readStickyPick(usageFs, paths.usagePicksFile, params.cwd);
+  const { ranking } = rankPoolGraph({
+    fs: usageFs,
+    paths,
+    pools: params.pools ?? {},
+    poolName,
+    nowMs,
+    resuming,
+    identityExists: (name) => loadIdentity(paths.identitiesDir, name, params.fs) !== void 0,
+    ...sticky === void 0 ? {} : { sticky }
+  });
+  const pick2 = ranking.pick?.identity;
+  const named = [.../* @__PURE__ */ new Set([...ranking.candidates.map((candidate) => candidate.identity), ...sticky === void 0 ? [] : [sticky.identity]])].filter(isIdentityName);
+  const members2 = loadPoolMembers(usageFs, paths, named, nowMs);
+  const changes = pick2 !== void 0 && sticky !== void 0 && sticky.identity !== pick2 && accountsDiffer(members2, sticky.identity, pick2);
+  return {
+    selection: { kind: "pool", outcome: pick2 === void 0 ? "none-eligible" : changes ? "changes-account" : "keeps-account" },
+    entries: ranking.candidates.map((candidate, index) => ({
+      value: candidate.identity,
+      label: pickerLabel({
+        identity: candidate.identity,
+        rank: index + 1,
+        heading: candidateHeading(candidate),
+        picked: candidate.identity === pick2,
+        detail: refusalOf(candidate),
+        ...memberTexts(members2.find((member) => member.identity === candidate.identity), nowMs)
+      })
+    })),
+    initial: pick2,
+    poolPick: pick2,
+    message: (reason) => poolMessage(reason, poolName, pick2, sticky)
+  };
+}
+function poolMessage(reason, poolName, pick2, sticky) {
+  switch (reason) {
+    case "account-change":
+      return `Pool "${poolName}" would run this launch as ${pick2 ?? "(none)"}, a different account from ${sticky?.identity ?? "(none)"}, which this directory last ran as. Which identity should it run as?`;
+    case "no-eligible-identity":
+      return `Every member of pool "${poolName}" is refused right now. Which identity should this launch run as?`;
+    case "requested":
+    case "no-identity":
+      return `Pool "${poolName}" is selected for this launch. Which identity should it run as?`;
+    default:
+      return reason;
+  }
+}
+function identityContext(params, resuming, nowMs) {
+  const { paths, usageFs } = params;
+  const members2 = loadPoolMembers(usageFs, paths, params.identityNames(), nowMs);
+  const { candidates } = rankPool({ members: members2, nowMs, resuming, preference: "listed" });
+  const named = params.decision.name;
+  const limited = named !== void 0 && candidates.some((candidate) => candidate.identity === named && candidate.class === "ineligible");
+  const identityEntries = candidates.map((candidate) => ({
+    value: candidate.identity,
+    label: pickerLabel({ identity: candidate.identity, detail: refusalOf(candidate), ...memberTexts(members2.find((member) => member.identity === candidate.identity), nowMs) })
+  }));
+  const poolEntries = Object.entries(params.pools ?? {}).map(([name, pool]) => ({
+    value: `pool:${name}`,
+    label: pickerLabel({ identity: `pool:${name}`, detail: `members ${pool.identities.map(poolMemberIdentity).join(", ")}` })
+  }));
+  return {
+    selection: named === void 0 ? { kind: "none" } : { kind: "identity", limited },
+    entries: [...identityEntries, ...poolEntries],
+    initial: named,
+    poolPick: void 0,
+    message: (reason) => {
+      switch (reason) {
+        case "no-identity":
+          return "No identity is selected for this launch. Which identity should it run as?";
+        case "no-eligible-identity":
+          return `${named ?? "The selected identity"} is refused right now. Which identity should this launch run as?`;
+        case "requested":
+        case "account-change":
+          return "Which identity should this launch run as?";
+        default:
+          return reason;
+      }
+    }
+  };
+}
+async function runIdentityPicker(params) {
+  if (!params.interactive) {
+    return { kind: "unchanged" };
+  }
+  const nowMs = params.now();
+  const resuming = isResuming(params.parsed.rest);
+  const context = params.decision.pool === void 0 ? identityContext(params, resuming, nowMs) : poolContext(params, params.decision.pool, resuming, nowMs);
+  const reason = decidePicker({
+    interactive: params.interactive,
+    unattended: isUnattendedLaunch(params.parsed.rest),
+    pick: params.parsed.pick,
+    configDirEscapeHatch: params.decision.configDirEscapeHatch,
+    waiting: params.parsed.wait === true,
+    selection: context.selection
+  });
+  if (reason === void 0) {
+    return { kind: "unchanged" };
+  }
+  const request7 = { message: context.message(reason), entries: context.entries, ...context.initial === void 0 ? {} : { initial: context.initial } };
+  const answer = await params.picker.pick(request7);
+  if (answer.kind === "cancelled") {
+    return { kind: "cancelled" };
+  }
+  const chosen = answer.value;
+  if (chosen === (params.decision.pool === void 0 ? params.decision.name : context.poolPick)) {
+    return { kind: "unchanged" };
+  }
+  if (params.decision.pool !== void 0 && poolNameOf(chosen) === void 0) {
+    recordStickyPick(params.usageFs, params.paths.usagePicksFile, params.cwd, chosen, nowMs);
+  }
+  return { kind: "selected", selector: chosen };
+}
+
+// src/launchPicker.ts
+init_realPorts();
+async function pickLaunchIdentity(params) {
+  return await runIdentityPicker({
+    parsed: params.parsed,
+    decision: params.decision,
+    interactive: process.stdin.isTTY && process.stdout.isTTY,
+    paths: params.paths,
+    fs: realFsPort,
+    usageFs: params.farm.runtime.fs,
+    pools: params.farm.pools,
+    cwd: params.farm.runtime.cwd,
+    now: params.farm.runtime.now,
+    identityNames: () => listIdentities(params.paths).flatMap((listing) => "problem" in listing ? [] : [listing.name]),
+    picker: promptsIdentityPicker(realPromptsPort)
+  });
+}
+
+// src/runClaude.ts
 init_launchWiring();
 init_paths();
 
@@ -158589,6 +158825,7 @@ function otherLaunchFlags(parsed) {
     ...parsed.skipPermissions === void 0 ? [] : ["--[no-]skip-permissions"],
     ...parsed.remoteControl === void 0 ? [] : ["--[no-]remote-control"],
     ...parsed.wait === void 0 ? [] : ["--[no-]wait"],
+    ...parsed.pick === void 0 ? [] : ["--[no-]pick"],
     ...parsed.categoryFlags.length === 0 ? [] : ["--category"],
     ...parsed.shareFlags.length === 0 ? [] : ["--share"],
     ...parsed.hideFlags.length === 0 ? [] : ["--hide"]
@@ -158654,13 +158891,19 @@ async function runClaude(argvOverride) {
       }
     }
   }
-  await refreshPools({
-    paths,
-    cwd: process.cwd(),
-    poolNames: identityDecision.pool === void 0 ? [] : [identityDecision.pool],
-    spawnDaemon: spawnDetachedSupervisor,
-    log: realLogPort.warn
-  });
+  const refreshUsage = async (poolName2) => {
+    await refreshPools({ paths, cwd: process.cwd(), poolNames: poolName2 === void 0 ? [] : [poolName2], spawnDaemon: spawnDetachedSupervisor, log: realLogPort.warn });
+  };
+  await refreshUsage(identityDecision.pool);
+  const picked = await pickLaunchIdentity({ paths, farm, parsed: nativeArgv, decision: identityDecision });
+  if (picked.kind === "cancelled") {
+    throw new IdentityPickerCancelledError();
+  }
+  const pickedIdentity = picked.kind === "selected" ? picked.selector : void 0;
+  const launchDecision = pickedIdentity === void 0 ? identityDecision : decideIdentity({ env: procForDecision.env, argv0Identity: pickedIdentity, readActiveIdentityFile: () => void 0 });
+  if (launchDecision.pool !== identityDecision.pool) {
+    await refreshUsage(launchDecision.pool);
+  }
   const prepareParams = {
     ...realPrepareLaunchParams(paths, {
       proc: argvOverride === void 0 ? realProcPort : { ...realProcPort, argv: argvOverride },
@@ -158669,10 +158912,11 @@ async function runClaude(argvOverride) {
       farm,
       allowMissingConfigProfile
     }),
+    ...pickedIdentity === void 0 ? {} : { pickedIdentity },
     // Wired here rather than in realPrepareLaunchParams because the port re-invokes this very binary: correct for the agent-shim command line, wrong for a library host whose own executable is not agent-shim.
     update: realLaunchUpdatePort(paths)
   };
-  const poolName = identityDecision.pool;
+  const poolName = launchDecision.pool;
   if (poolName !== void 0 && farm.pools !== void 0 && supervisesLaunch(farm.pools[poolName], nativeArgv.rest)) {
     const code = await runSupervised({
       paths,

package/dist/index.cjs

@@ -4764,7 +4764,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "agent-shim",
-      version: "11.78.0",
+      version: "11.79.0",
       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: "MIT",
       author: "Joseph Mearman <joseph@mearman.co.uk>",
@@ -10726,7 +10726,8 @@ var init_argv = __esm({
       { flag: "--remote-control", key: "remoteControl" },
       { flag: "--wait", key: "wait" },
       { flag: "--pause", key: "pause" },
-      { flag: "--explain", key: "explain" }
+      { flag: "--explain", key: "explain" },
+      { flag: "--pick", key: "pick" }
     ];
     LAUNCHER_FLAG_NAMES = [
       ...VALUED_FLAGS,
@@ -11812,7 +11813,7 @@ function decideLaunch(params, readOnly) {
   const configDirEscapeHatchApplies = env.CLAUDE_CONFIG_DIR !== void 0 && env.CLAUDE_CONFIG_DIR !== "";
   const decidedIdentity = decideIdentity({
     env,
-    argv0Identity: parsedArgv.identity,
+    argv0Identity: params.pickedIdentity ?? parsedArgv.identity,
     directoryPinnedIdentity: params.directoryPinnedIdentity,
     readActiveIdentityFile: () => {
       const raw = fs14.readFileUtf8(paths.activeIdentityFile);

package/dist/index.mjs

@@ -4740,7 +4740,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "agent-shim",
-      version: "11.78.0",
+      version: "11.79.0",
       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: "MIT",
       author: "Joseph Mearman <joseph@mearman.co.uk>",
@@ -10699,7 +10699,8 @@ var init_argv = __esm({
       { flag: "--remote-control", key: "remoteControl" },
       { flag: "--wait", key: "wait" },
       { flag: "--pause", key: "pause" },
-      { flag: "--explain", key: "explain" }
+      { flag: "--explain", key: "explain" },
+      { flag: "--pick", key: "pick" }
     ];
     LAUNCHER_FLAG_NAMES = [
       ...VALUED_FLAGS,
@@ -11787,7 +11788,7 @@ function decideLaunch(params, readOnly) {
   const configDirEscapeHatchApplies = env.CLAUDE_CONFIG_DIR !== void 0 && env.CLAUDE_CONFIG_DIR !== "";
   const decidedIdentity = decideIdentity({
     env,
-    argv0Identity: parsedArgv.identity,
+    argv0Identity: params.pickedIdentity ?? parsedArgv.identity,
     directoryPinnedIdentity: params.directoryPinnedIdentity,
     readActiveIdentityFile: () => {
       const raw = fs14.readFileUtf8(paths.activeIdentityFile);

package/dist/types/index.d.ts

@@ -14032,6 +14032,8 @@ interface PrepareLaunchParams {
     readonly log: LogPort;
     /** Discovers the real `claude` binary to spawn. Injected so `runLauncher` never depends on `src/versionDiscovery.ts`'s own filesystem/PATH inputs directly — the caller (`src/cli.ts`) wires the real discovery, tests wire a fake that returns a fixed path. */
     readonly resolveClaudeBinary: ClaudeBinaryResolver;
+    /** The identity (or `pool:<name>`) the person chose at the identity picker, which takes the place of whatever the arguments named: the question was asked because that choice was not settled. */
+    readonly pickedIdentity?: string;
     /** An identity pinned to `$PWD` by a directory rule. Accepted as an already-resolved value — the rules-loading code that produces it lands in Phase 4/5. */
     readonly directoryPinnedIdentity?: string;
     /** A directory rule's `configProfile` selection for `$PWD`. Accepted as an already-resolved value for the same reason. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-shim",
-  "version": "11.78.0",
+  "version": "11.79.0",
   "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": "MIT",
   "author": "Joseph Mearman <joseph@mearman.co.uk>",