@prohost/cli 0.6.0 → 0.8.0

package/CHANGELOG.md

@@ -4,8 +4,104 @@ Versions follow [semver](https://semver.org/). Publishing is automated: merging
 a version bump to `main` triggers `.github/workflows/npm-publish-cli.yml`, which
 builds via `prepack`, runs the suite, publishes, and tags `cli-v<version>`.
 
+## 0.8.0
+
+A paired agent woken as a bystander can now stay silent.
+
+- **`reply_expected: false`.** When a team-chat message lands in a thread the
+  agent belongs to but is addressed to someone else (ProhostAI's participation
+  walk), the run event now says so. The prompt tells the agent the message was
+  not addressed to it and nobody is waiting on it — instead of "someone is
+  waiting on a reply" — and renders the server's `trigger.brief`, the same
+  bystander guidance ProhostAI's in-product agents get. Absent (every older
+  server) keeps today's prompt.
+- **`[NO_REPLY]`.** An agent whose whole answer is `[NO_REPLY]` (any case,
+  surrounding whitespace ignored) posts nothing, and the run is completed
+  `{status: "succeeded", outcome: "silent"}` so ProhostAI records a deliberate
+  silence and clears the thinking indicator as one. Checked on every run, so
+  the literal token can never reach a thread. A server that predates `outcome`
+  ignores it and records a plain success.
+- **`trigger.brief` is rendered** whenever the server sends one that is not just
+  the message restated — a work order used to be dropped on any run that also
+  had a message.
+
+## 0.7.0
+
+Machines, accounts and agents: a paired AI employee now runs on a named
+Claude Code or Codex login, and ProhostAI can show — and change — which one.
+
+- **Accounts.** `prohost agent account add <label> --runtime claude|codex`
+  creates a login in its own config directory under `~/.prohost-accounts`
+  (`$PROHOST_ACCOUNTS_ROOT`), prints the exact sign-in command
+  (`CLAUDE_CONFIG_DIR=… claude auth login` / `CODEX_HOME=… codex login`) and
+  waits until the agent CLI reports it signed in. The CLI never reads the
+  login: it asks `claude auth status` / `codex login status` and keeps only
+  "signed in or not". `account list` / `account remove` round it out, and
+  `default` is the CLI's usual `~/.claude` / `~/.codex`, so existing agents
+  change nothing.
+- **One account per agent, applied per run.** `--account <label>` on `pair`
+  and `install-daemon` stores it in `agent.json`; every run, idle usage probe
+  and Codex MCP probe is spawned with that account's `CLAUDE_CONFIG_DIR` /
+  `CODEX_HOME`, so a change applies from the next run with no restart. An agent
+  set to an account that is not on the machine refuses to run rather than spend
+  another subscription. **Nothing ever switches accounts automatically.**
+- **Picked in ProhostAI.** An `agent.config_updated` event (signed, verified
+  like a run) or `auth_ok.agent_config` on reconnect moves the agent to the
+  account an operator picked in the web app, from its next run. An account
+  that isn't on this machine is ignored with a warning. Picks carry the
+  server's `requested_at`; one older than a pick already applied — or than the
+  floor `auth_ok` sends on connect — arrived out of order and is dropped.
+- **A stable machine id.** The first agent on a computer writes a random UUID
+  to `~/.prohost-accounts/machine.json`; every agent there sends it on auth as
+  `machine_id`. ProhostAI keys the machine's accounts by it — the label
+  (hostname by default) is display only, since two computers can share one.
+- **The status frame names the account.** `runtime_status` gains `account`
+  (random key, label, runtime, billing as the login reports it, sign-in state) and `machine_accounts`
+  (every account on the machine), plus per-model weekly windows
+  (`weekly_model`, e.g. Fable) from Claude Code's `get_usage`.
+- **Fix: the 5-hour window disappeared after five idle hours.** Claude Code
+  omits a rolled-over window from its own `rate_limit_event`, reports an idle
+  account's 5-hour window with no reset time, and the harness dropped any
+  window without a future reset — so an idle agent showed only its weekly
+  window. A window with known usage is now always reported: rolled over or not
+  started yet, it is `0%` with `resets_at: null`. New observations are merged
+  per window kind instead of replacing the whole list.
+- **`prohost agent list`** shows every agent home on the machine (default,
+  `$PROHOST_HOME`, and every home a `ai.prohost.agent.*` launchd plist pins),
+  its account, and whether its daemon or a harness is running — plus every
+  account with its runtime, billing and sign-in state.
+- **`$PROHOST_HOME/run.lock`.** A second `agent run` on the same home exits
+  with the pid that holds it, instead of executing every run twice. A lock
+  left by a dead process is taken over.
+- **`prohost agent workspace init --developer --repo <checkout>`** (opt-in)
+  adds the ProhostAI PR-protocol skill (a pointer to the repo's
+  `pr_protocol.md`, not a copy) and the fleet's `gh pr create` gate as a
+  `PreToolUse` hook to the agent workspace's `.claude/`.
+
 ## 0.6.0
 
