@prohost/cli 0.14.0 → 0.16.0

package/dist/host/ledger.d.ts

@@ -0,0 +1,52 @@
+/**
+ * The host's run ledger, keyed by employee and conversation.
+ *
+ * Two things outlive a restart here:
+ *
+ * - **Claimed runs.** Recorded the moment a claim succeeds, before anything
+ *   runs, so a run is never executed twice. A run claimed but never completed
+ *   (the service died mid-run) is reported failed on the next start, with its
+ *   own token — it is never run again: the agent may already have acted.
+ * - **Which login each conversation works on** (`employee/conversation` →
+ *   AI login), so a conversation stays with the login holding its session.
+ *
+ * The file holds run tokens, so it is written 0600, atomically.
+ */
+export interface LedgerRun {
+    run_id: string;
+    agent_id: string;
+    /** `employee/conversation`, or `run:<id>` for a run with no conversation. */
+    lane: string;
+    account_key?: string;
+    claimed_at: string;
+    completed: boolean;
+    completion_path?: string;
+    /** Kept only until the run is completed. */
+    run_token?: string;
+}
+export interface LedgerConversation {
+    account_key: string;
+    updated_at: string;
+}
+export declare const LEDGER_RUN_LIMIT = 500;
+export declare const LEDGER_CONVERSATION_LIMIT = 2000;
+export declare class HostLedger {
+    private readonly file;
+    private readonly warn;
+    private readonly runs;
+    private readonly conversations;
+    private constructor();
+    static load(env?: NodeJS.ProcessEnv, warn?: (line: string) => void): HostLedger;
+    get(runId: string): LedgerRun | undefined;
+    /** Runs claimed here and never completed: the service stopped mid-run. */
+    unfinished(): LedgerRun[];
+    claimed(run: Omit<LedgerRun, 'claimed_at' | 'completed'>): void;
+    /** The run's account changed mid-run (it moved to another login). */
+    setAccount(runId: string, accountKey: string): void;
+    completed(runId: string): void;
+    conversationLogin(lane: string): string | undefined;
+    setConversationLogin(lane: string, accountKey: string): void;
+    /** How many conversations stick to each login. */
+    conversationsPerLogin(): Map<string, number>;
+    private persist;
+}

package/dist/host/ledger.js

