@prohost/cli 0.8.3 → 0.9.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.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

@@ -430,7 +430,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 +484,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 +576,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`. |

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/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.
  *

package/dist/agent/command.js

@@ -16,6 +16,8 @@ import { acquireRunLock } from './lock.js';
 import { PairError, runPair } from './pair.js';
 import { CredentialsMissingError, ensureWorkspace, loadCredentials, prohostHome, tryLoadCredentials, } from './credentials.js';
 import { DEFAULT_EXEC_TIMEOUT_MS, DEFAULT_IDLE_TIMEOUT_MS, runAgentHarness } from './run.js';
+import { MAX_CONCURRENCY } from './scheduler.js';
+import { ReposFlagError, isCheckout, parseReposFlag } from './worktrees.js';
 import { announceUpgradeIfAvailable } from '../upgrade.js';
 function flagString(flags, name) {
     const value = flags[name];
@@ -119,6 +121,55 @@ function parseIdleTimeoutSeconds(flags) {
     }
     return parsed;
 }
+/** Returned by {@link parseConcurrency} for a value that isn't a run count. */
+export const INVALID_CONCURRENCY = Symbol('invalid-concurrency');
+/**
+ * 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 function parseConcurrency(raw) {
+    if (raw === undefined)
+        return undefined;
+    if (typeof raw !== 'string' || !/^\d+$/.test(raw.trim()))
+        return INVALID_CONCURRENCY;
+    const count = Number(raw);
+    return count >= 1 && count <= MAX_CONCURRENCY ? count : INVALID_CONCURRENCY;
+}
+/**
+ * What `--concurrency` and `--repos` asked for, or `null` after explaining why not.
+ *
+ * `installing` decides how a `--repos` path that is not a git checkout is
+ * treated — see {@link parseReposFlag}. `agent run` only warns about it.
+ */
+function parseParallelFlags(flags, installing) {
+    const concurrency = parseConcurrency(flags.concurrency);
+    if (concurrency === INVALID_CONCURRENCY) {
+        process.stderr.write(`--concurrency must be a whole number from 1 to ${MAX_CONCURRENCY}.\n`);
+        return null;
+    }
+    if (flags.repos === undefined)
+        return { concurrency };
+    const raw = flagString(flags, 'repos');
+    if (!raw) {
+        process.stderr.write('--repos needs a comma-separated list of git checkouts, e.g. --repos ~/code/app\n');
+        return null;
+    }
+    try {
+        const repos = parseReposFlag(raw, { requireCheckouts: installing });
+        for (const repo of repos.filter((entry) => !isCheckout(entry))) {
+            process.stderr.write(`! --repos: ${repo} is not a git checkout right now. Runs will be told it is read-only until it is.\n`);
+        }
+        return { concurrency, repos };
+    }
+    catch (err) {
+        if (!(err instanceof ReposFlagError))
+            throw err;
+        process.stderr.write(`✗ ${err.message}\n`);
+        return null;
+    }
+}
 /**
  * Environment the daemon must be given explicitly.
  *
@@ -210,6 +261,10 @@ async function installDaemonCommand(flags) {
     const idleTimeoutSeconds = parseIdleTimeoutSeconds(flags);
     if (idleTimeoutSeconds === INVALID_DURATION)
         return 1;
+    // Same reasoning: a bad value here would crash-loop the daemon, not print.
+    const parallel = parseParallelFlags(flags, true);
+    if (!parallel)
+        return 1;
     // Absolute, and created now. A supervisor does not inherit the installing
     // shell's current directory, so a relative `--workdir .` copied verbatim into
     // the plist names a directory that either doesn't exist or isn't the one the
@@ -235,6 +290,8 @@ async function installDaemonCommand(flags) {
         url: flagString(flags, 'url'),
         allowUnverified: flags['allow-unverified'] === true,
         safeTools: flags['safe-tools'] === true || flags['no-skip-permissions'] === true,
+        concurrency: parallel.concurrency,
+        repos: parallel.repos,
     };
     const spec = {
         label: launchdLabel(prohostHome()),
@@ -332,6 +389,9 @@ async function runCommand(flags) {
     const parsedIdleTimeout = parseIdleTimeoutSeconds(flags);
     if (parsedIdleTimeout === INVALID_DURATION)
         return 1;
+    const parallel = parseParallelFlags(flags, false);
+    if (!parallel)
+        return 1;
     // One harness per home: two would both execute every run.
     const lock = acquireRunLock();
     if (!lock.ok) {
@@ -340,8 +400,8 @@ async function runCommand(flags) {
             '`prohost agent uninstall-daemon` — or give this agent its own $PROHOST_HOME.\n');
         return 1;
     }
-    // First signal stops accepting work and lets the in-flight run finish
-    // reporting itself (so the server doesn't wait on a run we abandoned); a
+    // First signal stops accepting work and lets the in-flight runs finish
+    // reporting themselves (so the server doesn't wait on a run we abandoned); a
     // second one means the operator wants out now.
     const controller = new AbortController();
     const onSig = () => {
@@ -364,6 +424,8 @@ async function runCommand(flags) {
             url: flagString(flags, 'url') ?? process.env.PROHOST_WS_URL,
             machine: flagString(flags, 'machine'),
             cwd: requestedWorkdir(flags),
+            concurrency: parallel.concurrency,
+            repos: parallel.repos,
             timeoutMs: parsedTimeout === undefined ? DEFAULT_EXEC_TIMEOUT_MS : parsedTimeout * 1000,
             idleTimeoutMs: parsedIdleTimeout === undefined ? DEFAULT_IDLE_TIMEOUT_MS : parsedIdleTimeout * 1000,
             dryRun: flags['dry-run'] === true,

package/dist/agent/daemon.d.ts

@@ -90,6 +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. */
+    concurrency?: number;
+    /** Absolute checkouts each conversation gets its own worktree of. */
+    repos?: string[];
 }
 export declare function harnessArguments(invocation: HarnessInvocation): string[];
 /** Default log destination — alongside the credential and the run ledger. */

package/dist/agent/daemon.js

@@ -192,6 +192,10 @@ export function harnessArguments(invocation) {
         args.push('--allow-unverified');
     if (invocation.safeTools)
         args.push('--safe-tools');
+    if (invocation.concurrency !== undefined)
+        args.push('--concurrency', String(invocation.concurrency));
+    if (invocation.repos && invocation.repos.length > 0)
+        args.push('--repos', invocation.repos.join(','));
     return args;
 }
 /** Default log destination — alongside the credential and the run ledger. */

package/dist/agent/prompt.d.ts

@@ -72,6 +72,33 @@ export interface PromptContext {
      * hour" is advice about how to work, not a request to hurry.
      */
     idleTimeoutMs?: number;
+    /**
+     * Other runs may be executing on this machine at the same moment
+     * (`--concurrency` above 1).
+     *
+     * 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
+     * `scratch.json` into the working directory, and the run beside it does the
+     * same. Unset, the prompt is byte-for-byte what it was.
+     */
+    parallel?: boolean;
+    /**
+     * Git checkouts private to this run's conversation (`--repos`).
+     *
+     * Named with the checkout they were made from, because the agent's own
+     * standing instructions usually name *that* path — and the point of this
+     * block is to move it off it.
+     */
+    checkouts?: Array<{
+        name: string;
+        path: string;
+        source: string;
+    }>;
+    /** `--repos` entries no private checkout could be made of, and why. */
+    checkoutFailures?: Array<{
+        source: string;
+        reason: string;
+    }>;
 }
 /** Build the stdin prompt for one run. */
 export declare function buildPrompt(run: AgentRunRequest, context: PromptContext): string;

package/dist/agent/prompt.js

@@ -7,6 +7,26 @@
  * agent that would otherwise narrate its reasoning returns something sendable.
  */
 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.
+ */
+function isolationLines(context) {
+    const lines = [];
+    const checkouts = context.checkouts ?? [];
+    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.');
+    }
+    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.');
+    }
+    if (failures.length > 0) {
+        lines.push('- A private checkout could not be prepared for:', ...failures.map((failure) => `    ${failure.source} (${failure.reason})`), '  Treat that repository as read-only for this run: do not switch', '  branches, commit, or edit files in it, and say so if the request', '  needed a change there.');
+    }
+    return lines;
+}
 /**
  * Say the run's budget in a unit a reader thinks in.
  *
@@ -259,7 +279,7 @@ export function buildPrompt(run, context) {
     // not buried under the tool advice: how long the agent has changes how it
     // should approach the work, so it has to be read before any of the "go and
     // look" bullets below.
-    ...timeBudgetLines(context.timeoutMs, context.idleTimeoutMs), 
+    ...timeBudgetLines(context.timeoutMs, context.idleTimeoutMs), ...isolationLines(context), 
     // Claude Code lazy-loads part of its catalog — WebSearch/WebFetch among
     // them — so a run that inspects its loaded tools concludes it cannot
     // browse and says so to a customer, when one ToolSearch call away it

package/dist/agent/run.d.ts

@@ -10,9 +10,12 @@
  *
  * Two deliberate safety properties:
  *
- * * **Runs are serialized.** 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.
+ * * **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 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.
@@ -59,6 +62,15 @@ export declare const DEFAULT_EXEC_TIMEOUT_MS = 0;
  * tokens and their agent's availability indefinitely.
  */
 export declare const DEFAULT_IDLE_TIMEOUT_MS = 900000;
+/**
+ * Set to `1` in the environment of every agent command this harness starts.
+ *
+ * Lets instructions the agent reads from disk tell a paired run — someone is
+ * waiting in a thread, and the run holds one of this agent's few slots — from
+ * the same file being read anywhere else. ProhostAI's own pull-request protocol
+ * uses it to stop a run from sitting on CI after the PR is open.
+ */
+export declare const PAIRED_RUN_ENV_VAR = "PROHOST_PAIRED_RUN";
 export interface AgentRunOptions {
     /** Shell command that runs the agent, e.g. ``claude -p``. */
     exec: string;
@@ -95,6 +107,17 @@ export interface AgentRunOptions {
      * ``$PROHOST_HOME/workspace`` — see {@link workspacePath} for why not "here".
      */
     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.
+     */
+    concurrency?: number;
+    /**
+     * Git checkouts the agent works on (absolute paths). When set, every
+     * conversation gets a private worktree of each — see `worktrees.ts`.
+     */
+    repos?: string[];
     onLine?: (line: string) => void;
     webSocketCtor?: typeof WebSocket;
     fetchImpl?: typeof fetch;
@@ -186,6 +209,8 @@ interface PreparedMcp {
     mcpWired: boolean;
     /** A fail-closed preparation error. When set, the agent is never spawned. */
     error?: string;
+    /** The account this run was resolved onto; hand it back when the run ends. */
+    accountLabel?: string;
 }
 /**
  * Prepare a fresh Codex MCP override immediately before each invocation.