@prohost/cli 0.13.2 → 0.13.3

package/CHANGELOG.md

@@ -4,6 +4,26 @@ 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

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
@@ -237,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;
         },
@@ -664,7 +743,7 @@ export function readClaudeStream() {
             // 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/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.
@@ -1026,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;
@@ -1116,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';
@@ -1188,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.2";
+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.2";
+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.2';
+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,6 +1,6 @@
 {
   "name": "@prohost/cli",
-  "version": "0.13.2",
+  "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",