@prohost/cli 0.8.3 → 0.10.0

package/CHANGELOG.md

@@ -4,6 +4,71 @@ 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.10.0
+
+Every Claude Code and Codex login on a machine can report its remaining
+capacity and token use to ProhostAI, without pairing an agent.
+
+- **`prohost usage connect [--key <key>]`** stores an API key with the
+  `usage:write` scope in `$PROHOST_HOME/usage.json` (`0600`, never printed). A
+  machine that already paired an agent can skip `--key`; its credential is
+  accepted.
+- **Discovery.** `connect`, `usage discover [--dry-run]` and every `usage start`
+  register the config directories already on the machine — `~/.claude*`,
+  `~/.codex*`, `$CLAUDE_CONFIG_DIR`, `$CODEX_HOME` — in the machine-wide account
+  registry, labelled from the directory name (`~/.claude-work` → `work`). Only
+  directory names and non-secret markers are looked at.
+- **`prohost usage start`** reports every 5 minutes (`POST /v1/usage/reports`,
+  source `cli`): each login's windows from the same idle probes `agent run`
+  uses, asked at most every 15 minutes per login, three at a time.
+- **Token totals** from the CLIs' own session logs, summed per local day,
+  login, model and project folder name (`POST /v1/usage/token-totals`). Claude
+  Code responses are counted once however often their lines repeat; Codex usage
+  is the growth of each session's running total, with cached input split out.
+  The first run looks back 30 days, then reads only appended lines. No prompt
+  text is read into the totals or sent.
+  Totals for a login are sent only once a capacity report for it has been
+  accepted (`acceptedAccountKeys` when the server names them; otherwise any
+  non-zero `accepted`), so a first run or a newly found login reports first.
+  Skipped rows follow the server's `skipped[].reason`: `not_owned`,
+  `other_source` and `out_of_range` are dropped (logged once), `throttled` is
+  retried next pass, `not_reported` waits for the next accepted report. Rows
+  skipped without a reason are retried at most three times.
+- **Fails soft.** A 401/403/404 (routes not deployed, feature off, key without
+  the scope) is logged once and retried every 30 minutes; network errors back
+  off exponentially. A tick never throws.
+- **`prohost usage install-daemon` / `uninstall-daemon`** keep it running under
+  launchd with its own label (`ai.prohost.usage.*`), next to any agent daemon.
+  **`prohost usage status`** shows what was last sent and local totals.
+- `prohost agent account remove` on a login registered from an existing
+  directory forgets it and leaves the directory in place.
+
+## 0.9.0
+
+A quick question no longer waits behind a long job in another thread.
+
+- **`agent run --concurrency <n>`** (1–16, default 1) lets runs in different
+  conversations execute at once. Runs in the same conversation still take
+  turns in arrival order, because each turn resumes the session the previous
+  one left. Without the flag nothing changes: one run at a time, in order.
+  Queued runs are heartbeated and can be stopped exactly as before.
+- **`agent run --repos <checkout,…>`** gives every conversation its own
+  `git worktree` of each named repository under `$PROHOST_HOME/worktrees`,
+  so two runs never share a branch or a half-edited file. The prompt names
+  the checkouts and tells the agent to leave the originals alone, and the
+  directory is exported as `PROHOST_RUN_REPOS`. A conversation keeps its
+  checkouts between runs; they are removed after 14 idle days unless they
+  hold uncommitted or untracked files. A checkout that cannot be made does
+  not fail the run — the agent is told that repository is read-only for it.
+- **`install-daemon` passes both flags through**, and validates them first so
+  a typo cannot crash-loop the daemon.
+- **`PROHOST_PAIRED_RUN=1`** is set for every agent command the harness
+  starts. ProhostAI's own PR protocol uses it to end a run once the pull
+  request is open instead of holding the slot while CI runs.
+- With `--concurrency` above 1 the agent is told other runs may be executing
+  beside it. The strict Claude MCP config is now written atomically, since
+  another run's `claude` may be reading it at that moment.
+
 ## 0.8.3
 
 A paired agent's shell steps read as what they do, not "Running a command".