@@ -0,0 +1,131 @@
+/**
+ * The host's run ledger, keyed by employee and conversation.
+ *
+ * Two things outlive a restart here:
+ *
+ * - **Claimed runs.** Recorded the moment a claim succeeds, before anything
+ *   runs, so a run is never executed twice. A run claimed but never completed
+ *   (the service died mid-run) is reported failed on the next start, with its
+ *   own token — it is never run again: the agent may already have acted.
+ * - **Which login each conversation works on** (`employee/conversation` →
+ *   AI login), so a conversation stays with the login holding its session.
+ *
+ * The file holds run tokens, so it is written 0600, atomically.
+ */
+import { hostLedgerPath, readObject, writePrivateFile } from './computer.js';
+export const LEDGER_RUN_LIMIT = 500;
+export const LEDGER_CONVERSATION_LIMIT = 2_000;
+export class HostLedger {
+    file;
+    warn;
+    runs = new Map();
+    conversations = new Map();
+    constructor(file, warn) {
+        this.file = file;
+        this.warn = warn;
+    }
+    static load(env = process.env, warn = () => { }) {
+        const ledger = new HostLedger(hostLedgerPath(env), warn);
+        const raw = readObject(ledger.file);
+        for (const entry of Array.isArray(raw?.runs) ? raw.runs : []) {
+            const run = entry;
+            if (run && typeof run.run_id === 'string' && typeof run.agent_id === 'string' && typeof run.lane === 'string') {
+                ledger.runs.set(run.run_id, {
+                    run_id: run.run_id,
+                    agent_id: run.agent_id,
+                    lane: run.lane,
+                    ...(typeof run.account_key === 'string' ? { account_key: run.account_key } : {}),
+                    claimed_at: typeof run.claimed_at === 'string' ? run.claimed_at : '',
+                    completed: run.completed === true,
+                    ...(typeof run.completion_path === 'string' ? { completion_path: run.completion_path } : {}),
+                    ...(typeof run.run_token === 'string' && run.completed !== true ? { run_token: run.run_token } : {}),
+                });
+            }
+        }
+        const conversations = raw?.conversations;
+        if (conversations && typeof conversations === 'object' && !Array.isArray(conversations)) {
+            for (const [key, value] of Object.entries(conversations)) {
+                const entry = value;
+                if (entry && typeof entry.account_key === 'string') {
+                    ledger.conversations.set(key, {
+                        account_key: entry.account_key,
+                        updated_at: typeof entry.updated_at === 'string' ? entry.updated_at : '',
+                    });
+                }
+            }
+        }
+        return ledger;
+    }
+    get(runId) {
+        return this.runs.get(runId);
+    }
+    /** Runs claimed here and never completed: the service stopped mid-run. */
+    unfinished() {
+        return [...this.runs.values()].filter((run) => !run.completed);
+    }
+    claimed(run) {
+        this.runs.delete(run.run_id);
+        this.runs.set(run.run_id, { ...run, claimed_at: new Date().toISOString(), completed: false });
+        while (this.runs.size > LEDGER_RUN_LIMIT) {
+            const oldest = this.runs.keys().next().value;
+            if (oldest === undefined)
+                break;
+            this.runs.delete(oldest);
+        }
+        this.persist();
+    }
+    /** The run's account changed mid-run (it moved to another login). */
+    setAccount(runId, accountKey) {
+        const run = this.runs.get(runId);
+        if (!run)
+            return;
+        run.account_key = accountKey;
+        this.persist();
+    }
+    completed(runId) {
+        const run = this.runs.get(runId);
+        if (!run)
+            return;
+        run.completed = true;
+        delete run.run_token;
+        this.persist();
+    }
+    conversationLogin(lane) {
+        return this.conversations.get(lane)?.account_key;
+    }
+    setConversationLogin(lane, accountKey) {
+        if (lane.startsWith('run:'))
+            return;
+        if (this.conversations.get(lane)?.account_key === accountKey)
+            return;
+        this.conversations.delete(lane);
+        this.conversations.set(lane, { account_key: accountKey, updated_at: new Date().toISOString() });
+        while (this.conversations.size > LEDGER_CONVERSATION_LIMIT) {
+            const oldest = this.conversations.keys().next().value;
+            if (oldest === undefined)
+                break;
+            this.conversations.delete(oldest);
+        }
+        this.persist();
+    }
+    /** How many conversations stick to each login. */
+    conversationsPerLogin() {
+        const counts = new Map();
+        for (const entry of this.conversations.values()) {
+            counts.set(entry.account_key, (counts.get(entry.account_key) ?? 0) + 1);
+        }
+        return counts;
+    }
+    persist() {
+        try {
+            writePrivateFile(this.file, {
+                version: 1,
+                runs: [...this.runs.values()],
+                conversations: Object.fromEntries(this.conversations),
+            });
+        }
+        catch (err) {
+            this.warn(`! could not write the run ledger (${err instanceof Error ? err.message : String(err)})`);
+        }
+    }
+}

