@prohost/cli 0.13.1 → 0.13.3

package/CHANGELOG.md

@@ -4,6 +4,36 @@ 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.3
+
+- **Every turn the agent answers in reaches the thread.** When a command the
+  agent ran in the background (or one Claude Code moved to the background at
+  its two-minute timeout) is still running as the agent ends its turn, Claude
+  Code keeps the session alive and wakes it with another turn when the command
+  finishes. The CLI posted only the last turn, so a follow-up that said
+  `[NO_REPLY]`, or just "nothing in my earlier reply changes", replaced the real
+  answer: 3 of the Customer Support Bot's 155 runs lost theirs that way. A turn
+  that ends while a background task is still running is now posted as soon as
+  it ends ("the review is still running; I'll post the result"), each under an
+  idempotency key of its own (`prohost-cli-run-<run>-turn-<n>`). The run's last
+  turn is posted as before, under the run's key. A later `[NO_REPLY]` or a
+  repeat of the previous answer takes back nothing; a last turn that fails
+  (a usage limit) is still reported as the run's failure. Posts go strictly in
+  order: one the server refuses is retried under its own key and holds back
+  the rest (if it never lands, the run fails as a rejected reply does), and
+  nothing more is posted once the run is cancelled. A run that ends in one turn
+  is unchanged.
+
+## 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

