@prohost/cli 0.13.1 → 0.13.2

package/CHANGELOG.md

@@ -4,6 +4,16 @@ 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.13.2
+
+- **A run stopped by the Claude usage limit tells ProhostAI when the limit
+  lifts.** The completion now carries `failure_kind: "usage_limit"` and, when
+  Claude Code's stream said, `retry_after` (the reset time). When the limit
+  lifts within a few hours, ProhostAI runs the same request again shortly after,
+  unless someone asks again first; either way it alerts the person who asked
+  instead of leaving a note nobody is notified of. The thread keeps its session, as before, so the retry continues it. A
+  server that predates the fields ignores them.
+
 ## 0.13.1
 
 - **A connected team's thread is never answered after the run's grant ended.**

package/README.md

@@ -1,6 +1,6 @@
 # `@prohost/cli`
 
-The [ProhostAI](https://www.prohost.ai) command-line tool. Three things it does:
+The [ProhostAI](https://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
@@ -233,9 +233,12 @@ and gets a reply that has forgotten asking. The CLI reads the `session_id` out
 of Claude Code's JSON output, records it per conversation in
 `~/.prohost/sessions.json`, and `--resume`s it next time. Sessions don't live
 forever; when one is gone the run is retried once from scratch rather than
-failing. A run stopped by your Claude usage limit is not retried: it fails
+failing. A run stopped by your Claude usage limit is not retried here: it fails
 with Claude Code's own message, which says when the limit resets, and the
-conversation keeps its session for the next run.
+conversation keeps its session for the next run. The failure also tells
+ProhostAI when the limit lifts: if that is within a few hours, ProhostAI asks
+the agent again shortly after (unless someone asks again first), and either way
+it alerts whoever asked.
 
 **It lets the agent actually do things.** Runs are invoked with
 `--dangerously-skip-permissions`, so tool calls execute without stopping to ask.

package/dist/agent/api.d.ts

@@ -129,6 +129,20 @@ export type HeartbeatOutcome =
  * work send none either.
  */
 export declare function heartbeatRun(options: ApiOptions, path: string, progress?: string): Promise<HeartbeatOutcome>;
+/**
+ * A run's terminal state as the completion reports it. A failure the brain's
+ * usage limit caused says so, with when the limit lifts if the brain said.
+ */
+export type CompletionOutcome = {
+    ok: true;
+    silent?: boolean;
+} | {
+    ok: false;
+    error: string;
+    usageLimit?: {
+        retryAfter?: string;
+    };
+};
 /**
  * Report a run's terminal state. Called for every run — including one whose
  * command crashed — so the server never waits on a run this harness abandoned.
@@ -140,13 +154,7 @@ export declare function heartbeatRun(options: ApiOptions, path: string, progress
  * ``model`` is the model id the run used, when the harness knows it. Omitted
  * otherwise, so a plain ``--exec`` command's completion body is unchanged.
  */
-export declare function completeRun(options: ApiOptions, path: string, outcome: {
-    ok: true;
-    silent?: boolean;
-} | {
-    ok: false;
-    error: string;
-}, model?: string): Promise<ApiResult>;
+export declare function completeRun(options: ApiOptions, path: string, outcome: CompletionOutcome, model?: string): Promise<ApiResult>;
 /**
  * Report a batch of tool events for a run in flight.
  *

package/dist/agent/api.js

@@ -10,7 +10,7 @@
  * `completion.path`), which is why these take a path rather than building one.
  */
 import { USER_AGENT } from '../version.js';
-import { MAX_ERROR_CHARS, MAX_MODEL_CHARS, MAX_PROGRESS_CHARS, MAX_TOOL_EVENTS_PER_BATCH, RUN_OUTCOME_SILENT, RUN_STATUS_FAILED, RUN_STATUS_SUCCEEDED, } from './contract.js';
+import { MAX_ERROR_CHARS, MAX_MODEL_CHARS, MAX_PROGRESS_CHARS, MAX_TOOL_EVENTS_PER_BATCH, RUN_FAILURE_USAGE_LIMIT, RUN_OUTCOME_SILENT, RUN_STATUS_FAILED, RUN_STATUS_SUCCEEDED, } from './contract.js';
 /** Deadline for the cheap calls — a heartbeat answers in milliseconds. */
 export const DEFAULT_TIMEOUT_MS = 30_000;
 /**
@@ -184,6 +184,11 @@ export async function completeRun(options, path, outcome, model) {
     const body = outcome.ok
         ? { status: RUN_STATUS_SUCCEEDED, ...(outcome.silent ? { outcome: RUN_OUTCOME_SILENT } : {}) }
         : { status: RUN_STATUS_FAILED, error: outcome.error.slice(0, MAX_ERROR_CHARS) };
+    if (!outcome.ok && outcome.usageLimit) {
+        body.failure_kind = RUN_FAILURE_USAGE_LIMIT;
+        if (outcome.usageLimit.retryAfter)
+            body.retry_after = outcome.usageLimit.retryAfter;
+    }
     if (model)
         body.model = model.slice(0, MAX_MODEL_CHARS);
     const result = await postJson(options, path, body, undefined, false, SEND_TIMEOUT_MS);

package/dist/agent/claude.d.ts

@@ -199,6 +199,13 @@ export interface ClaudeStream {
      * help until the limit resets, so a caller must not retry it.
      */
     usageLimit(): string | undefined;
+    /**
+     * When the usage limit that stopped the turn lifts, in epoch seconds: the
+     * `resetsAt` of the rejecting `rate_limit_event`. `undefined` when no such
+     * event arrived, even if {@link usageLimit} recognised the limit from Claude
+     * Code's message alone — that message's "resets 11pm" is for people.
+     */
+    usageLimitResetsAt(): number | undefined;
     /**
      * The turn's outcome. ``stdout`` is the complete captured output, used only
      * when the stream held no `result` event — a crashed binary, a login prompt,

package/dist/agent/claude.js

@@ -655,6 +655,10 @@ export function readClaudeStream() {
                 ? 'usage limit reached'
                 : `usage limit reached · resets ${new Date(resetsAt * 1000).toISOString()}`;
         },
+        usageLimitResetsAt: () => {
+            flushTail();
+            return limitRejected?.resetsAt;
+        },
         finish(stdout) {
             // A binary that exits without flushing a final `\n` must not lose its
             // result.

package/dist/agent/contract.d.ts

@@ -50,6 +50,13 @@ export declare const RUN_OUTCOME_SILENT = "silent";
 export declare const NO_REPLY_TOKEN = "[NO_REPLY]";
 /** Whether the agent's output is the no-reply token and nothing else. */
 export declare function isNoReply(output: string): boolean;
+/**
+ * Completion `failure_kind` for a run the brain's subscription usage limit
+ * stopped. Sent with `status: failed`, plus `retry_after` when the brain said
+ * when the limit lifts, so the server can retry the work then instead of
+ * leaving the question unanswered. A server that predates the field ignores it.
+ */
+export declare const RUN_FAILURE_USAGE_LIMIT = "usage_limit";
 /** Server-side cap on the `error` field of a completion (`MAX_ERROR_CHARS`). */
 export declare const MAX_ERROR_CHARS = 1000;
 /** Server-side cap on the `model` field of a completion (`MAX_MODEL_CHARS`). */

package/dist/agent/contract.js

@@ -52,6 +52,13 @@ export const NO_REPLY_TOKEN = '[NO_REPLY]';
 export function isNoReply(output) {
     return output.trim().toUpperCase() === NO_REPLY_TOKEN;
 }
+/**
+ * Completion `failure_kind` for a run the brain's subscription usage limit
+ * stopped. Sent with `status: failed`, plus `retry_after` when the brain said
+ * when the limit lifts, so the server can retry the work then instead of
+ * leaving the question unanswered. A server that predates the field ignores it.
+ */
+export const RUN_FAILURE_USAGE_LIMIT = 'usage_limit';
 /** Server-side cap on the `error` field of a completion (`MAX_ERROR_CHARS`). */
 export const MAX_ERROR_CHARS = 1000;
 /** Server-side cap on the `model` field of a completion (`MAX_MODEL_CHARS`). */

package/dist/agent/run.js

@@ -759,14 +759,19 @@ venueCwd) {
      * A turn the Claude subscription's usage limit stopped, worded for the
      * thread: whose limit (this machine's login) and, in Claude Code's own
      * words, when it resets. The only fix is waiting, so the reason says that
-     * rather than "exited 1".
+     * rather than "exited 1" — and the completion says when, so the server can
+     * run the work again then.
      */
-    const usageLimitFailure = (said, stderr = '') => ({
-        ok: false,
-        reason: `Claude usage limit reached on ${options.machine ?? os.hostname()}`,
-        detail: [said, stderr.includes(said) ? '' : stderr].filter((part) => part.length > 0).join('\n'),
-        durationMs: elapsed(),
-    });
+    const usageLimitFailure = (said, stderr = '') => {
+        const resetsAt = stream?.usageLimitResetsAt();
+        return {
+            ok: false,
+            reason: `Claude usage limit reached on ${options.machine ?? os.hostname()}`,
+            detail: [said, stderr.includes(said) ? '' : stderr].filter((part) => part.length > 0).join('\n'),
+            durationMs: elapsed(),
+            usageLimit: resetsAt === undefined ? {} : { retryAfter: new Date(resetsAt * 1000).toISOString() },
+        };
+    };
     const failure = (result) => {
         // A killed run has no reply, but it usually has most of one. Reporting the
         // tail of what the agent was writing turns "no output for 15 minutes" into
@@ -1089,7 +1094,11 @@ mcp) {
             log(`    [dry-run] would report the run as failed`);
             return 'skipped';
         }
-        const completed = await completeWithRetry(api, run.completion_path, { ok: false, error: detail ? `${reason}: ${detail}` : reason }, log, sleep, runtime.model());
+        const completed = await completeWithRetry(api, run.completion_path, {
+            ok: false,
+            error: detail ? `${reason}: ${detail}` : reason,
+            ...(result.usageLimit ? { usageLimit: result.usageLimit } : {}),
+        }, log, sleep, runtime.model());
         if (!completed.ok) {
             log(`    ! could not report failure (${describeFailure(completed)})` +
                 `${completed.status !== 0 && completed.error ? ` ${completed.error}` : ''}`);

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

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.13.1';
+export const CLI_VERSION = '0.13.2';
 /** Sent on every HTTP request the CLI makes back into ProhostAI. */
 export const USER_AGENT = `prohost-cli/${CLI_VERSION}`;

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@prohost/cli",
-  "version": "0.13.1",
+  "version": "0.13.2",
   "description": "Run your own AI agent as a ProhostAI teammate, and stream your account's webhooks to your laptop.",
   "type": "module",
   "license": "MIT",
-  "homepage": "https://www.prohost.ai",
+  "homepage": "https://prohost.ai",
   "bugs": {
     "email": "support@prohost.ai"
   },