agent-shim 8.32.0 → 8.34.0

package/dist/index.cjs

@@ -368,6 +368,7 @@ var categories_default_default = {
 // src/config/schema.ts
 var import_node_path2 = __toESM(require("node:path"), 1);
 var import_zod = require("zod");
+var import_trilean = require("trilean");
 
 // src/versionDiscovery.ts
 var import_node_os = __toESM(require("node:os"), 1);
@@ -498,13 +499,14 @@ var CategoryMapSchema = import_zod.z.strictObject({
 }).transform((input) => expandAllCategoryKey(input));
 var DURATION_RE = /^(?:0|[1-9][0-9]*)(?:ms|s|m|h|d|w)$/;
 var DurationSchema = import_zod.z.string().regex(DURATION_RE);
-var WhenSchema = import_zod.z.strictObject({
+var WhenConditionObjectSchema = import_zod.z.strictObject({
   newerThan: DurationSchema.optional(),
   olderThan: DurationSchema.optional(),
   maxSizeBytes: import_zod.z.int().positive().optional(),
   branch: import_zod.z.string().min(1).optional(),
   env: import_zod.z.record(import_zod.z.string().min(1), import_zod.z.string()).optional()
 });
+var WhenSchema = import_zod.z.union([WhenConditionObjectSchema, import_trilean.PredicateNodeSchema]);
 var EntryValueSchema = import_zod.z.union([
   import_zod.z.boolean(),
   import_zod.z.strictObject({ value: import_zod.z.boolean(), when: WhenSchema })
@@ -621,11 +623,14 @@ var IDENTITY_NAME_PATTERN = "[A-Za-z0-9][A-Za-z0-9._@-]*";
 var PoolNameSchema = import_zod.z.string().min(1).regex(new RegExp(`^${POOL_NAME_PATTERN}$`));
 var SELECTOR_RE = new RegExp(`^(${POOL_SELECTOR_PREFIX}${POOL_NAME_PATTERN}|${IDENTITY_NAME_PATTERN})$`);
 var IdentitySelectorSchema = import_zod.z.string().min(1).regex(SELECTOR_RE);
-var PoolMemberSchema = import_zod.z.string().min(1).regex(SELECTOR_RE);
+var PoolMemberSchema = import_zod.z.union([import_zod.z.string().min(1).regex(SELECTOR_RE), import_zod.z.strictObject({ identity: import_zod.z.string().min(1).regex(SELECTOR_RE), when: WhenSchema })]);
+function poolMemberIdentity(member) {
+  return typeof member === "string" ? member : member.identity;
+}
 var POOL_PREFERENCES = ["score", "listed"];
 var PoolPreferenceSchema = import_zod.z.enum(POOL_PREFERENCES);
 var PoolSchema = import_zod.z.strictObject({
-  identities: import_zod.z.array(PoolMemberSchema).min(1).refine((members) => new Set(members).size === members.length, { message: "pool members must be unique" }),
+  identities: import_zod.z.array(PoolMemberSchema).min(1).refine((members) => new Set(members.map(poolMemberIdentity)).size === members.length, { message: "pool members must be unique" }),
   preference: PoolPreferenceSchema.optional()
 });
 var DirectoryRuleSchema = ConfigProfileSchema.omit({ description: true }).extend({
@@ -969,6 +974,7 @@ function classifyEntries(names, options) {
 
 // src/resolve/conditions.ts
 var import_picomatch2 = __toESM(require("picomatch"), 1);
+var import_trilean2 = require("trilean");
 var MILLISECONDS_PER_UNIT = Object.freeze({
   ms: 1,
   s: 1e3,
@@ -999,52 +1005,87 @@ function matchBranch(pattern, branch, detached = false) {
   }
   return (0, import_picomatch2.default)(pattern, { dot: true, nocase: false })(branch);
 }
+var evaluator = (0, import_trilean2.createSyncEvaluator)({});
+function resolversOf(context) {
+  const pool = context.pool;
+  const values = {
+    now: context.nowMs,
+    ...context.fact?.latestMtimeMs === void 0 ? {} : { "entry.latestMtimeMs": context.fact.latestMtimeMs },
+    ...context.fact?.totalSizeBytes === void 0 ? {} : { "entry.totalSizeBytes": context.fact.totalSizeBytes },
+    ...context.branch === void 0 ? {} : { "repo.branch": context.branch },
+    "repo.detached": context.branchDetached ?? false,
+    ...pool?.fiveHour === void 0 ? {} : { "quota.fiveHour.remaining": pool.fiveHour.remaining, "quota.fiveHour.utilization": pool.fiveHour.utilization, "quota.fiveHour.hoursUntilReset": pool.fiveHour.hoursUntilReset },
+    ...pool?.sevenDay === void 0 ? {} : { "quota.sevenDay.remaining": pool.sevenDay.remaining, "quota.sevenDay.utilization": pool.sevenDay.utilization, "quota.sevenDay.hoursUntilReset": pool.sevenDay.hoursUntilReset },
+    ...pool?.burnPerHour === void 0 ? {} : { "quota.burnPerHour": pool.burnPerHour },
+    ...pool?.resuming === void 0 ? {} : { "session.resuming": pool.resuming },
+    ...pool?.lastPickHoursAgo === void 0 ? {} : { "session.lastPickHoursAgo": pool.lastPickHoursAgo }
+  };
+  return {
+    resolveValue: (key) => {
+      const wrap = (value2) => ({ found: true, value: typeof value2 === "number" ? { kind: "number", value: value2 } : typeof value2 === "string" ? { kind: "text", value: value2 } : { kind: "boolean", value: value2 } });
+      if (typeof key !== "string") {
+        return { found: false };
+      }
+      if (key.startsWith("env.")) {
+        const value2 = context.env[key.slice("env.".length)];
+        return value2 === void 0 ? { found: false } : wrap(value2);
+      }
+      const value = values[key];
+      return value === void 0 ? { found: false } : wrap(value);
+    },
+    // This embedding provides the reference namespace only: a tree that asks for a lookup or a collection finds neither, which the evaluator carries as indeterminate rather than letting the tree pretend an answer.
+    resolveLookup: () => ({ found: false }),
+    resolveCollection: () => []
+  };
+}
+function fieldPredicate(field, when, context) {
+  switch (field) {
+    case "newerThan": {
+      const window = parseDuration(when.newerThan ?? "");
+      return { kind: "compare", op: "gte", left: { kind: "reference", key: "entry.latestMtimeMs" }, right: { kind: "numberLiteral", value: context.nowMs - window } };
+    }
+    case "olderThan": {
+      const window = parseDuration(when.olderThan ?? "");
+      return { kind: "compare", op: "lt", left: { kind: "reference", key: "entry.latestMtimeMs" }, right: { kind: "numberLiteral", value: context.nowMs - window } };
+    }
+    case "maxSizeBytes":
+      return { kind: "compare", op: "lte", left: { kind: "reference", key: "entry.totalSizeBytes" }, right: { kind: "numberLiteral", value: when.maxSizeBytes ?? 0 } };
+    case "branch":
+      return { kind: "allOf", operands: [{ kind: "textCompare", op: "portableMatches", left: { kind: "reference", key: "repo.branch" }, right: { kind: "textLiteral", value: when.branch ?? "" } }, { kind: "compare", op: "eq", left: { kind: "reference", key: "repo.detached" }, right: { kind: "booleanLiteral", value: false } }] };
+    case "env": {
+      const entries = Object.entries(when.env ?? {});
+      return { kind: "allOf", operands: entries.map(([name, expected]) => ({ kind: "textCompare", op: "equals", left: { kind: "reference", key: `env.${name}` }, right: { kind: "textLiteral", value: expected } })) };
+    }
+  }
+  return { kind: "allOf", operands: [] };
+}
 function evaluateWhen(when, context) {
   if (when === void 0) {
-    return { passed: true, checked: [], failed: [] };
+    return { status: "definite", passed: true, checked: [], failed: [] };
+  }
+  if ("kind" in when) {
+    const result = evaluator.evaluatePredicate(when, void 0, resolversOf(context));
+    return result.status === "indeterminate" ? { status: "indeterminate", reason: result.reason.message, checked: ["predicate"] } : { status: "definite", passed: result.value, checked: ["predicate"], failed: result.value ? [] : ["predicate"] };
   }
   const checked = [];
   const failed = [];
-  if (when.newerThan !== void 0) {
-    checked.push("newerThan");
-    const window = parseDuration(when.newerThan);
-    const latest = context.fact?.latestMtimeMs;
-    if (latest === void 0 || context.nowMs - latest > window) {
-      failed.push("newerThan");
-    }
-  }
-  if (when.olderThan !== void 0) {
-    checked.push("olderThan");
-    const window = parseDuration(when.olderThan);
-    const latest = context.fact?.latestMtimeMs;
-    if (latest === void 0 || context.nowMs - latest <= window) {
-      failed.push("olderThan");
-    }
-  }
-  if (when.maxSizeBytes !== void 0) {
-    checked.push("maxSizeBytes");
-    const total = context.fact?.totalSizeBytes;
-    if (total === void 0 || total > when.maxSizeBytes) {
-      failed.push("maxSizeBytes");
+  for (const field of ["newerThan", "olderThan", "maxSizeBytes", "branch", "env"]) {
+    if (when[field] === void 0) {
+      continue;
     }
-  }
-  if (when.branch !== void 0) {
-    checked.push("branch");
-    if (!matchBranch(when.branch, context.branch, context.branchDetached ?? false)) {
-      failed.push("branch");
+    checked.push(field);
+    const result = evaluator.evaluatePredicate(fieldPredicate(field, when, context), void 0, resolversOf(context));
+    if (result.status === "indeterminate") {
+      return { status: "indeterminate", reason: result.reason.message, checked };
     }
-  }
-  if (when.env !== void 0) {
-    checked.push("env");
-    const mismatch = Object.entries(when.env).some(([name, expected]) => context.env[name] !== expected);
-    if (mismatch) {
-      failed.push("env");
+    if (!result.value) {
+      failed.push(field);
     }
   }
-  return { passed: failed.length === 0, checked, failed };
+  return { status: "definite", passed: failed.length === 0, checked, failed };
 }
 function isVacuousWhen(when) {
-  return when !== void 0 && Object.keys(when).length === 0;
+  return when !== void 0 && !("kind" in when) && Object.keys(when).length === 0;
 }
 
 // src/resolve/match.ts
@@ -1415,10 +1456,10 @@ function selectRule(relPath, flattened, context) {
       ...context.branchDetached === void 0 ? {} : { branchDetached: context.branchDetached },
       env: context.env
     });
-    if (evaluation.passed) {
+    if (evaluation.status === "definite" && evaluation.passed) {
       return { rule, eliminated };
     }
-    eliminated.push({ rule, failed: evaluation.failed });
+    eliminated.push({ rule, failed: evaluation.status === "definite" ? evaluation.failed : [`${evaluation.checked.join(", ")} could not be decided: ${evaluation.reason}`] });
   }
   return { eliminated };
 }
@@ -1652,7 +1693,10 @@ function planFarm(params) {
 var ENTER_EVERYTHING = () => true;
 function readsSubtreeAggregates(rule) {
   const when = rule.when;
-  return when !== void 0 && (when.newerThan !== void 0 || when.olderThan !== void 0 || when.maxSizeBytes !== void 0);
+  if (when === void 0) {
+    return false;
+  }
+  return "kind" in when || when.newerThan !== void 0 || when.olderThan !== void 0 || when.maxSizeBytes !== void 0;
 }
 function hasUnboundedDepth(pattern) {
   return pattern.includes("**") || /[{(]/.test(pattern);
@@ -5355,7 +5399,7 @@ var import_undici = require("undici");
 // package.json
 var package_default = {
   name: "agent-shim",
-  version: "8.32.0",
+  version: "8.34.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>",
@@ -5411,6 +5455,7 @@ var package_default = {
     commander: "^15.0.0",
     cosmiconfig: "^10.0.1",
     picomatch: "^4.0.7",
+    trilean: "1.7.1",
     undici: "7.29.1",
     zod: "^4.6.1"
   },
@@ -6646,12 +6691,48 @@ function assessIdentity(member, nowMs) {
     ...sevenDayBurn === void 0 ? {} : { sevenDayBurn }
   };
 }
+function poolFactsOf(member, nowMs, resuming, sticky) {
+  const unified = member.snapshot?.providers[ANTHROPIC_PROVIDER]?.rateLimit?.unified;
+  const window = (which) => {
+    const raw = unified?.[which];
+    if (raw?.utilization === void 0) {
+      return void 0;
+    }
+    if (raw.resetsAt === void 0) {
+      return void 0;
+    }
+    return { remaining: Math.max(0, 1 - raw.utilization), utilization: raw.utilization, hoursUntilReset: Math.max(0, (Date.parse(raw.resetsAt) - nowMs) / MS_PER_HOUR) };
+  };
+  const burn = windowBurn(member.records, "fiveHour");
+  return {
+    ...window("fiveHour") === void 0 ? {} : { fiveHour: window("fiveHour") },
+    ...window("sevenDay") === void 0 ? {} : { sevenDay: window("sevenDay") },
+    ...burn === void 0 ? {} : { burnPerHour: burn * MS_PER_HOUR },
+    resuming,
+    ...sticky?.identity === member.identity ? { lastPickHoursAgo: Math.max(0, (nowMs - Date.parse(sticky.at)) / MS_PER_HOUR) } : {}
+  };
+}
 function rankPool(input) {
   const { members, nowMs } = input;
-  const assessments = members.map((member) => assess(member, nowMs));
+  const assessments = members.map((member) => ({ member, ...assess(member, nowMs) }));
   const demands = assessments.flatMap(({ candidate, burn }) => burn === void 0 ? [] : [burn * capacityOf(candidate.plan)]);
   const sharedDemand = demands.length === 0 ? void 0 : Math.max(...demands);
-  const candidates = assessments.map((assessment) => {
+  const guarded = assessments.map((assessment) => {
+    const { candidate } = assessment;
+    if (candidate.class === "ineligible" || assessment.member.policy === void 0) {
+      return assessment;
+    }
+    const context = { nowMs, env: {}, pool: poolFactsOf(assessment.member, nowMs, input.resuming, input.sticky) };
+    const verdict = evaluateWhen(assessment.member.policy, context);
+    if (verdict.status === "indeterminate") {
+      return { ...assessment, candidate: { ...candidate, policyDemoted: true, reasons: [`policy undecided (${verdict.checked.join(", ") === "predicate" ? "predicate" : verdict.checked.join(", ")}): ${verdict.reason}`, ...candidate.reasons] } };
+    }
+    if (verdict.passed) {
+      return assessment;
+    }
+    return { ...assessment, candidate: { ...candidate, class: "ineligible", reasons: [`skipped by policy (${verdict.checked.join(", ")}: did not hold)`, ...candidate.reasons] } };
+  });
+  const candidates = guarded.map((assessment) => {
     const { candidate, fiveHour, burn } = assessment;
     const pace = burn ?? (sharedDemand === void 0 ? void 0 : sharedDemand / capacityOf(candidate.plan));
     const { sevenDay, sevenDayBurn } = assessment;
@@ -6677,7 +6758,7 @@ function rankPool(input) {
     return { ...candidate, feasible: false, reasons: [...drySpots, ...candidate.reasons] };
   });
   const ordered = input.preference === "listed" ? [...candidates] : [...candidates].sort(
-    (left, right) => CLASS_ORDER[left.class] - CLASS_ORDER[right.class] || Number(right.feasible) - Number(left.feasible) || (right.score ?? 0) - (left.score ?? 0) || left.identity.localeCompare(right.identity)
+    (left, right) => CLASS_ORDER[left.class] - CLASS_ORDER[right.class] || Number(left.policyDemoted ?? false) - Number(right.policyDemoted ?? false) || Number(right.feasible) - Number(left.feasible) || (right.score ?? 0) - (left.score ?? 0) || left.identity.localeCompare(right.identity)
   );
   const sticky = input.sticky;
   const stickyIndex = sticky === void 0 ? -1 : ordered.findIndex((candidate) => candidate.identity === sticky.identity);
@@ -6848,27 +6929,27 @@ function rankNamedPool(input, poolName, stack, sticky) {
     throw new PoolGraphError(`No pool named "${poolName}". Run \`agent-shim pool add ${poolName} --identity <name>...\` first.`);
   }
   const childStack = [...stack, poolName];
-  const direct = pool.identities.filter((entry) => poolNameOf(entry) === void 0);
-  const missing = direct.filter((entry) => !input.identityExists(entry)).map((identity) => ({ pool: poolName, identity }));
-  const loaded = new Map(loadPoolMembers(input.fs, input.paths, direct.filter(input.identityExists), input.nowMs).map((member) => [member.identity, member]));
+  const direct = pool.identities.filter((entry) => poolNameOf(poolMemberIdentity(entry)) === void 0);
+  const missing = direct.filter((entry) => !input.identityExists(poolMemberIdentity(entry))).map((entry) => ({ pool: poolName, identity: poolMemberIdentity(entry) }));
+  const loaded = new Map(loadPoolMembers(input.fs, input.paths, direct.filter((entry) => input.identityExists(poolMemberIdentity(entry))).map(poolMemberIdentity), input.nowMs).map((member) => [member.identity, member]));
   const members = [];
   for (const entry of pool.identities) {
-    const nestedName = poolNameOf(entry);
+    const nestedName = poolNameOf(poolMemberIdentity(entry));
     if (nestedName === void 0) {
-      const member = loaded.get(entry);
+      const member = loaded.get(poolMemberIdentity(entry));
       if (member !== void 0) {
-        members.push(member);
+        members.push(typeof entry === "string" ? member : { ...member, policy: entry.when });
       }
       continue;
     }
     if (input.pools[nestedName] === void 0) {
-      throw new PoolGraphError(`Pool "${poolName}" member "${entry}" names a pool that is not defined.`);
+      throw new PoolGraphError(`Pool "${poolName}" member "${poolMemberIdentity(entry)}" names a pool that is not defined.`);
     }
     if (childStack.includes(nestedName)) {
-      throw new PoolGraphError(`Pool "${poolName}" member "${entry}" closes a cycle: ${[...childStack.slice(childStack.indexOf(nestedName)), nestedName].join(" -> ")}. A pool cannot nest itself, directly or through another pool.`);
+      throw new PoolGraphError(`Pool "${poolName}" member "${poolMemberIdentity(entry)}" closes a cycle: ${[...childStack.slice(childStack.indexOf(nestedName)), nestedName].join(" -> ")}. A pool cannot nest itself, directly or through another pool.`);
     }
     const nested = nestedMember(input, nestedName, childStack, sticky);
-    members.push(nested.member);
+    members.push(typeof entry === "string" ? nested.member : { ...nested.member, policy: entry.when });
     missing.push(...nested.missing);
   }
   const ranking = rankPool({
@@ -7129,7 +7210,7 @@ function writePools(paths, pools) {
 function poolCycleOf(pools, name) {
   const walk = (current, path32) => {
     for (const entry of pools[current]?.identities ?? []) {
-      const nested = poolNameOf(entry);
+      const nested = poolNameOf(poolMemberIdentity(entry));
       if (nested === void 0) {
         continue;
       }
@@ -7150,9 +7231,10 @@ function poolCycleOf(pools, name) {
 }
 function validateMembers(pools, name, members) {
   for (const entry of members) {
-    const nested = poolNameOf(entry);
+    const identity = poolMemberIdentity(entry);
+    const nested = poolNameOf(identity);
     if (nested !== void 0 && nested !== name && pools[nested] === void 0) {
-      throw new UsageError(`Member "${entry}" of pool "${name}" names a pool that is not defined. Run \`agent-shim pool add ${nested} --identity <name>...\` first.`);
+      throw new UsageError(`Member "${identity}" of pool "${name}" names a pool that is not defined. Run \`agent-shim pool add ${nested} --identity <name>...\` first.`);
     }
   }
   const cycle = poolCycleOf({ ...pools, [name]: { identities: [...members] } }, name);
@@ -9857,16 +9939,16 @@ function runDoctor(params) {
   const validatedGlobalConfig = params.globalConfig.raw === void 0 ? void 0 : validateJson(GlobalConfigSchema, params.globalConfig);
   const pools = validatedGlobalConfig?.ok === true ? validatedGlobalConfig.data.pools ?? {} : {};
   for (const [poolName, pool] of Object.entries(pools)) {
-    const missing = pool.identities.filter((member) => poolNameOf(member) === void 0 && !validIdentityNames.has(member));
+    const missing = pool.identities.filter((member) => poolNameOf(poolMemberIdentity(member)) === void 0 && !validIdentityNames.has(poolMemberIdentity(member)));
     const undefinedPools = pool.identities.flatMap((member) => {
-      const nested = poolNameOf(member);
+      const nested = poolNameOf(poolMemberIdentity(member));
       return nested === void 0 || nested in pools ? [] : [nested];
     });
     if (missing.length === 0 && undefinedPools.length === 0) {
-      push("pool", "pass", `${poolName} is valid (${pool.identities.join(", ")}).`, poolName);
+      push("pool", "pass", `${poolName} is valid (${pool.identities.map(poolMemberIdentity).join(", ")}).`, poolName);
     } else {
       const problems = [
-        ...missing.map((member) => `identity "${member}", which does not exist`),
+        ...missing.map((member) => `identity "${poolMemberIdentity(member)}", which does not exist`),
         ...undefinedPools.map((nested) => `pool "${nested}", which is not defined`)
       ];
       push("pool", "fail", `Pool "${poolName}" names ${problems.join(" and ")}.`, poolName);