package/README.md

@@ -1,12 +1,15 @@
 # `@prohost/cli`
 
-The [ProhostAI](https://www.prohost.ai) command-line tool. Two things it does:
+The [ProhostAI](https://www.prohost.ai) command-line tool. Three things it does:
 
 - **`prohost agent`** — run your own local agent as a ProhostAI teammate. Someone
   @-mentions it in the app, it runs on your machine, and its answer is posted
   back into the conversation.
 - **`prohost listen`** — stream your account's webhooks to a local HTTP endpoint
   while you develop against them (like `stripe listen`).
+- **`prohost usage`** — show your workspace how much Claude Code and Codex
+  capacity every login on this machine has left, and how many tokens each one
+  used, without pairing an agent.
 
 You need a ProhostAI account and **Node.js 18 or newer**. Nothing to install —
 `npx` fetches it on demand:
@@ -430,7 +433,8 @@ on the machine via `ps` and a process environment is not. Literal `headers`,
 treatment: the CLI translates them to Codex's environment-indirection fields,
 so their values do not appear in process arguments.
 
-Runs are handled one at a time, and each run executes **at most once on this
+Runs are handled one at a time unless you raise `--concurrency` (see "Running
+several conversations at once"), and each run executes **at most once on this
 machine** — even across restarts. Started runs are recorded in
 `~/.prohost/runs.json` before the command launches, so a webhook redelivery
 that arrives after a crash or restart will close the run out rather than run
@@ -483,6 +487,48 @@ prohost agent list                                    # every agent here, its ac
 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`.
 
+### Running several conversations at once
+
+By default a second request waits for the first, however unrelated they are —
+a one-line question in one thread sits behind a two-hour job in another.
+`--concurrency <n>` (1 to 16) lets up to `n` runs execute at once:
+
+```bash
+prohost agent run --exec 'claude -p' --concurrency 3 --repos ~/code/app,~/code/site
+```
+
+- **Runs in the same conversation still take turns, in order.** Each turn
+  resumes the session the last one left, so two turns of one thread never
+  overlap. Only different conversations run side by side.
+- **Every run spends the same login's quota.** Three runs at once use a
+  subscription's 5-hour window about three times as fast. Start small.
+- **They share the machine.** The agent is told other runs may be executing
+  beside it. If it edits code, also pass `--repos`.
+
+`--repos` takes a comma-separated list of git checkouts the agent works on.
+Each conversation then gets its own `git worktree` of every one, at
+`~/.prohost/worktrees/<conversation>/<repo-name>`, made on that conversation's
+first run. The agent is told to do its repository work there and to leave your
+originals alone; the directory is also exported to the command as
+`$PROHOST_RUN_REPOS`. Its working directory does not change — it is still the
+workspace, which is where its configuration and its sessions live.
+
+A conversation keeps its checkouts between runs, so a follow-up finds the
+branch the last run left. After 14 days without a run they are removed with
+`git worktree remove`, which refuses a checkout holding uncommitted or
+untracked files — those are kept and logged. Committed branches live in your
+original repository and are never touched. Each worktree is a full working
+copy, and dependencies installed inside it are not shared, so budget disk for
+it.
+
+`--repos` works without `--concurrency` too. If a checkout cannot be made (a
+full disk, a path that is no longer a repository), the run still happens: the
+agent is told to treat that repository as read-only for the run.
+
+Every command the harness starts has `PROHOST_PAIRED_RUN=1` in its
+environment, so instructions your agent reads from disk can tell a paired run
+from any other use of the same files.
+
 ### A developer workspace
 
 For an agent that works on the ProhostAI codebase, `prohost agent workspace
@@ -533,6 +579,8 @@ same judgement.
 | `--exec` | *(required)* | Command to run for each requested run. Prompt arrives on stdin. |
 | `--idle-timeout` | `900` | Seconds a run may produce **no output at all** before it is treated as stalled and killed. Any byte on stdout or stderr resets it. `0` disables it — see "Long runs". |
 | `--timeout` | `0` | Seconds one run may take before the command is killed, however busy it is. `0` — the default — means no wall-clock limit. Set it if you want a hard ceiling as well. |
+| `--concurrency` | `1` | How many runs may execute at once (1–16). Runs in one conversation always take turns. See "Running several conversations at once". |
+| `--repos` | — | Comma-separated git checkouts the agent works on. Each conversation gets its own worktree of every one. |
 | `--dry-run` | off | Print the reply that would be posted; write nothing. |
 | `--workdir` | `~/.prohost/workspace` | Working directory for the command. See "Where your agent runs". |
 | `--cwd` | — | Deprecated alias for `--workdir`. |
@@ -683,6 +731,75 @@ through ProhostAI's own approval path, not around it via an API key.
 
 ---
 
+## AI usage reporting
+
+`prohost usage` reports, for every Claude Code and Codex login on this machine,
+how much of its subscription is left (the 5-hour and weekly windows, with their
+reset times) and how many tokens it used per day, model and project folder.
+ProhostAI shows it in the workspace's AI Usage view. No agent pairing needed.
+
+```bash
+# 1. In ProhostAI: Settings → API keys → create a key with the usage:write scope.
+#    (A machine with a paired agent can skip --key: its credential is accepted.)
+npx @prohost/cli usage connect --key <api-key>
+
+# 2. Report now, then every 5 minutes, in the foreground…
+npx @prohost/cli usage start
+
+# …or keep it running across reboots (macOS launchd; prints a systemd unit on Linux).
+npx @prohost/cli usage install-daemon
+
+npx @prohost/cli usage status    # logins, last report, local token totals
+```
+
+**Which logins.** `connect`, `discover` and every `start` register the config
+directories already on this machine: `~/.claude`, `~/.codex` (as `default`) and
+any `~/.claude-<name>` / `~/.codex-<name>` (as `<name>` — `~/.claude-work` is
+`work`), plus `$CLAUDE_CONFIG_DIR` and `$CODEX_HOME`. They join the same
+machine-wide registry `prohost agent account` uses (`~/.prohost-accounts`), so a
+login added there is reported too. `prohost usage discover --dry-run` shows what
+would be registered without writing anything. Removing a discovered login with
+`prohost agent account remove` leaves its directory alone.
+
+**Capacity.** Each login is asked at most every 15 minutes, three at a time,
+through the unmodified CLI with that login's directory — `claude`'s `get_usage`
+control request and `codex app-server`'s `account/rateLimits/read`. Neither
+spends a model turn. Sign-in state comes from `claude auth status` /
+`codex login status`. `prohost` never opens a credential file or keychain item.
+
+**Tokens.** Read from the session logs the CLIs already write —
+`<config dir>/projects/**/*.jsonl` for Claude Code, `sessions/**/rollout-*.jsonl`
+for Codex — and summed per local day, login, model and project, where the
+project is the **name** of the working directory (`backend-service`, never its
+path). Only usage counters are read: no prompt, reply, tool call or file content
+is kept or sent. The first run looks back 30 days; after that only what was
+appended is read, using a cursor in `$PROHOST_HOME/usage/`. A day that changes
+is re-sent whole, and the server replaces it.
+Totals for a login go only after the server has accepted a capacity report
+for it (the server ignores totals for logins it hasn't seen), so each pass
+reports first. When the server says why it skipped a login's rows, the reason
+decides: another user's or another source's login, or a day out of range, is
+dropped (logged once); `throttled` is retried next pass; `not_reported` waits
+for the next accepted report. Unexplained skips are retried at most three
+times, so a login the server never takes is never resent forever and never
+holds up the others.
+
+**If the server says no.** Before the feature is enabled for your workspace
+(or with a key that lacks `usage:write`) the server answers 403/404. The reporter
+logs that once, waits 30 minutes, and tries again — it never exits over it.
+Network errors are retried with backoff. Logs go to `$PROHOST_HOME/usage.log`
+under the daemon.
+
+| Command | What it does |
+| --- | --- |
+| `usage connect [--key <key>] [--base-url <url>]` | Store the key (`$PROHOST_HOME/usage.json`, `0600`; `$PROHOST_API_KEY` works too), then discover logins. |
+| `usage discover [--dry-run]` | Register logins found on this machine. |
+| `usage start [--once] [--machine <name>]` | Report every 5 minutes; `--once` runs one pass and exits. |
+| `usage status` | Connection, daemon, last report and upload, and each login's local totals. |
+| `usage install-daemon [--machine <name>]` / `uninstall-daemon` | Keep `usage start` running (its own launchd job, separate from the agent's). |
+
+---
+
 ## Local webhook forwarding
 
 ```bash

package/dist/agent/account_runtime.d.ts

@@ -24,6 +24,15 @@ export declare class HarnessAccount {
     private readonly initialLabel;
     /** Label the most recent run was spawned with — what a run in flight is using. */
     private spawnedLabel;
+    /**
+     * Labels of the runs executing right now, oldest first.
+     *
+     * One value was enough while runs were serialized. With `--concurrency`, a
+     * pick can land while one run is on the old account and the next run then
+     * starts on the new one — and a single field would let the second overwrite
+     * what the first is using.
+     */
+    private readonly inFlight;
     /** `requested_at` of the newest pick applied, so a late older one is dropped. */
     private appliedRequestedAt;
     constructor(options: {
@@ -45,8 +54,13 @@ export declare class HarnessAccount {
     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;
+    /** The run spawned on `label` has ended. Pairs with {@link resolveForSpawn}. */
+    finishSpawn(label: string): void;
+    /**
+     * Whether the chosen account differs from the one a run was spawned with —
+     * the given run's, or the most recent run's when none is named.
+     */
+    changedSinceSpawn(spawned?: string | undefined): boolean;
     /** Spawn environment for the current account; empty when it can't be resolved. */
     spawnEnv(): NodeJS.ProcessEnv;
     /**
@@ -67,7 +81,9 @@ export declare class HarnessAccount {
      *
      * 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.
+     * credit that run's capacity to an account it isn't using. With several runs
+     * executing it is the oldest one's: the pick is not fulfilled until the last
+     * run on the previous account has ended.
      */
     snapshot(busy?: boolean): Promise<AccountsSnapshot>;
     /** The command that signs the current account in, for a log line. */

package/dist/agent/account_runtime.js

@@ -17,6 +17,15 @@ export class HarnessAccount {
     initialLabel;
     /** Label the most recent run was spawned with — what a run in flight is using. */
     spawnedLabel;
+    /**
+     * Labels of the runs executing right now, oldest first.
+     *
+     * One value was enough while runs were serialized. With `--concurrency`, a
+     * pick can land while one run is on the old account and the next run then
+     * starts on the new one — and a single field would let the second overwrite
+     * what the first is using.
+     */
+    inFlight = [];
     /** `requested_at` of the newest pick applied, so a late older one is dropped. */
     appliedRequestedAt;
     constructor(options) {
@@ -50,13 +59,24 @@ export class HarnessAccount {
     /** {@link resolve} for a run about to be spawned; remembers which account it got. */
     resolveForSpawn() {
         const resolved = this.resolve();
-        if (resolved.ok)
+        if (resolved.ok) {
             this.spawnedLabel = resolved.record.label;
+            this.inFlight.push(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();
+    /** The run spawned on `label` has ended. Pairs with {@link resolveForSpawn}. */
+    finishSpawn(label) {
+        const index = this.inFlight.indexOf(label);
+        if (index !== -1)
+            this.inFlight.splice(index, 1);
+    }
+    /**
+     * Whether the chosen account differs from the one a run was spawned with —
+     * the given run's, or the most recent run's when none is named.
+     */
+    changedSinceSpawn(spawned = this.spawnedLabel) {
+        return spawned !== undefined && spawned !== this.label();
     }
     /** Spawn environment for the current account; empty when it can't be resolved. */
     spawnEnv() {
@@ -96,10 +116,12 @@ export class HarnessAccount {
      *
      * 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.
+     * credit that run's capacity to an account it isn't using. With several runs
+     * executing it is the oldest one's: the pick is not fulfilled until the last
+     * run on the previous account has ended.
      */
     async snapshot(busy = false) {
-        const label = busy && this.spawnedLabel ? this.spawnedLabel : this.label();
+        const label = busy ? (this.inFlight[0] ?? this.spawnedLabel ?? this.label()) : this.label();
         const record = resolveAgentAccount(label, this.runtime, this.env);
         const resolved = record ? { ok: true, record } : { ok: false, error: '' };
         const records = loadAccounts(this.env);

package/dist/agent/accounts.d.ts

@@ -81,9 +81,25 @@ export declare function addAccount(options: {
     runtime: AccountRuntime;
     billing?: AccountBilling;
 }, env?: NodeJS.ProcessEnv): AccountRecord;
+/**
+ * Register a config directory that already exists — a login the operator made
+ * outside this CLI (`~/.claude-work`, a `$CODEX_HOME`). Nothing in it is read
+ * or written; signing in stays the agent CLI's own business. A directory that
+ * is already registered (under any label) is not registered twice.
+ */
+export declare function registerAccountDir(options: {
+    label: string;
+    runtime: AccountRuntime;
+    dir: string;
+    billing?: AccountBilling;
+}, env?: NodeJS.ProcessEnv): AccountRecord;
+/** Whether removing this account deletes its directory (only ones this CLI created). */
+export declare function ownsAccountDir(record: AccountRecord, env?: NodeJS.ProcessEnv): boolean;
 /**
  * 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.
+ * with it) — but only a directory this CLI created; a registered existing one
+ * is left where it is. 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;

package/dist/agent/accounts.js

@@ -236,9 +236,50 @@ function addAccountLocked(label, runtime, billing, env) {
     saveAccounts([...loadAccounts(env), record], env);
     return record;
 }
+/**
+ * Register a config directory that already exists — a login the operator made
+ * outside this CLI (`~/.claude-work`, a `$CODEX_HOME`). Nothing in it is read
+ * or written; signing in stays the agent CLI's own business. A directory that
+ * is already registered (under any label) is not registered twice.
+ */
+export function registerAccountDir(options, env = process.env) {
+    const { label, runtime } = options;
+    if (!isValidLabel(label) || label === DEFAULT_ACCOUNT_LABEL) {
+        throw new AccountError(`"${label}" is not a usable label for an existing login directory.`);
+    }
+    const dir = path.resolve(options.dir);
+    return withRegistryLock(env, () => {
+        const accounts = loadAccounts(env);
+        const same = accounts.find((a) => a.runtime === runtime && a.dir !== null && path.resolve(a.dir) === dir);
+        if (same)
+            return same;
+        if (findAccount(label, runtime, env)) {
+            throw new AccountError(`A ${runtimeName(runtime)} account named "${label}" already exists on this machine.`);
+        }
+        if (accounts.filter((a) => a.label !== DEFAULT_ACCOUNT_LABEL).length >= MAX_REPORTED_ACCOUNTS - 2) {
+            throw new AccountError(`This machine already has ${MAX_REPORTED_ACCOUNTS - 2} accounts, the most ProhostAI can show. Remove one first.`);
+        }
+        const record = {
+            key: randomUUID(),
+            label,
+            runtime,
+            billing: options.billing ?? 'subscription',
+            dir,
+            created_at: new Date().toISOString(),
+        };
+        saveAccounts([...accounts, record], env);
+        return record;
+    });
+}
+/** Whether removing this account deletes its directory (only ones this CLI created). */
+export function ownsAccountDir(record, env = process.env) {
+    return !!record.dir && record.dir.startsWith(path.join(accountsRoot(env), 'accounts') + path.sep);
+}
 /**
  * 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.
+ * with it) — but only a directory this CLI created; a registered existing one
+ * is left where it is. The implicit default can't be removed — it is the CLI's
+ * own login.
  */
 export function removeAccount(label, runtime, env = process.env) {
     if (label === DEFAULT_ACCOUNT_LABEL) {
@@ -253,7 +294,7 @@ export function removeAccount(label, runtime, env = process.env) {
         return found;
     });
     // Only ever a directory this module created under the root.
-    if (record.dir && record.dir.startsWith(path.join(accountsRoot(env), 'accounts') + path.sep)) {
+    if (ownsAccountDir(record, env) && record.dir) {
         rmSync(record.dir, { recursive: true, force: true });
     }
     return record;

package/dist/agent/agent_commands.js

@@ -4,7 +4,7 @@
  * `accounts.ts`, `list.ts` and `workspace.ts`.
  */
 import process from 'node:process';
-import { AccountError, addAccount, checkAuth, loadAccounts, parseAccountRuntime, removeAccount, runtimeName, signInCommand, waitForSignIn, } from './accounts.js';
+import { AccountError, addAccount, checkAuth, loadAccounts, ownsAccountDir, parseAccountRuntime, removeAccount, runtimeName, signInCommand, waitForSignIn, } from './accounts.js';
 import { ensureWorkspace } from './credentials.js';
 import { findAgentHomes, renderAgentList } from './list.js';
 import { WorkspaceInitError, initDeveloperWorkspace } from './workspace.js';
@@ -118,8 +118,9 @@ export async function accountCommand(args, flags, io = defaultIO) {
                 'Move them to another account first, or pass --force.');
             return 1;
         }
+        let removed;
         try {
-            removeAccount(label, target?.runtime ?? runtime ?? 'claude_code', env);
+            removed = removeAccount(label, target?.runtime ?? runtime ?? 'claude_code', env);
         }
         catch (err) {
             if (err instanceof AccountError) {
@@ -128,7 +129,9 @@ export async function accountCommand(args, flags, io = defaultIO) {
             }
             throw err;
         }
-        io.out(`✓ Removed "${label}" and its login directory.`);
+        io.out(ownsAccountDir(removed, env)
+            ? `✓ Removed "${label}" and its login directory.`
+            : `✓ Removed "${label}". Its login directory${removed.dir ? ` (${removed.dir})` : ''} was left in place.`);
         return 0;
     }
     io.err('Expected: prohost agent account add|list|remove');

package/dist/agent/api.d.ts

@@ -68,6 +68,12 @@ export declare function describeFailure(result: ApiResult): string;
  * cached, and the next replay receives its response.
  */
 export declare function isIdempotencyInFlight(result: ApiResult): boolean;
+/**
+ * POST a JSON body with the API key. Never throws: every failure comes back as
+ * an {@link ApiResult}. Exported for the `prohost usage` reporter, which owns
+ * its own paths.
+ */
+export declare function postJson(options: ApiOptions, path: string, body: unknown, idempotencyKey?: string, captureBody?: boolean, timeoutMs?: number): Promise<ApiResult>;
 /**
  * Post the agent's reply into the conversation that triggered the run.
  *

package/dist/agent/api.js

@@ -52,7 +52,12 @@ export function describeFailure(result) {
 export function isIdempotencyInFlight(result) {
     return result.status === 409 && (result.error ?? '').includes('idempotency_key_in_flight');
 }
-async function post(options, path, body, idempotencyKey, captureBody = false, timeoutMs = DEFAULT_TIMEOUT_MS) {
+/**
+ * POST a JSON body with the API key. Never throws: every failure comes back as
+ * an {@link ApiResult}. Exported for the `prohost usage` reporter, which owns
+ * its own paths.
+ */
+export async function postJson(options, path, body, idempotencyKey, captureBody = false, timeoutMs = DEFAULT_TIMEOUT_MS) {
     const fetchImpl = options.fetchImpl ?? fetch;
     const controller = new AbortController();
     const deadlineMs = options.timeoutMs ?? timeoutMs;
@@ -126,7 +131,7 @@ export async function postReply(options, path, bodyKey, message, runId, extra) {
     // thing in this request that must survive.
     // Byte-identical on every attempt: the server hashes the body against the
     // key, so a replay must serialise exactly as the original did.
-    return post(options, path, { ...extra, [bodyKey]: message }, `prohost-cli-run-${runId}`, false, SEND_TIMEOUT_MS);
+    return postJson(options, path, { ...extra, [bodyKey]: message }, `prohost-cli-run-${runId}`, false, SEND_TIMEOUT_MS);
 }
 function booleanField(body, key) {
     if (!body)
@@ -154,7 +159,7 @@ function booleanField(body, key) {
  */
 export async function heartbeatRun(options, path, progress) {
     const trimmed = progress?.trim();
-    const result = await post(options, path, trimmed ? { progress: trimmed.slice(0, MAX_PROGRESS_CHARS) } : {}, undefined, true);
+    const result = await postJson(options, path, trimmed ? { progress: trimmed.slice(0, MAX_PROGRESS_CHARS) } : {}, undefined, true);
     if (result.ok)
         return { kind: 'alive', cancelRequested: booleanField(result.body, 'cancel_requested') };
     if (result.status === 404)
@@ -180,7 +185,7 @@ export async function completeRun(options, path, outcome, model) {
         : { status: RUN_STATUS_FAILED, error: outcome.error.slice(0, MAX_ERROR_CHARS) };
     if (model)
         body.model = model.slice(0, MAX_MODEL_CHARS);
-    const result = await post(options, path, body, undefined, false, SEND_TIMEOUT_MS);
+    const result = await postJson(options, path, body, undefined, false, SEND_TIMEOUT_MS);
     if (result.status === 409)
         return { ...result, ok: true };
     return result;
@@ -195,5 +200,5 @@ export async function completeRun(options, path, outcome, model) {
  * over-fills one gets it clipped rather than rejected whole.
  */
 export async function postToolEvents(options, path, events) {
-    return post(options, path, { events: events.slice(0, MAX_TOOL_EVENTS_PER_BATCH) });
+    return postJson(options, path, { events: events.slice(0, MAX_TOOL_EVENTS_PER_BATCH) });
 }

package/dist/agent/claude.js

@@ -14,7 +14,8 @@
  * session is unresumable, if the JSON is not what we expect — the run still
  * happens and still completes. These are enhancements that must fail soft.
  */
-import { chmodSync, mkdirSync, writeFileSync } from 'node:fs';
+import { randomBytes } from 'node:crypto';
+import { chmodSync, mkdirSync, renameSync, writeFileSync } from 'node:fs';
 import path from 'node:path';
 import { prohostHome } from './credentials.js';
 import { MCP_SERVER_NAME } from './mcp.js';
@@ -697,7 +698,12 @@ export function writeMcpConfig(options) {
     const file = mcpConfigPath(env);
     mkdirSync(dir, { recursive: true, mode: 0o700 });
     chmodSync(dir, 0o700);
-    writeFileSync(file, `${JSON.stringify(buildMcpConfig(options), null, 2)}\n`, { mode: 0o600 });
-    chmodSync(file, 0o600);
+    // Written beside the target and renamed over it. Every run rewrites this
+    // file just before spawning, and with `--concurrency` another run's `claude`
+    // may be reading it at that instant — a plain write would let it read half.
+    const staged = `${file}.${process.pid}.${randomBytes(4).toString('hex')}.tmp`;
+    writeFileSync(staged, `${JSON.stringify(buildMcpConfig(options), null, 2)}\n`, { mode: 0o600 });
+    chmodSync(staged, 0o600);
+    renameSync(staged, file);
     return file;
 }

package/dist/agent/command.d.ts

@@ -29,6 +29,15 @@ export declare const INVALID_DURATION: unique symbol;
  * had not.
  */
 export declare function parseSeconds(raw: string | boolean | undefined): number | undefined | typeof INVALID_DURATION;
+/** Returned by {@link parseConcurrency} for a value that isn't a run count. */
+export declare const INVALID_CONCURRENCY: unique symbol;
+/**
+ * Read `--concurrency`. Pure, like {@link parseSeconds}, and strict for the
+ * same reason: `--concurrency` with nothing after it arrives as `true`, and
+ * treating that as absent would leave someone believing their agent runs four
+ * things at once while it runs one.
+ */
+export declare function parseConcurrency(raw: string | boolean | undefined): number | undefined | typeof INVALID_CONCURRENCY;
 /**
  * Environment the daemon must be given explicitly.
  *