+The thread now shows what a paired agent is doing, not just that it is doing
+something.
+
+- **Tool calls stream into the conversation.** With Claude Code, every
+  `tool_use` / `tool_result` in the `--output-format stream-json` stream is
+  reported to ProhostAI as it happens — the tool, a one-line preview of its
+  input (the command, the path, the query), whether it succeeded, and a short
+  line of what came back — and rendered in the thread exactly as an
+  in-product AI employee's tool calls are, beneath the "Working on
+  \<machine\>…" line. Events are batched on a one-second debounce
+  (`POST /v1/agent-runs/{id}/events`, at most 50 per request) and always
+  flushed before the reply is posted and before the run is completed.
+- **Best-effort, and additive.** The path comes from the run event
+  (`events.path`); a server that doesn't advertise it gets no requests at
+  all, and one that answers `404` is told so once per run and then left alone.
+  No event failure can fail the run or delay its reply. The 60-second
+  heartbeat and its one-line `progress` are unchanged.
+- **What stays on your machine.** Previews are capped at 200 characters and
+  only the headline field of a tool's input travels — a `Write`'s file
+  content, an `Edit`'s old and new text, never do. The server clips again and
+  redacts before anything reaches a browser.
+
 ProhostAI can now show which runtime, model and machine a paired AI employee
 runs on, and how much of the operator's Claude or Codex subscription is left.
 

package/README.md

@@ -117,6 +117,10 @@ nothing is posted and the run is left open.
 4. Your command's **stdout** is the reply. It's posted into the conversation
    verbatim, so print the message and nothing else — no preamble, no reasoning.
    (Claude Code and Codex are the exceptions: see below.)
+   To reply with nothing, print exactly `[NO_REPLY]`: nothing is posted and the
+   run is completed as a deliberate silence. That is the expected answer when
+   your agent is woken only because it is in a thread where someone else was
+   addressed — the prompt says so when that is the case.
 5. The run is completed either way. A command that crashes, times out, or prints
    nothing reports `failed`; a run is never left hanging.
 
@@ -442,6 +446,46 @@ unmodified CLI through its own protocol (`get_usage`,
 `codex app-server`), which answers with its own login. Account ids, emails and
 org names are never sent.
 
