@prohost/cli 0.11.0 → 0.12.0

package/CHANGELOG.md

@@ -4,6 +4,32 @@ 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.12.0
+
+- **`agent run` handles up to three conversations at once by default.**
+  `--concurrency` used to default to 1, so a one-line question in one thread
+  waited behind a long job in another. It now defaults to 3. Runs in the same
+  conversation still take turns, in order; only different conversations
+  overlap.
+- **This changes existing pairings on upgrade.** `install-daemon` records
+  `--concurrency` only when it was given, so a daemon installed without it
+  goes from one run at a time to three once it restarts on 0.12.0. Two things
+  follow:
+  - every run spends the same login's quota, so at busy times a subscription's
+    window is used up to three times as fast;
+  - without `--repos`, overlapping runs share every checkout on the machine.
+    Each run is told so, and told not to switch a shared checkout's branch.
+    Pass `--repos` to give each conversation its own.
+- **`--concurrency 1` is the old behaviour**, exactly: one run at a time, in
+  arrival order, and a prompt that says nothing about sharing the machine. For
+  a daemon, run `install-daemon` again with `--concurrency 1`.
+- **`--repos ~/app,~/site` means what it says.** A shell expands only the `~`
+  that starts the word, so every entry after the first used to resolve to a
+  directory named `~` under the current one. The CLI now reads a leading `~`
+  or `~/` on each entry as the home directory.
+- The startup line that reports the limit says when it is the default and how
+  to turn it off.
+
 ## 0.11.0
 
 - **Pair only with the workspace you expect.** `prohost agent pair --code <c>

package/README.md

@@ -513,9 +513,9 @@ 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 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
+Up to three runs are handled at once, in different conversations (see "Running
+several conversations at once"; `--concurrency 1` is one at a time), 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
 your agent a second time. That matters because your agent holds a credential:
@@ -569,21 +569,30 @@ 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:
+Up to three runs execute at once, so a one-line question in one thread does
+not sit behind a two-hour job in another. `--concurrency <n>` (1 to 16) sets
+the limit:
 
 ```bash
-prohost agent run --exec 'claude -p' --concurrency 3 --repos ~/code/app,~/code/site
+prohost agent run --exec 'claude -p' --concurrency 5 --repos ~/code/app,~/code/site
 ```
 
+`--concurrency 1` is one run at a time, in the order they arrived — what every
+version before 0.12.0 did unless told otherwise.
+
 - **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.
+  subscription's 5-hour window about three times as fast. Lower the limit if
+  the window runs out at busy times.
 - **They share the machine.** The agent is told other runs may be executing
-  beside it. If it edits code, also pass `--repos`.
+  beside it and, without `--repos`, that no git checkout is its own. If it
+  edits code, pass `--repos`.
+- **A daemon follows the default.** `install-daemon` records `--concurrency`
+  only when you give it, so a daemon installed without it runs three at once
+  after upgrading to 0.12.0 and restarting. Reinstall with `--concurrency 1`
+  to keep it at one.
 
 `--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
@@ -601,7 +610,7 @@ 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
+`--repos` works at any `--concurrency`, 1 included. 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.
 
@@ -659,7 +668,7 @@ 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". |
+| `--concurrency` | `3` | How many runs may execute at once (1–16); `1` is one at a time. 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". |

package/dist/agent/daemon.d.ts

