@prohost/cli 0.16.3 → 0.16.4

package/CHANGELOG.md

@@ -6,6 +6,16 @@ builds via `prepack`, runs the suite, publishes, and tags `cli-v<version>`.
 
 ## Unreleased
 
+## 0.16.4
+
+- **`409 conversation_busy` on claim** (ProhostAI serializes a conversation's turns): the run
+  stays queued instead of being skipped. Its slot goes to other work, and it is claimed again
+  when ProhostAI resends its frame (the earlier turn ended) or after a backoff of 30 s doubling to
+  at most 2 min — never in a tight loop. While it waits it does not hold its conversation's place
+  in the queue, so the earlier turn it waits for starts even if its frame came second; a resend
+  that arrives while its claim is still in flight is kept. Any other `409` is still another
+  computer's run. Works with servers that never send it.
+
 ## 0.16.3
 
 - **A dedicated service records its terminal switch in its home's code-host settings** as it

package/README.md

@@ -97,7 +97,10 @@ program (no terminal) relies on `--expect-account`.
 2. The run waits its turn (below). When a slot is free and its AI login has
    room, the computer **claims** it (`POST /v1/computers/{id}/runs/{run_id}/claim`).
    Exactly one computer ever gets a claim; a `409` means another computer took
-   it, and it is skipped.
+   it, and it is skipped. A `409 conversation_busy` means an earlier turn of the
+   same employee's conversation is still open: the run stays queued (its slot
+   goes to other work) and is claimed when ProhostAI sends its frame again, or
+   after a backoff of 30 s doubling to at most 2 min.
 3. The claim returns the run, a short-lived **run token** and the employee's
    **skills**. The skills are written into the employee's workspace —
    `.claude/skills/<key>/…` for Claude Code; `.codex/skills/<key>/…` plus a

package/dist/host/api.d.ts

@@ -61,6 +61,13 @@ export type ClaimResult = {
  | {
     kind: 'elsewhere';
 }
+/**
+ * `409 conversation_busy`: an earlier turn of the same employee's conversation is still open.
+ * The run stays queued here; the server sends its frame again when that turn ends.
+ */
+ | {
+    kind: 'busy';
+}
 /** Gone server-side (404 / 410): nothing to run. */
  | {
     kind: 'gone';
@@ -78,5 +85,4 @@ export type ClaimResult = {
     status: number;
     error?: string;
 };
-/** Claim a run for this computer. Exactly one computer ever gets a 200. */
 export declare function claimRun(options: ComputerApiOptions, computerId: string, runId: string): Promise<ClaimResult>;

package/dist/host/api.js

@@ -94,6 +94,20 @@ function parseSkills(value) {
     });
 }
 /** Claim a run for this computer. Exactly one computer ever gets a 200. */