+### Accounts: which login an agent runs on
+
+A machine can hold several Claude Code or Codex logins — say a work Max plan
+and a personal one — and each paired agent uses exactly one. Several agents can
+share one account; they then share its limits.
+
+```sh
+prohost agent account add work --runtime claude     # prints the sign-in command, waits for it
+#   CLAUDE_CONFIG_DIR=~/.prohost-accounts/accounts/claude_code/work claude auth login
+prohost agent install-daemon --exec 'claude -p' --account work
+prohost agent account list
+prohost agent list                                    # every agent here, its account and daemon
+```
+
+- Each account is its own config directory under `~/.prohost-accounts` (or
+  `$PROHOST_ACCOUNTS_ROOT`). You sign in with the agent CLI's own login command;
+  `prohost` only asks the CLI whether it is signed in and never reads the login.
+- `default` is the CLI's usual `~/.claude` / `~/.codex`, so an agent paired
+  before accounts existed keeps working unchanged.
+- The account is applied to every run (and every usage check) separately, so
+  picking another one — with `--account`, or in ProhostAI — takes effect from
+  the agent's next run, with no restart.
+- **Accounts never switch on their own.** When an account's limit is reached,
+  the agent rests until it resets; moving it to another subscription is always
+  a person's decision.
+- ProhostAI sees a random id for each account and the label you gave it. Never
+  the email, org or anything from the login.
+
+Only one `agent run` can serve an agent home at a time: a second one exits,
+naming the pid that holds `$PROHOST_HOME/run.lock`.
+
+### A developer workspace
+
+For an agent that works on the ProhostAI codebase, `prohost agent workspace
+init --developer --repo <backend-service checkout>` adds two things to its
+workspace's `.claude/`: a skill that points it at the repo's PR protocol
+(`prohost_agents/support/prompts/pr_protocol.md`, referenced, not copied) and
+the `gh pr create` gate hook the fleet uses. Nothing else about the default
+workspace changes.
+
 ### The trust model — read this once
 
 `agent run` is a standing instruction to execute a command on your machine when
@@ -514,6 +558,12 @@ for it:
   which is what stops the server reaping a run that is still being worked on.
   Against an older ProhostAI server the heartbeat endpoint answers `404`; the
   CLI says so once per run and otherwise behaves exactly as it did before.
