@bridge4dev/runner 0.33.0 → 0.34.0

package/dist/adapters/claude.js

@@ -1800,11 +1800,39 @@ class ClaudeSession {
                         break;
                     }
                     case 'assistant': {
+                        // Ticket #186. A subagent's own prose is NOT this session's answer.
+                        //
+                        // The SDK's own note — «by default, only tool_use/tool_result blocks
+                        // from subagents are emitted» — covers SYNCHRONOUS Task subagents. A
+                        // BACKGROUND agent's closing report is delivered regardless, as an
+                        // ordinary top-level assistant message that merely carries
+                        // `parent_tool_use_id` (probe against 0.3.226, 2026-08-08):
+                        //
+                        //   {type:'assistant', parent_tool_use_id:'toolu_…',
+                        //    subagent_type:'general-purpose', task_description:'…',
+                        //    message:{content:[{type:'text', text:'…'}]}}
+                        //
+                        // Session 50eb77b9 put two of those — 46 655 and 16 368 characters of
+                        // internal survey — into the feed four seconds after an
+                        // AskUserQuestion card, while the main agent was blocked on the very
+                        // tool call that card belongs to and could not have written a word.
+                        //
+                        // Only text and thinking are dropped. `tool_use` stays, and so does
+                        // the paired `tool_result` in `case 'user'` below: the dashboard
+                        // resolves a result by toolUseId and falls back to the last unfinished
+                        // row, so filtering one arm without the other sticks a subagent's
+                        // result onto a stranger's row (that fallback has misfired before).
+                        //
+                        // The test is «is a string», not «is not null»: an emitter that
+                        // omits the field must read as the main loop. Treating a missing
+                        // field as a subagent would blank the transcript of every session on
+                        // that CLI, which is a far worse failure than one leaked report.
+                        const fromSubagent = typeof msg.parent_tool_use_id === 'string';
                         for (const block of msg.message.content) {
-                            if (block.type === 'text' && block.text.trim()) {
+                            if (block.type === 'text' && !fromSubagent && block.text.trim()) {
                                 this.emit({ type: 'message', role: 'assistant', text: truncate(block.text) });
                             }
-                            else if (block.type === 'thinking' && block.thinking.trim()) {
+                            else if (block.type === 'thinking' && !fromSubagent && block.thinking.trim()) {
                                 this.emit({ type: 'thinking', text: truncate(block.thinking, 8_000) });
                             }
                             else if (block.type === 'tool_use') {

package/dist/supervisor.d.ts

@@ -246,6 +246,30 @@ export declare class Supervisor {
      * rewound (ticket #126).
      */
     private park;
+    /**
+     * The agent is producing output while this runner still says a human is
+     * expected — put `lastReported` back to RUNNING (ticket #185).
+     *
+     * This is not cosmetics on top of the API's own repair. While `lastReported`
+     * lies, two things break here and only here:
+     *
+     *  - `isParkable()` reads WAITING_INPUT with no open question as «idle», so
+     *    `ensureCapacity` may KILL a live agent process to hand its slot to
+     *    another session;
+     *  - `isBillable()` counts only RUNNING/STARTING, so `agentActiveMs` stops
+     *    growing and the time budget never fires for work that is really happening.
+     *
+     * It happens for real: a background subagent's report wakes a new turn inside
+     * the agent process (SDK 0.3.226 emits a second `system:init` and a `result`
+     * carrying `origin: {kind:'task-notification'}`), and nothing here reports a
+     * turn the runner did not start. Compaction does the same, and so does a
+     * question this runner withdraws by itself.
+     *
+     * An open question is the one thing that must survive: there, WAITING_INPUT
+     * means a tool call is parked on a person, and the agent narrating around its
+     * own question must not take the card off the screen.
+     */
+    private noteAgentIsWorking;
     private forwardEvent;
     /**
      * The dashboard's answer to a parked question (session 12).

package/dist/supervisor.js

@@ -22,6 +22,12 @@ import { availableModes, MODE_REFUSED_TEXT } from './adapters/types.js';
 /** Refusals shared by every checkpoint command (ticket #126). */
 const CHECKPOINTS_OFF = 'Restore points are switched off on this server ([checkpoints] enabled = false)';
 const AGENT_BUSY = 'The agent is still working — stop the turn first';
+/**
+ * Adapter events that exist only because the agent is producing output right
+ * now (ticket #185). `message` is deliberately absent — a user echo carries the
+ * same type and proves nothing about the agent — and is handled at the call site.
+ */
+const AGENT_OUTPUT_EVENTS = new Set(['tool', 'thinking']);
 /**
  * The project's git policy, lifted out of a session descriptor (session 18).
  *
@@ -1046,8 +1052,47 @@ export class Supervisor {
         }
         running.session.stop('session_parked');
     }
+    /**
+     * The agent is producing output while this runner still says a human is
+     * expected — put `lastReported` back to RUNNING (ticket #185).
+     *
+     * This is not cosmetics on top of the API's own repair. While `lastReported`
+     * lies, two things break here and only here:
+     *
+     *  - `isParkable()` reads WAITING_INPUT with no open question as «idle», so
+     *    `ensureCapacity` may KILL a live agent process to hand its slot to
+     *    another session;
+     *  - `isBillable()` counts only RUNNING/STARTING, so `agentActiveMs` stops
+     *    growing and the time budget never fires for work that is really happening.
+     *
+     * It happens for real: a background subagent's report wakes a new turn inside
+     * the agent process (SDK 0.3.226 emits a second `system:init` and a `result`
+     * carrying `origin: {kind:'task-notification'}`), and nothing here reports a
+     * turn the runner did not start. Compaction does the same, and so does a
+     * question this runner withdraws by itself.
+     *
+     * An open question is the one thing that must survive: there, WAITING_INPUT
+     * means a tool call is parked on a person, and the agent narrating around its
+     * own question must not take the card off the screen.
+     */
+    noteAgentIsWorking(running) {
+        if (running.openQuestions.size > 0)
+            return;
+        if (running.stopRequested || running.parkRequested || running.budgetSpent)
+            return;
+        if (running.lastReported !== 'WAITING_INPUT' && running.lastReported !== 'REVIEW')
+            return;
+        running.lastReported = 'RUNNING';
+        this.syncBudgetClock(running);
+        this.reportStatus(running.descriptor.id, 'RUNNING', {});
+    }
     forwardEvent(running, event) {
         const { descriptor } = running;
+        // Anything below that is the agent talking means the agent is working. Read
+        // before the switch so every such case gets it, including the ones added
+        // after this line was written.
+        if (event.type === 'message' ? event.role === 'assistant' : AGENT_OUTPUT_EVENTS.has(event.type))
+            this.noteAgentIsWorking(running);
         switch (event.type) {
             case 'provider_session': {
                 running.descriptor = { ...descriptor, providerSessionId: event.providerSessionId };
@@ -2431,6 +2476,21 @@ export class Supervisor {
                             error: 'The agent could not compact right now — wait for the current turn to finish',
                         });
                     }
+                    // Ticket #185. Compaction is a whole agent turn — `/compact` goes in
+                    // as an ordinary user message — and until now nobody said so: the
+                    // session read «Ваш ход» for the entire squeeze, and the dashboard
+                    // papered over it with `compactingSince`, a variable that exists only
+                    // in the tab that pressed the button. A second tab, a teammate or a
+                    // reload saw a session waiting for a person who had nothing to do.
+                    //
+                    // It is also not only cosmetic here: a session reading WAITING_INPUT
+                    // with no open question is parkable, and parking it would kill the
+                    // compaction mid-flight.
+                    if (running.lastReported !== 'RUNNING') {
+                        running.lastReported = 'RUNNING';
+                        this.syncBudgetClock(running);
+                        this.reportStatus(running.descriptor.id, 'RUNNING', {});
+                    }
                     return void reply({ ok: true, result: { started: true } });
                 }
                 case 'git_status': {

package/dist/version.d.ts

@@ -1,2 +1,2 @@
-export declare const RUNNER_VERSION = "0.33.0";
+export declare const RUNNER_VERSION = "0.34.0";
 //# sourceMappingURL=version.d.ts.map

package/dist/version.js

@@ -1,3 +1,3 @@
 // Kept in sync with package.json by the release script (manual for now).
-export const RUNNER_VERSION = '0.33.0';
+export const RUNNER_VERSION = '0.34.0';
 //# sourceMappingURL=version.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bridge4dev/runner",
-  "version": "0.33.0",
+  "version": "0.34.0",
   "description": "DevBridge dev runner — connects a dev server to DevBridge and runs agent sessions (Claude Code / Codex)",
   "homepage": "https://bridge4.dev",
   "license": "MIT",
@@ -37,16 +37,16 @@
     "prepublishOnly": "tsc"
   },
   "dependencies": {
-    "@anthropic-ai/claude-agent-sdk": "^0.3.218",
-    "smol-toml": "^1.7.0",
-    "ws": "^8.21.1",
-    "zod": "^3.24.0"
+    "@anthropic-ai/claude-agent-sdk": "^0.3.226",
+    "smol-toml": "^1.7.1",
+    "ws": "^8.21.3",
+    "zod": "^3.25.76"
   },
   "devDependencies": {
-    "@types/node": "^22.10.2",
+    "@types/node": "^22.20.1",
     "@types/ws": "^8.18.1",
-    "tsx": "^4.19.2",
-    "typescript": "~5.7.2",
-    "vitest": "^2.1.9"
+    "tsx": "^4.23.11",
+    "typescript": "~5.7.3",
+    "vitest": "^3.2.7"
   }
 }