@@ -171,6 +171,13 @@ export interface ClaudeStream {
      * that isn't Claude Code's at all.
      */
     drainToolEvents(): ToolEvent[];
+    /**
+     * Answers from turns that ended while a background task was still running —
+     * turns another can follow — in order, since the last call. Taken, not
+     * copied: {@link finish} no longer includes them. Empty for a run that ends
+     * in one turn, which is every run that starts no background task.
+     */
+    takeEarlyAnswers(): string[];
     /**
      * Model, Claude Code version and capacity windows the stream announced —
      * `system/init.{model, claude_code_version}` and the last
@@ -199,6 +206,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,
@@ -230,6 +244,27 @@ export declare function toolArgsPreview(name: string, input: unknown): string |
  * vocabulary belongs to Claude Code and grows without asking us, and a reader
  * that failed on an unknown `type` would turn a Claude Code release into a
  * fleet of broken laptops.
+ *
+ * **One invocation, several turns.** A run usually ends in one `result`
+ * event. It ends in more when a background task — a Bash
+ * `run_in_background`, or a command Claude Code moved to the
+ * background at its two-minute timeout — is still running when the agent ends
+ * its turn: Claude Code keeps the process alive, wakes the session with the
+ * task's notification when it finishes, and runs another turn that ends in a
+ * `result` of its own. The agent writes each of those turns as a message to the
+ * thread ("the review is still running, I'll post the result when it lands";
+ * "nothing in my earlier reply changes"), so each one that answers is a message
+ * of its own. Reading only the last event lost the answer three times in 155
+ * Customer Support Bot runs: twice to a trailing "nothing else changed", once
+ * (2026-10-22, Claude Code 2.1.308) to a trailing `[NO_REPLY]`.
+ *
+ * A turn that ends while a background task is still running can be followed by
+ * another, so it is handed out at once ({@link ClaudeStream.takeEarlyAnswers})
+ * for the harness to post while the run goes on. Whatever answered and was not
+ * taken is the run's reply from {@link ClaudeStream.finish}. Any answer
+ * followed by another turn is early too: it is not the run's last word.
+ * `[NO_REPLY]` and a repeat of the answer before take back nothing that was
+ * already said; a last turn that failed is still the run's outcome.
  */
 export declare function readClaudeStream(): ClaudeStream;
 /**

package/dist/agent/claude.js

@@ -17,6 +17,7 @@
 import { randomBytes } from 'node:crypto';
 import { chmodSync, mkdirSync, renameSync, writeFileSync } from 'node:fs';
 import path from 'node:path';
+import { NO_REPLY_TOKEN, isNoReply } from './contract.js';
 import { prohostHome } from './credentials.js';
 import { MCP_SERVER_NAME } from './mcp.js';
 import { fromClaudeRateLimitInfo } from './runtime_status.js';
@@ -458,13 +459,45 @@ function toolResultText(content) {
  * vocabulary belongs to Claude Code and grows without asking us, and a reader
  * that failed on an unknown `type` would turn a Claude Code release into a
  * fleet of broken laptops.
+ *
+ * **One invocation, several turns.** A run usually ends in one `result`
+ * event. It ends in more when a background task — a Bash
+ * `run_in_background`, or a command Claude Code moved to the
+ * background at its two-minute timeout — is still running when the agent ends
+ * its turn: Claude Code keeps the process alive, wakes the session with the
+ * task's notification when it finishes, and runs another turn that ends in a
+ * `result` of its own. The agent writes each of those turns as a message to the
+ * thread ("the review is still running, I'll post the result when it lands";
+ * "nothing in my earlier reply changes"), so each one that answers is a message
+ * of its own. Reading only the last event lost the answer three times in 155
+ * Customer Support Bot runs: twice to a trailing "nothing else changed", once
+ * (2026-10-22, Claude Code 2.1.308) to a trailing `[NO_REPLY]`.
+ *
+ * A turn that ends while a background task is still running can be followed by
+ * another, so it is handed out at once ({@link ClaudeStream.takeEarlyAnswers})
+ * for the harness to post while the run goes on. Whatever answered and was not
+ * taken is the run's reply from {@link ClaudeStream.finish}. Any answer
+ * followed by another turn is early too: it is not the run's last word.
+ * `[NO_REPLY]` and a repeat of the answer before take back nothing that was
+ * already said; a last turn that failed is still the run's outcome.
  */
 export function readClaudeStream() {
     let buffer = '';
     let session;
     let lastActivity;
     let lastText;
+    /** The last `result` event: what decides a run in which no turn answered. */
     let result;
+    /** Answered turns not yet handed out, in order, and whether another turn can follow each. */
+    const answers = [];
+    /** Whether any turn answered, handed out or not. */
+    let answered = false;
+    /** The last answer, so a turn that only repeats it is not said twice. */
+    let lastAnswer;
+    /** Every turn's refused tools, for the run's report. */
+    const denials = new Set();
+    /** Background tasks running as of the last `background_tasks_changed`. */
+    let backgroundTasks = 0;
     /** The last `assistant` event that was an API error rather than an answer. */
     let apiError;
     /** When a `rate_limit_event` said the limit is hit: its reset, epoch seconds. */
@@ -563,8 +596,26 @@ export function readClaudeStream() {
         // from whichever arrives first — they all name the same session.
         if (!session)
             session = text(event.session_id);
+        if (event.type === 'system' && event.subtype === 'background_tasks_changed' && Array.isArray(event.tasks)) {
+            backgroundTasks = event.tasks.length;
+        }
         if (event.type === 'result') {
+            // One per turn: see "One invocation, several turns" above.
             result = event;
+            const turn = outputFromEnvelope(event);
+            for (const name of turn.denials)
+                denials.add(name);
+            // Another turn ended, so no answer before it is the run's last word.
+            for (const answer of answers)
+                answer.early = true;
+            if (turn.ok && !isNoReply(turn.text)) {
+                // Kept as written, so a one-turn run's reply is byte for byte what it was.
+                const said = turn.text.trim();
+                if (said !== lastAnswer)
+                    answers.push({ text: turn.text, early: backgroundTasks > 0 });
+                lastAnswer = said;
+                answered = true;
+            }
             return;
         }
         if (event.type === 'user') {
@@ -595,6 +646,24 @@ export function readClaudeStream() {
         else if (written)
             lastActivity = written.replace(/\s+/g, ' ').trim().slice(0, MAX_ACTIVITY_CHARS);
     };
+    /** The run's outcome from its turns; only meaningful once a `result` arrived. */
+    const outcome = (last) => {
+        const final = outputFromEnvelope(last);
+        // A last turn that failed is the run's outcome even after an answer — a
+        // usage limit must still say when to try again. Every answer before it was
+        // handed out early the moment this turn ended.
+        if (!answered || !final.ok)
+            return final;
+        const sessionId = final.sessionId ?? session;
+        // Everything still unsaid, or — when all of it was handed out early — the
+        // token that says this turn adds nothing.
+        const text = answers.length === 1
+            ? answers[0].text
+            : answers.length > 0
+                ? answers.map((answer) => answer.text.trim()).join('\n\n')
+                : NO_REPLY_TOKEN;
+        return { ok: true, text, sessionId, denials: [...denials] };
+    };
     /** A trailing event with no newline after it is still an event. */
     const flushTail = () => {
         const tail = buffer.trim();
@@ -628,6 +697,16 @@ export function readClaudeStream() {
             toolEvents = [];
             return drained;
         },
+        takeEarlyAnswers: () => {
+            // Up to the last turn another can follow: an answer before it is just as
+            // surely not the run's last word, and order is the thread's order.
+            let through = -1;
+            answers.forEach((answer, index) => {
+                if (answer.early)
+                    through = index;
+            });
+            return answers.splice(0, through + 1).map((answer) => answer.text);
+        },
         observed: () => ({ ...observed }),
         salvage: () => {
             const trimmed = lastText?.trim();
@@ -638,9 +717,9 @@ export function readClaudeStream() {
         error: () => {
             flushTail();
             if (result) {
-                const outcome = outputFromEnvelope(result);
-                if (!outcome.ok)
-                    return outcome.error;
+                const turned = outcome(result);
+                if (!turned.ok)
+                    return turned.error;
             }
             return apiError?.text;
         },
@@ -655,12 +734,16 @@ 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.
             flushTail();
             if (result)
-                return outputFromEnvelope(result);
+                return outcome(result);
             // No `result` event: either the command isn't emitting the stream we
             // asked for, or it died before finishing. Either way the whole-output
             // parser gives the better error message, and it still understands a

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

@@ -638,7 +638,13 @@ toolEvents,
 /** Harness-set variables for this run's command, over the brain's own. */
 runEnv, 
 /** A venue run's own empty working directory; marks the turn as a venue session. */
-venueCwd) {
+venueCwd, 
+/**
+ * Where an answer goes the moment its turn ends while a background task is
+ * still running (see `readClaudeStream`). Absent, such answers stay in the
+ * turn's reply.
+ */
+onEarlyAnswer) {
     // `--timeout` is a ceiling on the run, not on each attempt: the retry below
     // must not let one run take twice what the operator allowed. Both attempts
     // share one deadline, which costs the retry nothing in practice — a rejected
@@ -699,6 +705,9 @@ venueCwd) {
         // The heartbeat line above is unchanged for older servers; the events are
         // the richer channel a newer server renders beneath it.
         toolEvents?.push(reader.drainToolEvents());
+        if (onEarlyAnswer)
+            for (const answer of reader.takeEarlyAnswers())
+                onEarlyAnswer(answer);
     };
     /**
      * Undo an eagerly recorded Claude session after an ordinary failed turn.
@@ -746,8 +755,16 @@ venueCwd) {
                     : undefined,
         });
         // Whatever the stream announced — model, version, capacity — is true of
-        // this machine whether or not the turn succeeded.
-        return reader ? running.finally(() => runtime.observe(reader.observed())) : running;
+        // this machine whether or not the turn succeeded. Its last event may have
+        // come without a newline: ended here, so a turn it closed still hands out
+        // the answers before it.
+        return reader
+            ? running.finally(() => {
+                reader.push('\n');
+                observe(reader);
+                runtime.observe(reader.observed());
+            })
+            : running;
     };
     // Wall clock for the whole turn, retry included — what the operator waited,
     // rather than what the last attempt took.
@@ -759,14 +776,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
@@ -1021,13 +1043,63 @@ mcp) {
     // workspace, and on this machine's log: never the agent's words about the
     // connected team's thread (see `VENUE_PROGRESS`).
     const turnControl = venue ? { ...control, report: () => control.report(VENUE_PROGRESS) } : control;
+    // A turn the agent ended while a background task was still running is a
+    // message of its own, posted as it lands: the agent wrote it for the thread
+    // ("the review is still running, I'll post the result"), and another turn
+    // may follow it by minutes. Strictly in order, each under a key of its own
+    // that every retry reuses, so an answer the server took but whose response
+    // was lost can't land twice. One that can't be posted holds back everything
+    // after it — the run's last reply included — and nothing is sent once the
+    // run has been stopped.
+    const early = [];
+    let earlyCount = 0;
+    let earlyPosted = 0;
+    let earlyPosts = Promise.resolve();
+    const earlyPath = run.reply_path;
+    const earlyBodyKey = run.reply_body_key;
+    const stoppedNow = () => control.signal.aborted || control.disposition() !== undefined;
+    const postEarly = async () => {
+        if (!earlyPath || !earlyBodyKey)
+            return;
+        while (early.length > 0) {
+            // The tool calls that led here are on the timeline before the answer.
+            await toolEvents.flush();
+            if (stoppedNow()) {
+                early.length = 0;
+                return;
+            }
+            const { answer, key } = early[0];
+            const posted = await postReplyWithReplay(api, () => stoppedNow()
+                ? Promise.resolve({ ok: false, status: -1, error: 'the run was stopped' })
+                : postReply(api, earlyPath, earlyBodyKey, answer, key, run.reply_body_extra), label, log, sleep);
+            if (!posted.ok) {
+                if (!stoppedNow())
+                    log(`${timestamp()} ! ${label} could not post an answer yet (${describeFailure(posted)})`);
+                return;
+            }
+            early.shift();
+            earlyPosted += 1;
+            log(`${timestamp()} ✓ ${label} posted an answer; a background task is still running`);
+        }
+    };
+    const onEarlyAnswer = !options.dryRun && earlyPath && earlyBodyKey
+        ? (answer) => {
+            earlyCount += 1;
+            early.push({ answer, key: `${run.run_id}-turn-${earlyCount}` });
+            earlyPosts = earlyPosts.then(postEarly);
+        }
+        : undefined;
     let result;
     try {
-        result = await runTurn(run, prompt, options, runtime, mcp, turnControl, log, toolEvents, runEnv, venueDir?.dir);
+        result = await runTurn(run, prompt, options, runtime, mcp, turnControl, log, toolEvents, runEnv, venueDir?.dir, onEarlyAnswer);
     }
     finally {
         venueDir?.remove();
+        await earlyPosts;
     }
+    // One more try for an answer that couldn't be posted while the run worked.
+    if (early.length > 0)
+        await postEarly();
     // A venue session is never continued: the next turn there starts fresh from
     // the thread the server sends, so nothing of this one is remembered.
     const sessionId = venue ? undefined : result.ok ? result.sessionId : undefined;
@@ -1089,7 +1161,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}` : ''}`);
@@ -1107,14 +1183,29 @@ mcp) {
         log(`    [dry-run] nothing was sent and the run was left open`);
         return 'skipped';
     }
+    // An earlier answer still not in the thread: posting the last one would put
+    // it out of order, and posting the earlier one under any other key could
+    // post it twice. The run fails the way a rejected reply does.
+    if (early.length > 0) {
+        log(`${timestamp()} ✗ ${label} ${early.length} answer(s) could not be posted (${seconds}s)`);
+        if (result.sessionRecorded)
+            runtime.sessions.forget(sessionKeyFor(run));
+        const reported = await completeWithRetry(api, run.completion_path, { ok: false, error: 'posting the reply failed: an earlier answer could not be posted' }, log, sleep, runtime.model());
+        return reported.ok ? 'failed' : 'unreported';
+    }
     // The agent decided not to reply — the usual answer when it was woken as a
     // bystander (`reply_expected: false`). A finished run, not a failure: nothing
     // is posted, and the completion says so, so the server records a deliberate
     // silence and clears the thinking indicator as one. Checked on every run, not
     // only bystander ones: the literal token must never reach a thread.
     if (isNoReply(reply)) {
-        log(`${timestamp()} ✓ ${label} chose not to reply (${seconds}s)`);
-        const completed = await completeWithRetry(api, run.completion_path, { ok: true, silent: true }, log, sleep, runtime.model());
+        // Silence only when nothing was said: a last turn that adds nothing to
+        // answers already in the thread is a run that replied.
+        const silent = earlyPosted === 0;
+        log(silent
+            ? `${timestamp()} ✓ ${label} chose not to reply (${seconds}s)`
+            : `${timestamp()} ✓ ${label} replied in ${seconds}s (${earlyPosted} posted while it worked)`);
+        const completed = await completeWithRetry(api, run.completion_path, silent ? { ok: true, silent: true } : { ok: true }, log, sleep, runtime.model());
         if (!completed.ok) {
             log(`    ! could not mark the run complete (${describeFailure(completed)})`);
             return 'unreported';
@@ -1179,7 +1270,8 @@ mcp) {
         log(`${timestamp()} ! ${label} replied, but marking it complete failed (${describeFailure(completed)})`);
         return 'unreported';
     }
-    log(`${timestamp()} ✓ ${label} replied in ${seconds}s (${reply.length} chars)`);
+    const alsoPosted = earlyPosted > 0 ? `, ${earlyPosted} more posted while it worked` : '';
+    log(`${timestamp()} ✓ ${label} replied in ${seconds}s (${reply.length} chars${alsoPosted})`);
     return 'succeeded';
 }
 /**

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.3";
 /** 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.3";

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.3';
 /** 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.3",
   "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"
   },