package/dist/host/legacy.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Adopted agent homes (`host migrate`) that ProhostAI has not placed on this
+ * computer yet, served the way `agent run` served them — with their own
+ * credential, in this one process — until the computer takes them over.
+ *
+ * `sync` is called with the employees the computer serves: an adopted home
+ * whose employee is among them is stopped (it drains: runs going finish), any
+ * other adopted home with a known `--exec` keeps running. A host-only home
+ * runs only while the computer isn't paired: once it is, the host service
+ * hosts the terminal sessions itself.
+ */
+import type { AgentRunOptions } from '../agent/run.js';
+import type { AdoptedHome } from './migrate.js';
+export type HarnessRunner = (options: AgentRunOptions) => Promise<unknown>;
+export declare class LegacyHarnesses {
+    private readonly homes;
+    private readonly options;
+    private readonly running;
+    /** Stopped, still finishing the runs it had: never started again until done, and awaited on stop. */
+    private readonly draining;
+    /** What the last `sync` was told, so a home that finishes draining is started again if it is wanted. */
+    private last;
+    private stopped;
+    constructor(homes: readonly AdoptedHome[], options: {
+        env?: NodeJS.ProcessEnv;
+        log: (line: string) => void;
+        machine?: string;
+        run?: HarnessRunner;
+    });
+    /** Which homes run now, given the employees the computer serves and whether it is paired. */
+    wanted(served: ReadonlySet<string>, paired: boolean): AdoptedHome[];
+    sync(served: ReadonlySet<string>, paired: boolean): void;
+    active(): string[];
+    /** Homes stopped and still finishing their runs. */
+    drainingHomes(): string[];
+    stop(): Promise<void>;
+    private start;
+}

package/dist/host/legacy.js

@@ -0,0 +1,115 @@
+/**
+ * Adopted agent homes (`host migrate`) that ProhostAI has not placed on this
+ * computer yet, served the way `agent run` served them — with their own
+ * credential, in this one process — until the computer takes them over.
+ *
+ * `sync` is called with the employees the computer serves: an adopted home
+ * whose employee is among them is stopped (it drains: runs going finish), any
+ * other adopted home with a known `--exec` keeps running. A host-only home
+ * runs only while the computer isn't paired: once it is, the host service
+ * hosts the terminal sessions itself.
+ */
+import { isClaudeExec } from '../agent/claude.js';
+import { loadCredentials } from '../agent/credentials.js';
+import { claudeTokenEnv } from './computer.js';
+import { runAgentHarness } from '../agent/run.js';
+export class LegacyHarnesses {
+    homes;
+    options;
+    running = new Map();
+    /** Stopped, still finishing the runs it had: never started again until done, and awaited on stop. */
+    draining = new Map();
+    /** What the last `sync` was told, so a home that finishes draining is started again if it is wanted. */
+    last;
+    stopped = false;
+    constructor(homes, options) {
+        this.homes = homes;
+        this.options = options;
+    }
+    /** Which homes run now, given the employees the computer serves and whether it is paired. */
+    wanted(served, paired) {
+        return this.homes.filter((home) => {
+            if (home.host_only)
+                return !paired;
+            return Boolean(home.exec) && !served.has(home.agent_id);
+        });
+    }
+    sync(served, paired) {
+        if (this.stopped)
+            return;
+        this.last = { served, paired };
+        const wanted = new Set(this.wanted(served, paired).map((home) => home.home));
+        for (const [home, running] of this.running) {
+            if (wanted.has(home))
+                continue;
+            this.options.log(`  ⇢ ${home}: now served by this computer — stopping its own connection`);
+            running.controller.abort();
+            this.running.delete(home);
+            this.draining.set(home, running.done.finally(() => {
+                this.draining.delete(home);
+                // Wanted again while it was finishing: start it now.
+                if (this.last)
+                    this.sync(this.last.served, this.last.paired);
+            }));
+        }
+        for (const home of this.homes) {
+            if (!wanted.has(home.home) || this.running.has(home.home) || this.draining.has(home.home))
+                continue;
+            this.start(home);
+        }
+    }
+    active() {
+        return [...this.running.keys()];
+    }
+    /** Homes stopped and still finishing their runs. */
+    drainingHomes() {
+        return [...this.draining.keys()];
+    }
+    async stop() {
+        this.stopped = true;
+        const all = [...this.running.values()];
+        this.running.clear();
+        for (const running of all)
+            running.controller.abort();
+        await Promise.all([
+            ...all.map((running) => running.done.catch(() => undefined)),
+            ...[...this.draining.values()].map((done) => done.catch(() => undefined)),
+        ]);
+    }
+    start(home) {
+        const env = { ...process.env, ...this.options.env, PROHOST_HOME: home.home };
+        let credentials;
+        try {
+            credentials = loadCredentials(env);
+        }
+        catch (err) {
+            this.options.log(`  ! ${home.home}: ${err instanceof Error ? err.message : String(err)}`);
+            return;
+        }
+        const prefix = `[${home.agent_name}] `;
+        const controller = new AbortController();
+        const options = {
+            exec: home.exec ?? '',
+            ...(home.host_only ? { hostOnly: true } : { codeHost: null }),
+            credentials,
+            env,
+            ...(this.options.machine ? { machine: this.options.machine } : {}),
+            ...(home.workdir ? { cwd: home.workdir } : {}),
+            ...(home.concurrency !== undefined ? { concurrency: home.concurrency } : {}),
+            ...(home.repos ? { repos: home.repos } : {}),
+            ...(home.timeout_seconds !== undefined ? { timeoutMs: home.timeout_seconds * 1000 } : {}),
+            ...(home.idle_timeout_seconds !== undefined ? { idleTimeoutMs: home.idle_timeout_seconds * 1000 } : {}),
+            ...(home.safe_tools ? { safeTools: true } : {}),
+            // A dedicated install's Claude token (in the host's home), for a Claude harness only; re-read per run.
+            ...(home.exec && isClaudeExec(home.exec) ? { extraEnv: () => claudeTokenEnv(this.options.env ?? process.env) } : {}),
+            signal: controller.signal,
+            onLine: (line) => this.options.log(`${prefix}${line}`),
+        };
+        this.options.log(`  ⇢ ${home.home}: serving ${home.agent_name} with its own connection until it is placed here`);
+        const run = this.options.run ?? runAgentHarness;
+        const done = run(options).catch((err) => {
+            this.options.log(`${prefix}✗ stopped: ${err instanceof Error ? err.message : String(err)}`);
+        });
+        this.running.set(home.home, { controller, done });
+    }
+}