+- **The thread sees the tool calls.** With Claude Code, each tool the agent
+  calls — and whether it succeeded — is reported to ProhostAI as it happens
+  and shown in the conversation under the "Working on your machine…" line,
+  the way an in-product AI employee's tool calls are. Only a one-line preview
+  travels (the command, the path, the query; never a file's contents), and a
+  server that doesn't support it is told nothing.
 - **Cancel works.** Stopping a run in ProhostAI is answered on the next
   heartbeat: the command's whole process group gets `SIGTERM`, then `SIGKILL`
   five seconds later, and the run is reported as cancelled. No reply is posted.
@@ -576,6 +626,7 @@ decision to make.
 | Flag | Default | What it does |
 | --- | --- | --- |
 | `--code` | `$PROHOST_PAIRING_CODE` | The one-time pairing code. |
+| `--account` | the home's current account, else `default` | Which Claude Code / Codex login this agent runs on (see Accounts). |
 | `--webhook-url` | none | Also push events to this HTTPS endpoint. Omit for stream-only, which is the normal laptop setup. |
 | `--base-url` | `https://connect.prohost.ai` | Public API base. |
 

package/dist/agent/account_runtime.d.ts

@@ -0,0 +1,75 @@
+/**
+ * The account a running harness uses — resolved per spawn, switched on request.
+ *
+ * `agent run` reads the account from `agent.json` at every run and every idle
+ * probe rather than once at start-up, so a switch (made here with
+ * `--account`, or in ProhostAI through `agent.config_updated`) takes effect on
+ * the next run without restarting or reinstalling the daemon.
+ */
+import type { AccountRecord, AccountRuntime, CommandRunner, ConfigUpdateOutcome } from './accounts.js';
+import type { AccountsSnapshot } from './runtime_status.js';
+export type AccountResolution = {
+    ok: true;
+    record: AccountRecord;
+} | {
+    ok: false;
+    error: string;
+};
+export declare class HarnessAccount {
+    readonly runtime: AccountRuntime;
+    private readonly env;
+    private readonly binary;
+    private readonly run;
+    /** Label from `agent.json` at start-up; the file wins once it has one. */
+    private readonly initialLabel;
+    /** Label the most recent run was spawned with — what a run in flight is using. */
+    private spawnedLabel;
+    /** `requested_at` of the newest pick applied, so a late older one is dropped. */
+    private appliedRequestedAt;
+    constructor(options: {
+        runtime: AccountRuntime;
+        /** Environment that locates `$PROHOST_HOME` and the accounts root. */
+        env?: NodeJS.ProcessEnv;
+        initialLabel?: string;
+        /** Agent CLI binary used for sign-in checks. */
+        binary?: string;
+        run?: CommandRunner;
+    });
+    /** The label this agent home names now. */
+    label(): string;
+    /**
+     * The account for the next spawn. An account named but missing from this
+     * machine is an error: running on some other login would spend a
+     * subscription nobody picked.
+     */
+    resolve(): AccountResolution;
+    /** {@link resolve} for a run about to be spawned; remembers which account it got. */
+    resolveForSpawn(): AccountResolution;
+    /** Whether the chosen account differs from the one the last run was spawned with. */
+    changedSinceSpawn(): boolean;
+    /** Spawn environment for the current account; empty when it can't be resolved. */
+    spawnEnv(): NodeJS.ProcessEnv;
+    /**
+     * Apply an account picked in ProhostAI. Picks carry `requested_at` (the
+     * server stamps them in the order they were made); one older than a pick
+     * already applied arrived out of order and is ignored. A pick without a
+     * stamp (an older server) always applies.
+     */
+    apply(key: unknown, requestedAt?: unknown): ConfigUpdateOutcome;
+    /**
+     * Raise the floor without applying anything: `auth_ok` carries the newest
+     * pick's stamp even when nothing is pending, so a live pick still in flight
+     * from before the connect — or one a later pick cancelled — is dropped.
+     */
+    noteRequestedAt(requestedAt: unknown): void;
+    /**
+     * Accounts for the status frame: this agent's, plus every account on the machine.
+     *
+     * While a run executes, "this agent's" is the account it was spawned with,
+     * not a newer pick — the server would otherwise mark the pick fulfilled and
+     * credit that run's capacity to an account it isn't using.
+     */
+    snapshot(busy?: boolean): Promise<AccountsSnapshot>;
+    /** The command that signs the current account in, for a log line. */
+    signInHint(): string | undefined;
+}

package/dist/agent/account_runtime.js

@@ -0,0 +1,130 @@
+/**
+ * The account a running harness uses — resolved per spawn, switched on request.
+ *
+ * `agent run` reads the account from `agent.json` at every run and every idle
+ * probe rather than once at start-up, so a switch (made here with
+ * `--account`, or in ProhostAI through `agent.config_updated`) takes effect on
+ * the next run without restarting or reinstalling the daemon.
+ */
+import { DEFAULT_ACCOUNT_LABEL, MAX_REPORTED_ACCOUNTS, accountBlock, accountEnv, applyAccountKey, checkAuth, loadAccounts, resolveAgentAccount, runtimeName, signInCommand, } from './accounts.js';
+import { tryLoadCredentials } from './credentials.js';
+export class HarnessAccount {
+    runtime;
+    env;
+    binary;
+    run;
+    /** Label from `agent.json` at start-up; the file wins once it has one. */
+    initialLabel;
+    /** Label the most recent run was spawned with — what a run in flight is using. */
+    spawnedLabel;
+    /** `requested_at` of the newest pick applied, so a late older one is dropped. */
+    appliedRequestedAt;
+    constructor(options) {
+        this.runtime = options.runtime;
+        this.env = { ...process.env, ...options.env };
+        this.binary = options.binary;
+        this.run = options.run;
+        this.initialLabel = options.initialLabel;
+    }
+    /** The label this agent home names now. */
+    label() {
+        return tryLoadCredentials(this.env)?.account ?? this.initialLabel ?? DEFAULT_ACCOUNT_LABEL;
+    }
+    /**
+     * The account for the next spawn. An account named but missing from this
+     * machine is an error: running on some other login would spend a
+     * subscription nobody picked.
+     */
+    resolve() {
+        const label = this.label();
+        const record = resolveAgentAccount(label, this.runtime, this.env);
+        if (record)
+            return { ok: true, record };
+        return {
+            ok: false,
+            error: `this agent is set to the ${runtimeName(this.runtime)} account "${label}", which is not on this machine — ` +
+                `add it (prohost agent account add ${label} --runtime ${this.runtime === 'claude_code' ? 'claude' : 'codex'}) ` +
+                'or pick another account for this agent in ProhostAI',
+        };
+    }
+    /** {@link resolve} for a run about to be spawned; remembers which account it got. */
+    resolveForSpawn() {
+        const resolved = this.resolve();
+        if (resolved.ok)
+            this.spawnedLabel = resolved.record.label;
+        return resolved;
+    }
+    /** Whether the chosen account differs from the one the last run was spawned with. */
+    changedSinceSpawn() {
+        return this.spawnedLabel !== undefined && this.spawnedLabel !== this.label();
+    }
+    /** Spawn environment for the current account; empty when it can't be resolved. */
+    spawnEnv() {
+        const resolved = this.resolve();
+        return resolved.ok ? accountEnv(resolved.record) : {};
+    }
+    /**
+     * Apply an account picked in ProhostAI. Picks carry `requested_at` (the
+     * server stamps them in the order they were made); one older than a pick
+     * already applied arrived out of order and is ignored. A pick without a
+     * stamp (an older server) always applies.
+     */
+    apply(key, requestedAt) {
+        const at = typeof requestedAt === 'string' ? Date.parse(requestedAt) : Number.NaN;
+        if (!Number.isNaN(at) && this.appliedRequestedAt !== undefined && at < this.appliedRequestedAt) {
+            return { applied: false, reason: 'a newer account pick was already applied' };
+        }
+        const outcome = applyAccountKey(key, this.runtime, this.env);
+        if (outcome.applied && !Number.isNaN(at))
+            this.appliedRequestedAt = at;
+        return outcome;
+    }
+    /**
+     * Raise the floor without applying anything: `auth_ok` carries the newest
+     * pick's stamp even when nothing is pending, so a live pick still in flight
+     * from before the connect — or one a later pick cancelled — is dropped.
+     */
+    noteRequestedAt(requestedAt) {
+        const at = typeof requestedAt === 'string' ? Date.parse(requestedAt) : Number.NaN;
+        if (Number.isNaN(at))
+            return;
+        if (this.appliedRequestedAt === undefined || at > this.appliedRequestedAt)
+            this.appliedRequestedAt = at;
+    }
+    /**
+     * Accounts for the status frame: this agent's, plus every account on the machine.
+     *
+     * While a run executes, "this agent's" is the account it was spawned with,
+     * not a newer pick — the server would otherwise mark the pick fulfilled and
+     * credit that run's capacity to an account it isn't using.
+     */
+    async snapshot(busy = false) {
+        const label = busy && this.spawnedLabel ? this.spawnedLabel : this.label();
+        const record = resolveAgentAccount(label, this.runtime, this.env);
+        const resolved = record ? { ok: true, record } : { ok: false, error: '' };
+        const records = loadAccounts(this.env);
+        // The current account first, so a machine with more than the cap still
+        // reports the one this agent is on.
+        const ordered = resolved.ok
+            ? [resolved.record, ...records.filter((r) => r.key !== resolved.record.key)]
+            : records;
+        const all = await Promise.all(ordered.slice(0, MAX_REPORTED_ACCOUNTS).map(async (record) => {
+            // Only the login of this runtime's CLI is checked with this binary;
+            // another runtime's accounts are checked with that CLI's default name.
+            const check = await checkAuth(record, {
+                binary: record.runtime === this.runtime ? this.binary : undefined,
+                run: this.run,
+            });
+            return accountBlock(record, check.state, check.billing);
+        }));
+        const current = resolved.ok ? all.find((a) => a.key === resolved.record.key) : undefined;
+        // More accounts than a frame carries (a hand-edited registry): send none
+        // rather than a partial list the server would prune to.
+        return { current, all: ordered.length > MAX_REPORTED_ACCOUNTS ? undefined : all };
+    }
+    /** The command that signs the current account in, for a log line. */
+    signInHint() {
+        const resolved = this.resolve();
+        return resolved.ok ? signInCommand(resolved.record) : undefined;
+    }
+}

package/dist/agent/accounts.d.ts

@@ -0,0 +1,162 @@
+/**
+ * Brain accounts — which Claude Code or Codex login a paired agent runs on.
+ *
+ * A machine can hold several logins ("work", "personal"), each in its own
+ * config directory: `CLAUDE_CONFIG_DIR` for Claude Code, `CODEX_HOME` for
+ * Codex. Every agent home on the machine uses exactly one of them, named in its
+ * `agent.json` as `account`, and several agents may share one (and so share its
+ * quota). The implicit `default` account is today's `~/.claude` / `~/.codex`,
+ * so an agent paired before accounts existed keeps running exactly as it did.
+ *
+ * **This module never reads a credential.** Signing in is done by the operator
+ * running the agent CLI's own login command with the account's directory; we
+ * only ever ask the unmodified CLI whether it is signed in (`claude auth status`
+ * → `loggedIn`, `codex login status` → its exit code) and keep nothing else
+ * from the answer — not the email, org or account id either one prints.
+ *
+ * **Accounts never switch on their own.** An exhausted subscription makes the
+ * agent rest until its window resets; only an operator (here, or through the
+ * picker in ProhostAI, which arrives as `agent.config_updated`) moves an agent
+ * to another account.
+ *
+ * The registry lives in a machine-wide root shared by every agent home —
+ * `~/.prohost-accounts`, or `$PROHOST_ACCOUNTS_ROOT` — so `account add` once
+ * serves every agent on the machine.
+ */
+/** Server → CLI: an operator picked another account for this agent in ProhostAI. */
+export declare const EVENT_AGENT_CONFIG_UPDATED = "agent.config_updated";
+/** Label of the implicit account that is the agent CLI's own default config dir. */
+export declare const DEFAULT_ACCOUNT_LABEL = "default";
+/** Most accounts reported to the server in one frame (the server caps it too). */
+export declare const MAX_REPORTED_ACCOUNTS = 16;
+export type AccountRuntime = 'claude_code' | 'codex';
+export type AccountBilling = 'subscription' | 'api_key';
+export type AuthState = 'ok' | 'expired' | 'unknown';
+export interface AccountRecord {
+    /** Random UUID made here when the account is created — the only identity the server sees. */
+    key: string;
+    /** Operator-chosen, unique per runtime on this machine. */
+    label: string;
+    runtime: AccountRuntime;
+    billing: AccountBilling;
+    /** Config directory for this login; `null` for the implicit default (the CLI's own default). */
+    dir: string | null;
+    created_at: string;
+}
+/** An account as it goes on the wire (`runtime_status.account` / `machine_accounts[]`). */
+export interface AccountBlock {
+    key: string;
+    label: string;
+    runtime: AccountRuntime;
+    billing: AccountBilling;
+    auth_state: AuthState;
+}
+export declare class AccountError extends Error {
+}
+export declare function isValidLabel(label: string): boolean;
+/** `claude` → `claude_code`; anything else that is not `codex` is `undefined`. */
+export declare function parseAccountRuntime(value: string | undefined): AccountRuntime | undefined;
+/** Machine-wide root shared by every agent home. */
+export declare function accountsRoot(env?: NodeJS.ProcessEnv): string;
+/** Every account on this machine. An unreadable registry is an empty one. */
+export declare function loadAccounts(env?: NodeJS.ProcessEnv): AccountRecord[];
+/**
+ * This computer's id: a random UUID made once and kept in the machine-wide
+ * accounts root, so every agent home on the machine sends the same one. It is
+ * what ProhostAI keys a machine's accounts by — the label (hostname by
+ * default) is display only, since two computers can share one. Nothing about
+ * the computer goes into it. `undefined` when it can't be stored, in which
+ * case the agent reports no accounts rather than risk another machine's.
+ */
+export declare function machineId(env?: NodeJS.ProcessEnv): string | undefined;
+export declare function findAccount(label: string, runtime: AccountRuntime, env?: NodeJS.ProcessEnv): AccountRecord | undefined;
+/**
+ * The implicit default account for a runtime, created on first use so it has
+ * a stable key the server can recognise across restarts.
+ */
+export declare function ensureDefaultAccount(runtime: AccountRuntime, env?: NodeJS.ProcessEnv): AccountRecord;
+/** Create an account and its config directory. Signing in is the operator's next step. */
+export declare function addAccount(options: {
+    label: string;
+    runtime: AccountRuntime;
+    billing?: AccountBilling;
+}, env?: NodeJS.ProcessEnv): AccountRecord;
+/**
+ * Forget an account and delete its config directory (the login inside it goes
+ * with it). The implicit default can't be removed — it is the CLI's own login.
+ */
+export declare function removeAccount(label: string, runtime: AccountRuntime, env?: NodeJS.ProcessEnv): AccountRecord;
+export declare function runtimeName(runtime: AccountRuntime): string;
+/** Environment a spawn needs to run as this account. Empty for the default. */
+export declare function accountEnv(record: AccountRecord | undefined): NodeJS.ProcessEnv;
+/** POSIX single-quote a path for a shell command (pasted, or run as a hook). */
+export declare function shellQuote(value: string): string;
+/** The exact command that signs this account in, for the operator to run. */
+export declare function signInCommand(record: AccountRecord): string;
+export interface AuthCheck {
+    state: AuthState;
+    /** What the login itself says it bills to, when it says. */
+    billing?: AccountBilling;
+}
+/** Runs one short command with extra env; resolves exit code and stdout. Never rejects. */
+export type CommandRunner = (command: string, args: string[], env: NodeJS.ProcessEnv) => Promise<{
+    code: number | null;
+    stdout: string;
+}>;
+export declare const defaultCommandRunner: CommandRunner;
+/**
+ * Ask the agent CLI whether this account is signed in.
+ *
+ * Claude Code: `claude auth status --json` — only `loggedIn` and `authMethod`
+ * are read (the same JSON carries the email and org, which are dropped here).
+ * Codex: `codex login status` — exit 0 means signed in; its one line says
+ * whether that is ChatGPT or an API key. A CLI that can't be run, or answers
+ * something we don't recognise, is `unknown` — never `expired` on a guess.
+ */
+export declare function checkAuth(record: AccountRecord, options?: {
+    binary?: string;
+    run?: CommandRunner;
+}): Promise<AuthCheck>;
+/**
+ * Poll until the operator has finished signing in, or until the deadline.
+ * Resolves the last check either way.
+ */
+export declare function waitForSignIn(record: AccountRecord, options: {
+    timeoutMs: number;
+    intervalMs?: number;
+    check?: (record: AccountRecord) => Promise<AuthCheck>;
+    sleep?: (ms: number) => Promise<void>;
+    now?: () => number;
+}): Promise<AuthCheck>;
+/**
+ * Wire block for one account. `billing` is what the login itself reported
+ * when it said; the value given at `account add` is only the fallback.
+ */
+export declare function accountBlock(record: AccountRecord, state: AuthState, billing?: AccountBilling): AccountBlock;
+/**
+ * The account an agent home runs on: `agent.json`'s `account`, or the default.
+ *
+ * `undefined` when the home names an account that is not on this machine —
+ * the caller refuses to run rather than quietly using another subscription.
+ */
+export declare function resolveAgentAccount(label: string | undefined, runtime: AccountRuntime, env?: NodeJS.ProcessEnv): AccountRecord | undefined;
+export type ConfigUpdateOutcome = {
+    applied: true;
+    record: AccountRecord;
+    changed: boolean;
+} | {
+    applied: false;
+    reason: string;
+};
+/**
+ * Apply an account picked in ProhostAI (`agent.config_updated` or
+ * `auth_ok.agent_config`): find it on this machine and persist it to the agent
+ * home's `agent.json`, so it is used from the next run and survives a restart.
+ *
+ * An unknown key, or one belonging to another runtime, changes nothing.
+ */
+export declare function applyAccountKey(key: unknown, runtime: AccountRuntime, env?: NodeJS.ProcessEnv): ConfigUpdateOutcome;
+/** Persist an account choice made on this machine (`--account`). Validates it exists. */
+export declare function setAgentAccount(label: string, runtime: AccountRuntime | undefined, env?: NodeJS.ProcessEnv): void;
+/** Whether the registry file exists at all (for `agent list`'s empty state). */
+export declare function hasRegistry(env?: NodeJS.ProcessEnv): boolean;