+/** A refusal's code: `{detail: {error}}`, `{detail: "<code>"}` or `{error}`, matched exactly by the caller. */
+function errorCode(body) {
+    if (!body || typeof body !== 'object' || Array.isArray(body))
+        return undefined;
+    const top = body;
+    const detail = top.detail;
+    if (typeof detail === 'string')
+        return detail;
+    if (detail && typeof detail === 'object' && !Array.isArray(detail)) {
+        const code = detail.error;
+        return typeof code === 'string' ? code : undefined;
+    }
+    return typeof top.error === 'string' ? top.error : undefined;
+}
 export async function claimRun(options, computerId, runId) {
     const response = await callJson(options, claimPath(computerId, runId), {});
     if (response.status === 200 || response.status === 201) {
@@ -112,7 +126,7 @@ export async function claimRun(options, computerId, runId) {
         };
     }
     if (response.status === 409)
-        return { kind: 'elsewhere' };
+        return errorCode(response.body) === 'conversation_busy' ? { kind: 'busy' } : { kind: 'elsewhere' };
     if (response.status === 404 || response.status === 410)
         return { kind: 'gone', status: response.status };
     if (response.status === 0 || response.status === 429 || response.status >= 500) {

package/dist/host/scheduler.d.ts

@@ -67,8 +67,12 @@ export declare class HostScheduler<T extends QueuedRun = QueuedRun> {
      * run keeps its place and does not block the others.
      *
      * Taking it marks it running; call {@link finish} when it is done.
+     *
+     * A `parked` run (one the server said must wait for another turn of its conversation) neither
+     * starts nor holds its lane: the next run of the lane — possibly the very turn it waits for —
+     * is the lane's candidate instead. Runs of one lane still never run side by side.
      */
-    take(config: SchedulerConfig, eligible?: (run: T) => boolean): T | undefined;
+    take(config: SchedulerConfig, eligible?: (run: T) => boolean, parked?: (run: T) => boolean): T | undefined;
     /** A started run is done. */
     finish(runId: string): void;
     /** A taken run could not start after all: back in the queue, in its old place. */

package/dist/host/scheduler.js

@@ -66,14 +66,20 @@ export class HostScheduler {
      * run keeps its place and does not block the others.
      *
      * Taking it marks it running; call {@link finish} when it is done.
+     *
+     * A `parked` run (one the server said must wait for another turn of its conversation) neither
+     * starts nor holds its lane: the next run of the lane — possibly the very turn it waits for —
+     * is the lane's candidate instead. Runs of one lane still never run side by side.
      */
-    take(config, eligible = () => true) {
+    take(config, eligible = () => true, parked = () => false) {
         if (config.held)
             return undefined;
         const busyLanes = new Set([...this.running.values()].map((r) => r.lane));
         const seenLanes = new Set();
         const candidates = [];
         for (const run of this.queue) {
+            if (parked(run))
+                continue;
             // Only the oldest run of each lane is a candidate: later ones wait their turn.
             if (seenLanes.has(run.lane))
                 continue;

package/dist/host/service.d.ts

@@ -112,6 +112,11 @@ export interface HostServiceResult {
     runsStarted: number;
     runsSkipped: number;
 }
+/**
+ * How long a run whose conversation is busy waits before it is claimed again, unless the server
+ * sends its frame first (it does when the earlier turn ends): 30 s, doubling, at most 2 min.
+ */
+export declare function busyBackoffMs(waits: number): number;
 /** The CLI's own entry file: when it changes on disk, an update was installed. */
 export declare function entrypointStamp(entry?: string): () => boolean;
 export declare function runHostService(options: HostServiceOptions): Promise<HostServiceResult>;

package/dist/host/service.js

@@ -82,6 +82,13 @@ const ACK_RETRY = 503;
 const RECONNECT_MAX_DELAY_MS = 30_000;
 /** An employee id names a folder: nothing else gets in. */
 const SAFE_ID = /^[A-Za-z0-9-]{1,64}$/;
+/**
+ * How long a run whose conversation is busy waits before it is claimed again, unless the server
+ * sends its frame first (it does when the earlier turn ends): 30 s, doubling, at most 2 min.
+ */
+export function busyBackoffMs(waits) {
+    return Math.min(30_000 * 2 ** waits, 120_000);
+}
 function timestamp() {
     return new Date().toISOString().slice(11, 19);
 }
@@ -260,6 +267,8 @@ async function serveHost(options) {
     }
     /** Runs being claimed right now, and the login each will run on. */
     const claiming = new Map();
+    /** Runs the server resent while their claim was in flight: a `conversation_busy` answer to that claim is already stale. */
+    const resentWhileClaiming = new Set();
     function runsOnLogin(accountKey) {
         let n = 0;
         for (const run of active.values())
@@ -489,7 +498,9 @@ async function serveHost(options) {
                     return false;
                 const pick = pool.pick(runtimeOf(run.agentId, run.data), conversationOf(run.lane), config.share_logins[runtimeOf(run.agentId, run.data)], runsOnLogin);
                 return pick.kind === 'use' || pick.kind === 'move';
-            });
+            }, 
+            // Waiting on an earlier turn of its conversation: that turn may be queued behind it.
+            (run) => Boolean(run.busyWaits) && run.notBefore > now());
             if (!next)
                 break;
             background.push(startRun(next));
@@ -516,6 +527,19 @@ async function serveHost(options) {
         const claim = await claimRun(computerApi, computer.computer_id, queued.runId).finally(() => {
             claiming.delete(queued.runId);
         });
+        const resent = resentWhileClaiming.delete(queued.runId);
+        if (claim.kind === 'busy' && !draining) {
+            // Serialized server-side: an earlier turn of this conversation is still open. Not dropped,
+            // not failed: queued again (its slot is free for other work) until the server resends its
+            // frame, or its backoff ends. A resend that came while this claim was in flight already
+            // said the earlier turn ended: claimed again at once.
+            const waits = queued.busyWaits ?? 0;
+            scheduler.requeue({ ...queued, busyWaits: waits + 1, notBefore: resent ? 0 : now() + busyBackoffMs(waits) });
+            if (waits === 0)
+                log(`${timestamp()} ◦ run ${queued.runId.slice(0, 12)} waits — an earlier turn of its conversation is still open`);
+            pump();
+            return;
+        }
         if (claim.kind !== 'claimed') {
             if (claim.kind === 'retry' && queued.claimAttempts + 1 < MAX_CLAIM_ATTEMPTS && !draining) {
                 scheduler.requeue({ ...queued, claimAttempts: queued.claimAttempts + 1, notBefore: now() + 2_000 * 2 ** queued.claimAttempts });
@@ -525,7 +549,7 @@ async function serveHost(options) {
                 result.runsSkipped += 1;
                 const why = claim.kind === 'elsewhere'
                     ? 'another computer has it'
-                    : claim.kind === 'gone'
+                    : claim.kind === 'gone' || claim.kind === 'busy'
                         ? 'it is no longer waiting'
                         : `the claim was refused (${claim.status}${'error' in claim && claim.error ? `: ${claim.error}` : ''})`;
                 log(`${timestamp()} ◦ run ${queued.runId.slice(0, 12)} skipped — ${why}`);
@@ -1016,8 +1040,19 @@ async function serveHost(options) {
             return [ACK_IGNORED];
         if (typeof data.computer_id === 'string' && data.computer_id !== computer.computer_id)
             return [ACK_IGNORED];
-        if (scheduler.has(runId) || active.has(runId) || ledger.get(runId))
+        if (scheduler.has(runId) || active.has(runId) || ledger.get(runId)) {
+            // The server's resend of a run waiting on its busy conversation: the earlier turn ended, so
+            // it is claimed now rather than at the end of its backoff.
+            const waiting = scheduler.queued().find((run) => run.runId === runId);
+            if (waiting?.busyWaits && waiting.notBefore > now()) {
+                waiting.notBefore = 0;
+                pump();
+            }
+            else if (claiming.has(runId)) {
+                resentWhileClaiming.add(runId);
+            }
             return [ACK_ACCEPTED];
+        }
         if (draining)
             return [ACK_RETRY, 'draining'];
         if (!config.ai_employees_enabled)

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.16.3";
+export declare const CLI_VERSION = "0.16.4";
 /** Sent on every HTTP request the CLI makes back into ProhostAI. */
-export declare const USER_AGENT = "prohost-cli/0.16.3";
+export declare const USER_AGENT = "prohost-cli/0.16.4";

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.16.3';
+export const CLI_VERSION = '0.16.4';
 /** 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.16.3",
+  "version": "0.16.4",
   "description": "Run your own AI agent as a ProhostAI teammate, and stream your account's webhooks to your laptop.",
   "type": "module",
   "license": "MIT",