@@ -90,7 +90,10 @@ export interface HarnessInvocation {
     allowUnverified?: boolean;
     /** Gate tools behind permission prompts (the `--safe-tools` opt-out). */
     safeTools?: boolean;
-    /** Runs allowed at once; omitted for the default of one. */
+    /**
+     * Runs allowed at once. Omitted unless `--concurrency` was given, so an
+     * installed daemon follows the CLI's default rather than freezing one.
+     */
     concurrency?: number;
     /** Absolute checkouts each conversation gets its own worktree of. */
     repos?: string[];

package/dist/agent/prompt.d.ts

@@ -74,7 +74,7 @@ export interface PromptContext {
     idleTimeoutMs?: number;
     /**
      * Other runs may be executing on this machine at the same moment
-     * (`--concurrency` above 1).
+     * (the default; `--concurrency 1` turns it off).
      *
      * Said because it changes what is safe: an agent that believes it has the
      * machine to itself switches branches in a shared checkout and writes

package/dist/agent/prompt.js

@@ -10,7 +10,7 @@ import { NO_REPLY_TOKEN } from './contract.js';
 /**
  * What the agent is told about sharing the machine and where its checkouts are.
  *
- * Empty when neither `--concurrency` nor `--repos` is in play.
+ * Empty for `--concurrency 1` without `--repos`.
  */
 function isolationLines(context) {
     const lines = [];
@@ -18,6 +18,12 @@ function isolationLines(context) {
     const failures = context.checkoutFailures ?? [];
     if (context.parallel) {
         lines.push('- Other conversations may be running on this machine right now, as other', '  processes of you, in this same working directory. Give any scratch file', '  a name unique to this run, and do not assume a file or a git branch', '  you did not create in this conversation is yours to change.');
+        // Without `--repos` — the usual pairing — nothing moves a run off the
+        // checkouts its standing instructions name, and `git switch` there changes
+        // the files under whichever run is reading them.
+        if (checkouts.length === 0 && failures.length === 0) {
+            lines.push('- No git checkout on this machine is private to this conversation.', '  Another run may be reading one while you work, so do not switch its', '  branch or leave it half-changed: if the work needs a branch of its', '  own, do it in a separate `git worktree` you create for it.');
+        }
     }
     if (checkouts.length > 0) {
         lines.push('- This conversation has its own git checkouts. Do all repository work', '  in them, and nowhere else:', ...checkouts.map((checkout) => `    ${checkout.name}: ${checkout.path}`), '  They are worktrees private to this conversation and they persist', '  between your runs here, so a branch or an uncommitted change you find', '  in one is your own earlier work in this thread. Wherever your other', '  instructions name one of these as the place to work, use the path', '  above instead:', ...checkouts.map((checkout) => `    ${checkout.source}`), '  Never switch branches, commit, or edit files in those originals —', '  other runs read them. Do not run `git worktree add` yourself.');

package/dist/agent/run.d.ts

@@ -10,12 +10,13 @@
  *
  * Two deliberate safety properties:
  *
- * * **Runs are serialized by default.** One local agent, one run at a time;
- *   concurrent frames queue. Agents hold working directories and rate limits,
- *   and running several at once is a good way to corrupt both. `--concurrency`
- *   raises the limit for runs in *different* conversations only — two turns of
- *   one conversation never overlap (see `scheduler.ts`) — and `--repos` gives
- *   each conversation its own git checkouts to do it in (see `worktrees.ts`).
+ * * **Runs in one conversation are serialized.** Two turns of one conversation
+ *   never overlap (see `scheduler.ts`). Runs in *different* conversations may:
+ *   up to `--concurrency` of them at once, {@link DEFAULT_CONCURRENCY} when the
+ *   flag is absent, and frames beyond that queue. Agents hold working
+ *   directories and rate limits, so every overlapping run is told it is
+ *   sharing the machine, `--repos` gives each conversation its own git
+ *   checkouts (see `worktrees.ts`), and `--concurrency 1` is one run at a time.
  * * **Runs are deduped on ``run_id``.** Webhook deliveries retry, and each
  *   attempt is mirrored to this socket. Without dedupe a retry would execute
  *   the command a second time and post a second reply.
@@ -108,9 +109,10 @@ export interface AgentRunOptions {
      */
     cwd?: string;
     /**
-     * How many runs may execute at once. Defaults to 1 — one run at a time, as
-     * before. Above 1, runs in different conversations overlap; runs in the same
-     * conversation still wait for each other.
+     * How many runs may execute at once. Defaults to
+     * {@link DEFAULT_CONCURRENCY}. Above 1, runs in different conversations
+     * overlap; runs in the same conversation still wait for each other. 1 is one
+     * run at a time, in arrival order.
      */
     concurrency?: number;
     /**

package/dist/agent/run.js

@@ -10,12 +10,13 @@
  *
  * Two deliberate safety properties:
  *
- * * **Runs are serialized by default.** One local agent, one run at a time;
- *   concurrent frames queue. Agents hold working directories and rate limits,
- *   and running several at once is a good way to corrupt both. `--concurrency`
- *   raises the limit for runs in *different* conversations only — two turns of
- *   one conversation never overlap (see `scheduler.ts`) — and `--repos` gives
- *   each conversation its own git checkouts to do it in (see `worktrees.ts`).
+ * * **Runs in one conversation are serialized.** Two turns of one conversation
+ *   never overlap (see `scheduler.ts`). Runs in *different* conversations may:
+ *   up to `--concurrency` of them at once, {@link DEFAULT_CONCURRENCY} when the
+ *   flag is absent, and frames beyond that queue. Agents hold working
+ *   directories and rate limits, so every overlapping run is told it is
+ *   sharing the machine, `--repos` gives each conversation its own git
+ *   checkouts (see `worktrees.ts`), and `--concurrency 1` is one run at a time.
  * * **Runs are deduped on ``run_id``.** Webhook deliveries retry, and each
  *   attempt is mirrored to this socket. Without dedupe a retry would execute
  *   the command a second time and post a second reply.
@@ -43,7 +44,7 @@ import { HeartbeatLoop } from './heartbeat.js';
 import { buildPrompt, replyFromStdout } from './prompt.js';
 import { NO_CAPABILITIES, capabilityProbe } from './capabilities.js';
 import { RunStore } from './runstore.js';
-import { MAX_CONCURRENCY, RunScheduler } from './scheduler.js';
+import { DEFAULT_CONCURRENCY, MAX_CONCURRENCY, RunScheduler } from './scheduler.js';
 import { RUNTIME_STATUS_FEATURE, RuntimeStatusReporter, claudeQuotaProvider, codexConfiguredModel, codexQuotaProvider, modelFromExec, parseVersion, readCodexObservation, } from './runtime_status.js';
 import { SessionStore, sessionKeyFor } from './sessionstore.js';
 import { verifySignature } from './signature.js';
@@ -1152,11 +1153,11 @@ export async function runAgentHarness(options) {
         }
         return true;
     };
-    const concurrency = Math.min(MAX_CONCURRENCY, Math.max(1, Math.floor(options.concurrency ?? 1)));
+    const concurrency = Math.min(MAX_CONCURRENCY, Math.max(1, Math.floor(options.concurrency ?? DEFAULT_CONCURRENCY)));
     const scheduler = new RunScheduler(concurrency);
     const worktrees = new WorktreeManager({ repos: options.repos ?? [], env: options.env, log });
     if (concurrency > 1) {
-        log(`${timestamp()} ⚙ up to ${concurrency} runs at once — runs in the same conversation still take turns` +
+        log(`${timestamp()} ⚙ up to ${concurrency} runs at once${options.concurrency === undefined ? ' (the default; --concurrency 1 for one at a time)' : ''} — runs in the same conversation still take turns` +
             (worktrees.enabled
                 ? ''
                 : '. No --repos given: runs share every checkout on this machine, so name the ' +

package/dist/agent/scheduler.d.ts

@@ -2,10 +2,11 @@
  * Which accepted runs execute now, and which wait.
  *
  * `agent run` used to chain every run onto one promise: one local agent, one
- * run at a time. That is still the default, and with a limit of 1 this
- * scheduler is exactly that chain — strict arrival order, nothing overlapping.
+ * run at a time. With a limit of 1 this scheduler is still exactly that chain
+ * — strict arrival order, nothing overlapping — and `--concurrency 1` asks for
+ * it. The harness default is {@link DEFAULT_CONCURRENCY}.
  *
- * `--concurrency N` lifts the limit without lifting the rule that actually
+ * A limit above 1 lifts the cap without lifting the rule that actually
  * protects an answer: **two runs on the same lane never overlap, and they start
  * in the order they arrived.** A lane is a conversation (see `sessionKeyFor`).
  * Each turn resumes the session the previous turn left, so running two turns of
@@ -19,6 +20,13 @@
  */
 /** Most runs one harness will execute at once, whatever the flag says. */
 export declare const MAX_CONCURRENCY = 16;
+/**
+ * Runs `agent run` executes at once when `--concurrency` is not given.
+ *
+ * Not 1: a one-line question in one thread should not sit behind a two-hour
+ * job in another. Not higher: every run spends the same login's quota.
+ */
+export declare const DEFAULT_CONCURRENCY = 3;
 export declare class RunScheduler {
     private readonly limit;
     private readonly pending;

package/dist/agent/scheduler.js

@@ -2,10 +2,11 @@
  * Which accepted runs execute now, and which wait.
  *
  * `agent run` used to chain every run onto one promise: one local agent, one
- * run at a time. That is still the default, and with a limit of 1 this
- * scheduler is exactly that chain — strict arrival order, nothing overlapping.
+ * run at a time. With a limit of 1 this scheduler is still exactly that chain
+ * — strict arrival order, nothing overlapping — and `--concurrency 1` asks for
+ * it. The harness default is {@link DEFAULT_CONCURRENCY}.
  *
- * `--concurrency N` lifts the limit without lifting the rule that actually
+ * A limit above 1 lifts the cap without lifting the rule that actually
  * protects an answer: **two runs on the same lane never overlap, and they start
  * in the order they arrived.** A lane is a conversation (see `sessionKeyFor`).
  * Each turn resumes the session the previous turn left, so running two turns of
@@ -19,6 +20,13 @@
  */
 /** Most runs one harness will execute at once, whatever the flag says. */
 export const MAX_CONCURRENCY = 16;
+/**
+ * Runs `agent run` executes at once when `--concurrency` is not given.
+ *
+ * Not 1: a one-line question in one thread should not sit behind a two-hour
+ * job in another. Not higher: every run spends the same login's quota.
+ */
+export const DEFAULT_CONCURRENCY = 3;
 export class RunScheduler {
     limit;
     pending = [];

package/dist/agent/worktrees.d.ts

@@ -72,10 +72,16 @@ export declare function laneDirName(lane: string): string;
  * forever. A running harness instead reports the checkout it could not make on
  * each run, and keeps answering.
  *
+ * A leading `~` is the home directory. A shell only expands the one that
+ * starts the word, so in `--repos ~/app,~/site` the second arrives as typed —
+ * and resolved as-is it would name a directory called `~` under wherever the
+ * harness was started.
+ *
  * @throws ReposFlagError naming the entry that is wrong.
  */
 export declare function parseReposFlag(raw: string, options?: {
     requireCheckouts?: boolean;
+    home?: string;
 }): string[];
 /** Whether `repo` is the top of a git checkout (a clone, or a worktree of one). */
 export declare function isCheckout(repo: string): boolean;

package/dist/agent/worktrees.js

@@ -30,6 +30,7 @@
 import { execFile } from 'node:child_process';
 import { createHash } from 'node:crypto';
 import { existsSync, mkdirSync, readdirSync, rmdirSync, rmSync, statSync, utimesSync, writeFileSync } from 'node:fs';
+import os from 'node:os';
 import path from 'node:path';
 import { prohostHome } from './credentials.js';
 /** Child-process env var naming the directory that holds this run's checkouts. */
@@ -83,6 +84,11 @@ function lastLine(text) {
  * forever. A running harness instead reports the checkout it could not make on
  * each run, and keeps answering.
  *
+ * A leading `~` is the home directory. A shell only expands the one that
+ * starts the word, so in `--repos ~/app,~/site` the second arrives as typed —
+ * and resolved as-is it would name a directory called `~` under wherever the
+ * harness was started.
+ *
  * @throws ReposFlagError naming the entry that is wrong.
  */
 export function parseReposFlag(raw, options = {}) {
@@ -95,7 +101,7 @@ export function parseReposFlag(raw, options = {}) {
     const repos = [];
     const names = new Map();
     for (const entry of entries) {
-        const repo = path.resolve(entry);
+        const repo = path.resolve(expandHome(entry, options.home));
         if (options.requireCheckouts && !isCheckout(repo)) {
             throw new ReposFlagError(`--repos: ${repo} is not the top of a git checkout (no .git there).`);
         }
@@ -110,6 +116,11 @@ export function parseReposFlag(raw, options = {}) {
     }
     return repos;
 }
+function expandHome(entry, home = os.homedir()) {
+    if (entry === '~')
+        return home;
+    return entry.startsWith('~/') ? path.join(home, entry.slice(2)) : entry;
+}
 /** Whether `repo` is the top of a git checkout (a clone, or a worktree of one). */
 export function isCheckout(repo) {
     return existsSync(path.join(repo, '.git'));

package/dist/index.js

@@ -65,10 +65,10 @@ function printHelp() {
         '  --timeout        Seconds one run may take before it is killed, however busy it is.',
         '                   Defaults to 0 — no wall-clock limit, because a long run is not a stuck',
         '                   one. Set it if you want a hard ceiling as well as the stall watchdog.',
-        '  --concurrency    How many runs may execute at once, 1 to 16. Defaults to 1. Runs in the same',
+        '  --concurrency    How many runs may execute at once, 1 to 16. Defaults to 3. Runs in the same',
         '                   conversation always take turns, so only different conversations overlap.',
         '                   Every run spends the same login\'s quota, and they share this machine —',
-        '                   pair it with --repos if the agent edits code.',
+        '                   pair it with --repos if the agent edits code. Pass 1 for one run at a time.',
         '  --repos          Comma-separated git checkouts the agent works on. Each conversation gets',
         '                   its own `git worktree` of every one under $PROHOST_HOME/worktrees, kept for',
         '                   the life of the thread and removed after 14 idle days if it is clean. The',

package/dist/version.d.ts

@@ -7,6 +7,6 @@
  * `package.json`, so a release bump that forgets this file fails the suite
  * instead of shipping a `User-Agent` that lies about which build is calling.
  */
-export declare const CLI_VERSION = "0.11.0";
+export declare const CLI_VERSION = "0.12.0";
 /** Sent on every HTTP request the CLI makes back into ProhostAI. */
-export declare const USER_AGENT = "prohost-cli/0.11.0";
+export declare const USER_AGENT = "prohost-cli/0.12.0";

package/dist/version.js

@@ -7,6 +7,6 @@
  * `package.json`, so a release bump that forgets this file fails the suite
  * instead of shipping a `User-Agent` that lies about which build is calling.
  */
-export const CLI_VERSION = '0.11.0';
+export const CLI_VERSION = '0.12.0';
 /** Sent on every HTTP request the CLI makes back into ProhostAI. */
 export const USER_AGENT = `prohost-cli/${CLI_VERSION}`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prohost/cli",
-  "version": "0.11.0",
+  "version": "0.12.0",
   "description": "Run your own AI agent as a ProhostAI teammate, and stream your account's webhooks to your laptop.",
   "type": "module",
   "license": "MIT",