@tecorb/agent-pool 0.1.0 → 0.1.1

package/CHANGELOG.md

@@ -2,6 +2,19 @@
 
 All notable changes to `@tecorb/agent-pool`. The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and versions follow [Semantic Versioning](https://semver.org/).
 
+## 0.1.1 - 2026-10-15
+
+### Fixed
+
+- **Automatic switching** no longer stops with "no other subscription can take over" when the other accounts are only Unknown. Claude Code reports usage only for the account it runs on, so an idle account is Unknown after `availability.maxAgeMinutes`. Such accounts are now tried after the Available ones, once their login check passes. An account whose last reported window is still at 100%, or that was left for a limit and has not reset since, stays out until its reset.
+- When the chosen account's login check fails, the next account is tried, including Limited ones.
+- After a full stop, Agent Pool checks again every 5 minutes and at the earliest known reset, and switches back to the first account that can serve again.
+- A high-confidence authentication error now moves the work to the next account.
+
+### Added
+
+- Events `autoswitch.candidates` (every account with its decision and why), `autoswitch.precheck` (which account would take over while the current one is Limited) and `autoswitch.retry`.
+
 ## 0.1.0 - 2026-10-15
 
 The first release.

package/dist/{chunk-C6GZJCDH.js → chunk-6AS5JAKB.js}

@@ -7419,7 +7419,11 @@ function readToken(dp) {
 }
 
 // ../daemon/src/autoswitch/policy.ts
-var TRIGGERS = ["LIMIT_REACHED", "SUBSCRIPTION_UNAVAILABLE"];
+var TRIGGERS = [
+  "LIMIT_REACHED",
+  "SUBSCRIPTION_UNAVAILABLE",
+  "AUTHENTICATION_ERROR"
+];
 var REASONS = {
   LIMIT_REACHED: "limit reached",
   SUBSCRIPTION_UNAVAILABLE: "subscription unavailable",
@@ -7447,8 +7451,11 @@ function isFreshProvider(a) {
   return a.source === "provider" && !a.stale;
 }
 function chooseCandidates(fromSubscriptionId, inPriorityOrder, now) {
-  const available = [];
-  const limited = [];
+  const tiers = {
+    available: [],
+    unverified: [],
+    limited: []
+  };
   const skipped = [];
   const resets = [];
   for (const c of inPriorityOrder) {
@@ -7473,22 +7480,57 @@ function chooseCandidates(fromSubscriptionId, inPriorityOrder, now) {
       continue;
     }
     const a = c.availability;
+    const exhaustion = c.exhaustion ?? null;
+    if (exhaustion !== null && a.state !== "AVAILABLE" && Date.parse(exhaustion.until) > now.getTime()) {
+      skip(`${exhaustion.why} (until ${exhaustion.until})`);
+      resets.push(exhaustion.until);
+      continue;
+    }
     if (a.state === "AVAILABLE" && (isFreshProvider(a) || a.source === "estimated")) {
-      available.push(c);
+      tiers.available.push({ ...c, tier: "available" });
+    } else if (a.state === "UNKNOWN") {
+      tiers.unverified.push({ ...c, tier: "unverified" });
     } else if (a.state === "LIMITED" && isFreshProvider(a)) {
-      limited.push(c);
+      tiers.limited.push({ ...c, tier: "limited" });
     } else {
-      skip(a.state === "UNKNOWN" ? "availability Unknown" : `${a.state} (${a.source})`);
+      skip(`${a.state} (${a.source})`);
     }
   }
   const earliest = resets.filter((r) => Date.parse(r) > now.getTime()).sort((x, y) => Date.parse(x) - Date.parse(y))[0];
   return {
-    ordered: available.length > 0 ? available : limited,
-    limitedOnly: available.length === 0 && limited.length > 0,
+    ordered: [...tiers.available, ...tiers.unverified, ...tiers.limited],
+    limitedOnly: tiers.available.length === 0 && tiers.unverified.length === 0 && tiers.limited.length > 0,
     earliestReset: earliest ?? null,
     skipped
   };
 }
+function knownExhaustion(input) {
+  const nowMs = input.now.getTime();
+  const windows = (input.snapshot?.windows ?? []).flatMap((w) => {
+    const resetMs = w.resetsAt === null ? Number.NaN : Date.parse(w.resetsAt);
+    return w.usedPercentage === null || Number.isNaN(resetMs) || resetMs <= nowMs ? [] : [{ name: w.name, pct: w.usedPercentage, resetsAt: w.resetsAt, resetMs }];
+  });
+  const latestOf = (ws) => [...ws].sort((a, b) => b.resetMs - a.resetMs)[0];
+  const full = latestOf(windows.filter((w) => w.pct >= 100));
+  if (full !== void 0) {
+    return {
+      until: full.resetsAt,
+      why: `the ${full.name} usage window was at ${Math.round(full.pct)}% when last reported`
+    };
+  }
+  const away = input.lastAutoAway;
+  if (away === null || away.category !== "LIMIT_REACHED") return null;
+  const awayMs = Date.parse(away.at);
+  const snapMs = input.snapshot === null ? Number.NaN : Date.parse(input.snapshot.observedAt);
+  if (!Number.isNaN(snapMs) && snapMs > awayMs) return null;
+  const high = latestOf(windows.filter((w) => w.pct >= input.limitedThreshold));
+  const next = high ?? [...windows].sort((a, b) => a.resetMs - b.resetMs)[0];
+  if (next === void 0) return null;
+  return {
+    until: next.resetsAt,
+    why: `the limit was reached at ${away.at}; the ${next.name} usage window resets later`
+  };
+}
 function checkRateGuard(input) {
   if (input.switchesLastHour >= input.maxPerSessionPerHour) {
     return {
@@ -9066,6 +9108,7 @@ export {
   evaluateTrigger,
   canSwitchNow,
   chooseCandidates,
+  knownExhaustion,
   checkRateGuard,
   cooldownUntil,
   connectDaemon,

package/dist/index.js

@@ -23,7 +23,7 @@ if (isCallback) {
   });
   process.stdin.destroy();
 } else {
-  const { run } = await import("./main-45TVEBCR.js");
+  const { run } = await import("./main-LFJGWMAM.js");
   process.exitCode = await run(argv, {
     stdout: process.stdout,
     stderr: process.stderr,

package/dist/{main-45TVEBCR.js → main-LFJGWMAM.js}

@@ -61,7 +61,7 @@ import {
   withSubscriptionEnv,
   workerJson,
   workerManager
-} from "./chunk-C6GZJCDH.js";
+} from "./chunk-6AS5JAKB.js";
 import {
   AppError,
   EXIT_CODES,
@@ -353,7 +353,7 @@ Example:
   );
   group.command("serve", { hidden: true }).description("Run the daemon in this process (used by daemon start)").action(
     action(rt, async (ctx) => {
-      const { serveDaemon } = await import("./serve-IOY77YRF.js");
+      const { serveDaemon } = await import("./serve-MAWWQPZB.js");
       const daemon = await serveDaemon({
         env: ctx.io.env,
         entryPath: ctx.io.entryPath,
@@ -651,8 +651,12 @@ function registerEvents(program, rt) {
 Events come from the audit log in SQLite, so this works with or without the
 daemon. The daemon's availability monitor records availability.changed and
 availability.signal; automatic switching records autoswitch.* (with the
-reason, confidence, evidence, and from and to subscription). With --json,
---follow prints one JSON object per line.
+reason, confidence, evidence, and from and to subscription).
+autoswitch.candidates lists every subscription with its decision (selected,
+rejected or not tried) and why; autoswitch.precheck looks ahead while a
+subscription is LIMITED; autoswitch.retry records a new check after no
+subscription could take over. With --json, --follow prints one JSON object
+per line.
 
 Examples:
   agent-pool events
@@ -2435,7 +2439,7 @@ Claude Code credential files.`
 }
 
 // src/main.ts
-var VERSION = true ? "0.1.0" : "0.0.0-dev";
+var VERSION = true ? "0.1.1" : "0.0.0-dev";
 async function run(argv, io) {
   const rt = { io, version: VERSION, exitCode: 0 };
   const program = buildProgram(rt);

package/dist/{serve-IOY77YRF.js → serve-MAWWQPZB.js}

@@ -22,6 +22,7 @@ import {
   errorObject,
   evaluateTrigger,
   handoffService,
+  knownExhaustion,
   newNonce,
   openSubscriptionEnv,
   parseMessage,
@@ -33,7 +34,7 @@ import {
   switchService,
   withSubscriptionEnv,
   workerManager
-} from "./chunk-C6GZJCDH.js";
+} from "./chunk-6AS5JAKB.js";
 import {
   AppError,
   ENFORCES_POSIX_MODES,
@@ -708,6 +709,27 @@ function effectiveState(row, lastHook) {
   return row;
 }
 var QUIET_MS = 5 * 6e4;
+var RETRY_MS = 5 * 6e4;
+function ageText(ms) {
+  const minutes = Math.round(ms / 6e4);
+  if (minutes < 120) return `${minutes} min`;
+  const hours = Math.round(minutes / 60);
+  return hours < 48 ? `${hours} h` : `${Math.round(hours / 24)} days`;
+}
+function tierWhy(tier, view) {
+  if (tier === "available") {
+    return `AVAILABLE (${view?.source ?? "unknown"})`;
+  }
+  if (tier === "limited") return "LIMITED (provider): close to its limit";
+  const age = view?.usage === null || view?.usage === void 0 ? "no usage data from the provider yet" : `provider data ${ageText(view.usage.ageMs)} old`;
+  return `availability Unknown (${age}); only a session on it can tell, so it is tried after the login check`;
+}
+function atLimit(snapshot, now) {
+  if (snapshot === null) return false;
+  return [snapshot.fiveHour, snapshot.sevenDay].some(
+    (w) => w !== void 0 && w.usedPercentage !== null && w.usedPercentage >= 100 && w.resetsAt !== null && Date.parse(w.resetsAt) > now.getTime()
+  );
+}
 var AUTO_DECISIONS = {
   overrideGate: () => Promise.resolve(false),
   checkpointCommit: () => Promise.resolve(false),
@@ -757,7 +779,9 @@ var AutoSwitchWatcher = class {
       quietUntil: 0,
       switched: false,
       lastHook: null,
-      approved: false
+      approved: false,
+      waiting: null,
+      prechecked: false
     });
   }
   untrack(run) {
@@ -837,14 +861,48 @@ var AutoSwitchWatcher = class {
         this.signal(t, worker, { classification, source });
       }
     }
-    if (t.pending !== null && canSwitchNow(effectiveState(worker.state, t.lastHook))) {
+    if (t.waiting !== null) {
+      if (t.lastHook === "hook.Stop" || newSnapshot && !atLimit(usage.snapshot, this.now())) {
+        t.waiting = null;
+      }
+    }
+    const switchable = canSwitchNow(effectiveState(worker.state, t.lastHook));
+    if (t.pending !== null && switchable) {
       const signal = t.pending;
       t.pending = null;
       t.busy = true;
       void this.decideLive(t, worker, signal).finally(() => {
         t.busy = false;
       });
+      return;
+    }
+    if (t.waiting !== null && switchable && this.now().getTime() >= t.waiting.retryAt) {
+      const { signal } = t.waiting;
+      t.busy = true;
+      void this.decideLive(t, worker, signal, { retry: true }).finally(() => {
+        t.busy = false;
+      });
+      return;
     }
+    if (newSnapshot && t.pending === null && t.waiting === null) {
+      const sub = this.storage.subscriptions.getById(worker.subscriptionId);
+      const state = sub === void 0 ? null : this.options.env.availability.evaluate(sub).state;
+      if (state === "LIMITED" && !t.prechecked) {
+        t.prechecked = true;
+        t.busy = true;
+        void this.precheck(t, worker).finally(() => {
+          t.busy = false;
+        });
+      } else if (state === "AVAILABLE") {
+        t.prechecked = false;
+      }
+    }
+  }
+  /** When the candidates are checked again after none could take over. */
+  retryAt(earliestReset) {
+    const next = this.now().getTime() + (this.options.retryMs ?? RETRY_MS);
+    const reset = earliestReset === null ? Number.NaN : Date.parse(earliestReset) + 1e3;
+    return Number.isNaN(reset) ? next : Math.min(next, reset);
   }
   /** Records a classified signal and decides whether it waits for a switch. */
   signal(t, worker, signal) {
@@ -895,10 +953,59 @@ var AutoSwitchWatcher = class {
       sessionId: worker.sessionId
     };
   }
+  /**
+   * Every subscription as a switching candidate, in priority order, and the
+   * policy's choice. Availability that is no longer current does not rule a
+   * subscription out: an idle account has no fresh usage data, because only a
+   * running session reports it. What older data still proves (a window at
+   * its limit, or a switch away for a limit) keeps it out until the reset.
+   */
+  candidates(fromSubscriptionId, config, now) {
+    const { storage } = this;
+    const all = storage.subscriptions.list();
+    const views = /* @__PURE__ */ new Map();
+    const inputs = all.map((s) => {
+      const view = this.options.env.availability.evaluate(s, now);
+      views.set(s.id, view);
+      const snap = storage.snapshots.latestBySource(s.id, "provider");
+      const away = storage.switches.lastAutoAwayFrom(s.id);
+      return {
+        id: s.id,
+        label: s.label,
+        removed: s.removedAt !== null,
+        status: s.status,
+        availability: {
+          state: view.state,
+          source: view.source,
+          stale: view.stale,
+          resetsAt: view.resetsAt
+        },
+        cooldownUntil: cooldownUntil(away?.requestedAt ?? null, config.switching.cooldownMinutes),
+        exhaustion: knownExhaustion({
+          snapshot: snap === void 0 ? null : {
+            observedAt: snap.observedAt,
+            windows: [
+              { name: "5-hour", ...snap.fiveHour },
+              { name: "7-day", ...snap.sevenDay }
+            ]
+          },
+          lastAutoAway: away === void 0 ? null : { at: away.requestedAt, category: away.details?.category ?? null },
+          limitedThreshold: config.availability.limitedThreshold,
+          now
+        })
+      };
+    });
+    return { all, views, choice: chooseCandidates(fromSubscriptionId, inputs, now) };
+  }
   /**
    * The shared part of both paths: mode, loop guards and candidates. Returns
-   * the target, or null after recording why there is none (and telling the
-   * attached terminal).
+   * the target, or why there is none (after recording it and telling the
+   * attached terminal). Each candidate's login is checked in turn; one that
+   * fails is skipped and the next one is tried.
+   *
+   * revalidate: the ask path checking again after the answer (no new
+   * triggered or candidates event). retry: checking again after no
+   * subscription could take over (records only what changed).
    */
   async plan(run, worker, classification, options = {}) {
     const { storage } = this;
@@ -908,6 +1015,7 @@ var AutoSwitchWatcher = class {
     const label = sub?.label ?? worker.subscriptionId;
     const reason = categoryReason(classification.category);
     const base = this.base(worker);
+    const quiet = options.revalidate === true || options.retry === true;
     const details = {
       mode,
       reason,
@@ -915,7 +1023,7 @@ var AutoSwitchWatcher = class {
       confidence: classification.confidence,
       evidence: classification.evidence
     };
-    if (options.revalidate !== true) {
+    if (!quiet) {
       storage.events.append({
         type: "autoswitch.triggered",
         severity: "warn",
@@ -926,22 +1034,24 @@ var AutoSwitchWatcher = class {
         }
       });
     }
-    const say = (type, summary, extra = {}) => {
+    const say = (type, summary2, extra2 = {}) => {
       storage.events.append({
         type,
         severity: "warn",
         ...base,
-        data: { ...details, ...extra, summary }
+        data: { ...details, ...extra2, summary: summary2 }
       });
-      run.line(`Agent Pool: ${summary}`);
-      run.notice(summary);
-      return null;
+      run.line(`Agent Pool: ${summary2}`);
+      run.notice(summary2);
     };
     if (mode === "off") {
-      return say(
-        "autoswitch.off",
-        `"${label}": ${reason} (${classification.confidence}). autoSwitch is off, so the worker stays on "${label}"; switch by hand with "agent-pool worker switch".`
-      );
+      if (options.retry !== true) {
+        say(
+          "autoswitch.off",
+          `"${label}": ${reason} (${classification.confidence}). autoSwitch is off, so the worker stays on "${label}"; switch by hand with "agent-pool worker switch".`
+        );
+      }
+      return { kind: "off" };
     }
     const now = this.now();
     if (worker.sessionId !== null) {
@@ -953,48 +1063,138 @@ var AutoSwitchWatcher = class {
         maxPerSessionPerHour: config.switching.maxPerSessionPerHour
       });
       if (!guard.ok) {
-        return say(
-          "autoswitch.blocked",
-          `"${label}": ${reason}, but automatic switching stopped: ${guard.reason}. Switch by hand with "agent-pool worker switch".`,
-          { guard: "rate" }
-        );
+        if (options.retry !== true) {
+          say(
+            "autoswitch.blocked",
+            `"${label}": ${reason}, but automatic switching stopped: ${guard.reason}. Switch by hand with "agent-pool worker switch".`,
+            { guard: "rate" }
+          );
+        }
+        return { kind: "blocked" };
       }
     }
-    const all = storage.subscriptions.list();
-    const inputs = all.map((s) => {
-      const view = this.options.env.availability.evaluate(s, now);
-      return {
-        id: s.id,
-        label: s.label,
-        removed: s.removedAt !== null,
-        status: s.status,
-        availability: {
-          state: view.state,
-          source: view.source,
-          stale: view.stale,
-          resetsAt: view.resetsAt
-        },
-        cooldownUntil: cooldownUntil(
-          storage.switches.lastAutoAwayFrom(s.id)?.requestedAt ?? null,
-          config.switching.cooldownMinutes
-        )
-      };
-    });
-    const choice = chooseCandidates(worker.subscriptionId, inputs, now);
+    const { all, views, choice } = this.candidates(worker.subscriptionId, config, now);
     const switches = switchService(run.ctx ?? this.options.ctx, this.options.env, quietReporter());
+    const rejected = new Map(choice.skipped.map((x) => [x.id, x.why]));
+    let selected = null;
     for (const candidate of choice.ordered) {
       const target = all.find((s) => s.id === candidate.id);
       if (target === void 0) continue;
       const check = await switches.checkTarget(target, worker.subscriptionId);
-      if (check.usable) return target;
-      choice.skipped.push({ id: target.id, label: target.label, why: check.reasons.join(" ") });
+      if (check.usable) {
+        selected = { target, tier: candidate.tier };
+        break;
+      }
+      const why = check.reasons.join(" ");
+      rejected.set(target.id, why);
+      choice.skipped.push({ id: target.id, label: target.label, why });
+    }
+    const rows = all.filter((s) => s.removedAt === null).map((s) => {
+      const ranked = choice.ordered.find((c) => c.id === s.id);
+      const tier = ranked === void 0 ? {} : { tier: ranked.tier };
+      if (s.id === worker.subscriptionId) {
+        return { id: s.id, label: s.label, decision: "current", why: reason };
+      }
+      const no = rejected.get(s.id);
+      if (no !== void 0)
+        return { id: s.id, label: s.label, decision: "rejected", ...tier, why: no };
+      if (selected?.target.id === s.id) {
+        return {
+          id: s.id,
+          label: s.label,
+          decision: "selected",
+          ...tier,
+          why: `${tierWhy(selected.tier, views.get(s.id))}; logged in`
+        };
+      }
+      return {
+        id: s.id,
+        label: s.label,
+        decision: "not tried",
+        ...tier,
+        why: "a subscription earlier in the order was selected"
+      };
+    });
+    const key = JSON.stringify(rows.map((r) => [r.id, r.decision, r.why]));
+    const changed = options.retry !== true || key !== options.previousKey;
+    if (options.revalidate !== true && changed) {
+      storage.events.append({
+        type: "autoswitch.candidates",
+        ...base,
+        data: {
+          summary: selected === null ? `No subscription can take over from "${label}".` : `Selected "${selected.target.label}" to take over from "${label}" (${selected.tier}).`,
+          selected: selected?.target.id ?? null,
+          ...options.retry === true ? { retry: true } : {},
+          candidates: rows
+        }
+      });
     }
+    if (selected !== null) return { kind: "target", ...selected };
     const reset = choice.earliestReset === null ? "No reset time is known." : `The earliest known reset is ${choice.earliestReset}.`;
-    return say(
-      "autoswitch.exhausted",
-      `"${label}": ${reason}, and no other subscription can take over. ${reset} Claude Code continues automatically after a reset.`,
-      { earliestReset: choice.earliestReset, skipped: choice.skipped }
-    );
+    const summary = `"${label}": ${reason}, and no other subscription can take over. ${reset} Agent Pool checks again every ${Math.round((this.options.retryMs ?? RETRY_MS) / 6e4)} min and at the earliest reset; Claude Code continues automatically after a reset.`;
+    const extra = { earliestReset: choice.earliestReset, skipped: choice.skipped };
+    if (options.retry !== true) {
+      say("autoswitch.exhausted", summary, extra);
+    } else if (changed) {
+      storage.events.append({
+        type: "autoswitch.retry",
+        ...base,
+        data: { ...details, ...extra, summary }
+      });
+    }
+    return { kind: "exhausted", earliestReset: choice.earliestReset, key };
+  }
+  /**
+   * While the worker's subscription is LIMITED: checks ahead which
+   * subscription would take over, so a missing login shows before the limit
+   * is reached. Usage of an idle account cannot be read, so only logins are
+   * checked; the switch itself checks everything again.
+   */
+  async precheck(t, worker) {
+    try {
+      const config = this.liveConfig();
+      if (config.autoSwitch === "off") return;
+      const { storage } = this;
+      const label = storage.subscriptions.getById(worker.subscriptionId)?.label ?? worker.subscriptionId;
+      const { all, views, choice } = this.candidates(worker.subscriptionId, config, this.now());
+      const switches = switchService(
+        t.run.ctx ?? this.options.ctx,
+        this.options.env,
+        quietReporter()
+      );
+      const rows = choice.skipped.map((x) => ({
+        id: x.id,
+        label: x.label,
+        decision: "rejected",
+        why: x.why
+      }));
+      const ready = [];
+      for (const candidate of choice.ordered) {
+        const target = all.find((s) => s.id === candidate.id);
+        if (target === void 0) continue;
+        const check = await switches.checkTarget(target, worker.subscriptionId);
+        if (check.usable) ready.push(target.label);
+        rows.push({
+          id: target.id,
+          label: target.label,
+          tier: candidate.tier,
+          decision: check.usable ? "ready" : "rejected",
+          why: check.usable ? `${tierWhy(candidate.tier, views.get(target.id))}; logged in` : check.reasons.join(" ")
+        });
+      }
+      const summary = ready.length > 0 ? `"${label}" is close to its limit; next in line: ${ready.map((l) => `"${l}"`).join(", ")}.` : `"${label}" is close to its limit and no other subscription is ready to take over: ${rows.map((r) => `"${r.label}" ${r.why}`).join("; ") || "there is no other subscription"}.`;
+      storage.events.append({
+        type: "autoswitch.precheck",
+        severity: ready.length > 0 ? "info" : "warn",
+        ...this.base(worker),
+        data: { summary, candidates: rows }
+      });
+      if (ready.length === 0) {
+        t.run.line(`Agent Pool: ${summary}`);
+        t.run.notice(summary);
+      }
+    } catch {
+    }
   }
   /** In ask mode: the question waits in the daemon until a terminal answers. */
   async confirm(run, worker, target, classification) {
@@ -1019,18 +1219,35 @@ var AutoSwitchWatcher = class {
     }
     return ok;
   }
-  /** A signal while the worker is alive: hand off and ask its owner (this daemon) to switch. */
-  async decideLive(t, worker, signal) {
+  /**
+   * A signal while the worker is alive: hand off and ask its owner (this
+   * daemon) to switch. With retry: the candidates are checked again after
+   * none could take over earlier.
+   */
+  async decideLive(t, worker, signal, options = {}) {
     const { storage } = this;
     const quiet = () => {
       t.quietUntil = Date.now() + QUIET_MS;
     };
+    const retry = options.retry === true;
+    const previousKey = t.waiting?.key;
     try {
-      const target = await this.plan(t.run, worker, signal.classification);
-      if (target === null) {
-        quiet();
+      const outcome = await this.plan(t.run, worker, signal.classification, {
+        retry,
+        ...previousKey === void 0 ? {} : { previousKey }
+      });
+      if (outcome.kind !== "target") {
+        if (outcome.kind === "exhausted") {
+          t.waiting = { signal, retryAt: this.retryAt(outcome.earliestReset), key: outcome.key };
+        } else if (outcome.kind === "blocked" && t.waiting !== null) {
+          t.waiting.retryAt = this.retryAt(null);
+        } else {
+          t.waiting = null;
+        }
+        if (!retry) quiet();
         return;
       }
+      const { target, tier } = outcome;
       if (this.mode() === "ask") {
         if (!t.approved) {
           if (!await this.confirm(t.run, worker, target, signal.classification)) {
@@ -1052,7 +1269,7 @@ var AutoSwitchWatcher = class {
           return;
         }
         const again = await this.plan(t.run, current, signal.classification, { revalidate: true });
-        if (again === null || again.id !== target.id) {
+        if (again.kind !== "target" || again.target.id !== target.id) {
           quiet();
           return;
         }
@@ -1087,9 +1304,15 @@ var AutoSwitchWatcher = class {
         });
         t.run.line(`Agent Pool: ${summary}`);
         t.run.notice(summary);
+        if (t.waiting !== null) t.waiting.retryAt = this.retryAt(null);
         quiet();
         return;
       }
+      if (tier === "unverified") {
+        t.run.line(
+          `Agent Pool: switching to "${target.label}": its availability is Unknown (no current usage data), and its login is verified.`
+        );
+      }
       const details = {
         category: signal.classification.category,
         confidence: signal.classification.confidence,
@@ -1116,12 +1339,15 @@ var AutoSwitchWatcher = class {
               reason,
               ...details,
               from: worker.subscriptionId,
-              to: target.id
+              to: target.id,
+              tier,
+              verified: tier !== "unverified"
             }
           });
         }
       });
       t.switched = true;
+      t.waiting = null;
     } catch (err) {
       storage.events.append({
         type: "autoswitch.failed",
@@ -1141,8 +1367,9 @@ var AutoSwitchWatcher = class {
     const decision = evaluateTrigger(finished.classification);
     if (!decision.trigger) return null;
     const worker = finished.worker;
-    const target = await this.plan(run, worker, finished.classification);
-    if (target === null) return null;
+    const outcome = await this.plan(run, worker, finished.classification);
+    if (outcome.kind !== "target") return null;
+    const { target, tier } = outcome;
     if (this.mode() === "ask" && !await this.confirm(run, worker, target, finished.classification)) {
       return null;
     }
@@ -1181,6 +1408,8 @@ var AutoSwitchWatcher = class {
         ...details,
         from: subscription.id,
         to: target.id,
+        tier,
+        verified: tier !== "unverified",
         after: "exit"
       }
     });
@@ -1517,7 +1746,8 @@ async function serveDaemon(io) {
       env,
       config,
       clock,
-      ...io.watchIntervalMs === void 0 ? {} : { intervalMs: io.watchIntervalMs }
+      ...io.watchIntervalMs === void 0 ? {} : { intervalMs: io.watchIntervalMs },
+      ...io.autoSwitchRetryMs === void 0 ? {} : { retryMs: io.autoSwitchRetryMs }
     });
     const runFor = (params) => {
       const runId = optString(obj(params), "runId", 64);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tecorb/agent-pool",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Orchestrate Claude Code across multiple Claude subscriptions owned by one developer.",
   "keywords": [
     "claude",