package/dist/host/logins.d.ts

@@ -0,0 +1,109 @@
+/**
+ * The computer's AI logins, and which one each conversation works on.
+ *
+ * A login is one Claude Code or Codex sign-in in its own config directory:
+ * the CLI's defaults (`~/.claude`, `~/.codex`) and every account in the
+ * machine-wide registry (`~/.prohost-accounts`, see `agent/accounts.ts`).
+ *
+ * What is sent to ProhostAI about a login is its key, label, runtime, plan and
+ * sign-in state — never the email. `claude auth status --json` carries the
+ * email; it is read only for `prohost host logins` on this machine
+ * (`email_local`) and never leaves it.
+ */
+import type { AccountRecord, AccountRuntime, AuthState, CommandRunner } from '../agent/accounts.js';
+import type { QuotaProvider, QuotaWindow } from '../agent/runtime_status.js';
+export interface LoginInfo {
+    account_key: string;
+    label: string;
+    runtime: AccountRuntime;
+    /** `max`, `pro`, `plus`, … — lowercased; `null` when the login didn't say. */
+    subscription_type: string | null;
+    /** `Claude Max`, `ChatGPT Pro`, … */
+    plan_label: string | null;
+    auth_state: AuthState;
+    /** The config directory (`CLAUDE_CONFIG_DIR` / `CODEX_HOME`). Local only. */
+    dir: string;
+    quota_windows: QuotaWindow[];
+    /** Local only: shown by `host logins`, never sent. */
+    email_local?: string;
+}
+/** The directory a login's sessions live in: its own, or the CLI's default. */
+export declare function loginDir(record: AccountRecord, env?: NodeJS.ProcessEnv): string;
+/**
+ * Every login on this machine: the registry, plus each runtime's default when
+ * its config directory exists or its binary is installed (created in the
+ * registry on first sight, so it has a stable key).
+ */
+export declare function loginRecords(env?: NodeJS.ProcessEnv, installed?: (binary: string) => boolean): AccountRecord[];
+export interface DetectOptions {
+    env?: NodeJS.ProcessEnv;
+    run?: CommandRunner;
+    /** Usage / plan probe for one login (the CLI's own `get_usage` / rate-limit read). */
+    quota?: (record: AccountRecord) => QuotaProvider | undefined;
+    /** Read the email for local display (`host logins`). */
+    includeEmail?: boolean;
+    records?: AccountRecord[];
+}
+/** Ask each login whether it is signed in, on which plan, and how much it has left. */
+export declare function detectLogins(options?: DetectOptions): Promise<LoginInfo[]>;
+/** The environment a run on this login spawns with. */
+export declare function loginEnv(login: Pick<LoginInfo, 'runtime' | 'dir' | 'label'>, env?: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
+/** When an exhausted window lifts: the latest reset among windows at 100 %. */
+export declare function exhaustedUntil(windows: readonly QuotaWindow[], now: number): number | undefined;
+export type LoginPick = 
+/** Run on this login. */
+{
+    kind: 'use';
+    login: LoginInfo;
+}
+/** The conversation's login rests: copy its session to `to` and resume there. */
+ | {
+    kind: 'move';
+    from: LoginInfo;
+    to: LoginInfo;
+}
+/** Nothing has room: wait. `until` is the earliest reset, when known. */
+ | {
+    kind: 'wait';
+    until?: number;
+    resting?: LoginInfo;
+}
+/** No signed-in login of this kind on the computer. */
+ | {
+    kind: 'none';
+};
+/** When a login that hit its limit without saying when is tried again. */
+export declare const UNKNOWN_RESET_MS: number;
+/**
+ * Logins, their rests, and which conversation sticks to which login.
+ *
+ * A conversation sticks to the login that holds its session. When that login
+ * rests (its usage limit), the conversation moves only if sharing between
+ * logins is on for this computer — and only to a login of the same kind:
+ * a Claude Code session cannot continue in Codex, or the other way round.
+ */
+export declare class LoginPool {
+    private readonly affinity;
+    private readonly now;
+    private logins;
+    private readonly rests;
+    constructor(affinity: {
+        get(conversation: string): string | undefined;
+        set(conversation: string, accountKey: string): void;
+    }, now?: () => number);
+    update(logins: LoginInfo[]): void;
+    all(): readonly LoginInfo[];
+    get(accountKey: string): LoginInfo | undefined;
+    /** The login hit its usage limit; it rests until `until` (ms), or an hour when unknown. */
+    rest(accountKey: string, until?: number): number;
+    /** When the login is next usable, if it is resting now. */
+    restingUntil(accountKey: string): number | undefined;
+    /** The conversation's login, if it has one. */
+    stuckTo(conversation: string | undefined): string | undefined;
+    stick(conversation: string | undefined, accountKey: string): void;
+    /**
+     * Which login a run in `conversation` (undefined: no conversation) works on.
+     * `busy` counts runs going per login, so new conversations spread out.
+     */
+    pick(runtime: AccountRuntime, conversation: string | undefined, share: boolean, busy?: (accountKey: string) => number): LoginPick;
+}

package/dist/host/logins.js

@@ -0,0 +1,190 @@
+/**
+ * The computer's AI logins, and which one each conversation works on.
+ *
+ * A login is one Claude Code or Codex sign-in in its own config directory:
+ * the CLI's defaults (`~/.claude`, `~/.codex`) and every account in the
+ * machine-wide registry (`~/.prohost-accounts`, see `agent/accounts.ts`).
+ *
+ * What is sent to ProhostAI about a login is its key, label, runtime, plan and
+ * sign-in state — never the email. `claude auth status --json` carries the
+ * email; it is read only for `prohost host logins` on this machine
+ * (`email_local`) and never leaves it.
+ */
+import { existsSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { accountEnv, checkAuth, ensureDefaultAccount, loadAccounts, } from '../agent/accounts.js';
+import { claudePlanLabel } from '../agent/runtime_status.js';
+import { resolvesOnPath } from '../codehost/agents.js';
+/** The directory a login's sessions live in: its own, or the CLI's default. */
+export function loginDir(record, env = process.env) {
+    if (record.dir)
+        return record.dir;
+    return path.join(env.HOME || os.homedir(), record.runtime === 'claude_code' ? '.claude' : '.codex');
+}
+const BINARY = { claude_code: 'claude', codex: 'codex' };
+/**
+ * Every login on this machine: the registry, plus each runtime's default when
+ * its config directory exists or its binary is installed (created in the
+ * registry on first sight, so it has a stable key).
+ */
+export function loginRecords(env = process.env, installed = (binary) => resolvesOnPath(binary, env)) {
+    for (const runtime of ['claude_code', 'codex']) {
+        const dir = path.join(env.HOME || os.homedir(), runtime === 'claude_code' ? '.claude' : '.codex');
+        if (existsSync(dir) || installed(BINARY[runtime])) {
+            try {
+                ensureDefaultAccount(runtime, env);
+            }
+            catch {
+                /* a locked or unwritable registry costs the default its key this round */
+            }
+        }
+    }
+    return loadAccounts(env);
+}
+/** `ChatGPT Pro` → `pro`. */
+function planKey(label) {
+    const key = label?.replace(/^(ChatGPT|Claude)\s+/i, '').trim().toLowerCase();
+    return key && /^[a-z0-9_-]{1,32}$/.test(key) ? key : undefined;
+}
+/** Ask each login whether it is signed in, on which plan, and how much it has left. */
+export async function detectLogins(options = {}) {
+    const env = options.env ?? process.env;
+    const records = options.records ?? loginRecords(env);
+    return Promise.all(records.map(async (record) => {
+        const auth = await checkAuth(record, { run: options.run, includeEmail: options.includeEmail });
+        const observed = auth.state === 'expired' ? undefined : await options.quota?.(record)?.refresh().catch(() => undefined);
+        const subscription = auth.subscriptionType ?? planKey(observed?.plan_label);
+        const planLabel = observed?.plan_label ?? (record.runtime === 'claude_code' ? claudePlanLabel(auth.subscriptionType) : undefined);
+        return {
+            account_key: record.key,
+            label: record.label,
+            runtime: record.runtime,
+            subscription_type: subscription ?? null,
+            plan_label: planLabel ?? null,
+            auth_state: auth.state,
+            dir: loginDir(record, env),
+            quota_windows: observed?.quota_windows ?? [],
+            ...(options.includeEmail && auth.email ? { email_local: auth.email } : {}),
+        };
+    }));
+}
+/** The environment a run on this login spawns with. */
+export function loginEnv(login, env = process.env) {
+    const home = env.HOME || os.homedir();
+    const isDefault = login.dir === path.join(home, login.runtime === 'claude_code' ? '.claude' : '.codex');
+    return isDefault ? {} : accountEnv({ runtime: login.runtime, dir: login.dir });
+}
+/** When an exhausted window lifts: the latest reset among windows at 100 %. */
+export function exhaustedUntil(windows, now) {
+    let until;
+    for (const window of windows) {
+        if (window.used_percent < 100 || !window.resets_at)
+            continue;
+        const at = Date.parse(window.resets_at);
+        if (Number.isFinite(at) && at > now)
+            until = Math.max(until ?? 0, at);
+    }
+    return until;
+}
+/** When a login that hit its limit without saying when is tried again. */
+export const UNKNOWN_RESET_MS = 60 * 60_000;
+/**
+ * Logins, their rests, and which conversation sticks to which login.
+ *
+ * A conversation sticks to the login that holds its session. When that login
+ * rests (its usage limit), the conversation moves only if sharing between
+ * logins is on for this computer — and only to a login of the same kind:
+ * a Claude Code session cannot continue in Codex, or the other way round.
+ */
+export class LoginPool {
+    affinity;
+    now;
+    logins = [];
+    rests = new Map();
+    constructor(affinity, now = Date.now) {
+        this.affinity = affinity;
+        this.now = now;
+    }
+    update(logins) {
+        this.logins = logins;
+    }
+    all() {
+        return this.logins;
+    }
+    get(accountKey) {
+        return this.logins.find((login) => login.account_key === accountKey);
+    }
+    /** The login hit its usage limit; it rests until `until` (ms), or an hour when unknown. */
+    rest(accountKey, until) {
+        const at = until && until > this.now() ? until : this.now() + UNKNOWN_RESET_MS;
+        this.rests.set(accountKey, at);
+        return at;
+    }
+    /** When the login is next usable, if it is resting now. */
+    restingUntil(accountKey) {
+        const now = this.now();
+        const rested = this.rests.get(accountKey);
+        const fromRun = rested !== undefined && rested > now ? rested : undefined;
+        if (rested !== undefined && rested <= now)
+            this.rests.delete(accountKey);
+        const login = this.get(accountKey);
+        const fromWindows = login ? exhaustedUntil(login.quota_windows, now) : undefined;
+        if (fromRun === undefined)
+            return fromWindows;
+        if (fromWindows === undefined)
+            return fromRun;
+        return Math.max(fromRun, fromWindows);
+    }
+    /** The conversation's login, if it has one. */
+    stuckTo(conversation) {
+        return conversation ? this.affinity.get(conversation) : undefined;
+    }
+    stick(conversation, accountKey) {
+        if (conversation)
+            this.affinity.set(conversation, accountKey);
+    }
+    /**
+     * Which login a run in `conversation` (undefined: no conversation) works on.
+     * `busy` counts runs going per login, so new conversations spread out.
+     */
+    pick(runtime, conversation, share, busy = () => 0) {
+        const usable = this.logins.filter((login) => login.runtime === runtime && login.auth_state !== 'expired');
+        if (usable.length === 0)
+            return { kind: 'none' };
+        const free = usable
+            .filter((login) => this.restingUntil(login.account_key) === undefined)
+            .sort((a, b) => busy(a.account_key) - busy(b.account_key));
+        const earliest = () => {
+            const times = usable.map((login) => this.restingUntil(login.account_key)).filter((t) => t !== undefined);
+            return times.length > 0 ? Math.min(...times) : undefined;
+        };
+        const stuck = this.stuckTo(conversation);
+        const signedOut = stuck
+            ? this.logins.find((login) => login.account_key === stuck && login.runtime === runtime && login.auth_state === 'expired')
+            : undefined;
+        if (signedOut) {
+            // Its session lives in a login that is signed out: it moves only when
+            // sharing is on; otherwise the conversation waits for that sign-in.
+            const other = share ? free.find((login) => login.account_key !== signedOut.account_key) : undefined;
+            return other ? { kind: 'move', from: signedOut, to: other } : { kind: 'wait', resting: signedOut };
+        }
+        // A login no longer on this computer at all took its sessions with it:
+        // nothing to keep, so the conversation starts fresh on one that has room.
+        const sticky = stuck ? usable.find((login) => login.account_key === stuck) : undefined;
+        if (sticky) {
+            const until = this.restingUntil(sticky.account_key);
+            if (until === undefined)
+                return { kind: 'use', login: sticky };
+            const other = share ? free.find((login) => login.account_key !== sticky.account_key) : undefined;
+            if (other)
+                return { kind: 'move', from: sticky, to: other };
+            // With sharing on, the first login of this kind to reset frees the conversation.
+            return { kind: 'wait', until: share ? earliest() : until, resting: sticky };
+        }
+        const first = free[0];
+        if (first)
+            return { kind: 'use', login: first };
+        return { kind: 'wait', until: earliest() };
+    }
+}