@bridge4dev/runner 0.33.0 → 0.35.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/adapters/codex.js

@@ -483,21 +483,41 @@ class CodexSession {
             // settings/update in this protocol version).
             ...(this.effort ? { effort: this.effort } : {}),
         };
-        // Collaboration mode is turn-scoped but sticky, and its `settings` REPLACE
-        // the thread's developer instructions — so only send it on a real change.
+        // Collaboration mode is turn-scoped but sticky, so it is only sent on a real
+        // change. What it must NOT carry is our own instructions (ticket #179).
         //
-        // Session 13: they are sent for plan mode too. Passing `null` there did not
-        // mean «keep what the thread had», it meant «no developer instructions at
-        // all» — so the one mode a user picks when they want the agent to think
-        // before acting was the one mode where DevBridge's rules, the branch it is
-        // on and the project's own CLAUDE.md never reached it.
+        // The line that used to sit here said `settings` REPLACE the thread's
+        // developer instructions, and that passing `null` meant «no developer
+        // instructions at all». Both halves are false, and the first one cost the
+        // product a duplicated system prompt in every Codex session. Measured on the
+        // wire — a fake Responses API behind `codex app-server`, reading the developer
+        // message verbatim — on codex-cli 0.135.0 AND 0.147.0, which behave alike:
+        //
+        //   thread developerInstructions + collaborationMode carrying the same text
+        //     → the text appears TWICE in one developer message: once at the top (on
+        //       0.135.0, right after `<permissions instructions>`) and again inside
+        //       `<collaboration_mode>…</collaboration_mode>`. That is exactly what the
+        //       ticket's screenshots show, and with a real project prompt it is ~27 KB
+        //       sent twice on every single request.
+        //   thread developerInstructions + `developer_instructions: null`
+        //     → the text appears ONCE, and `<collaboration_mode>` carries Codex's own
+        //       preset for the mode («# Plan Mode (Conversational)…»).
+        //
+        // So `null` is not a loss, it is the fix — and it repairs a second, quieter
+        // defect at the same time: our text was OVERWRITING Codex's built-in plan
+        // instructions, i.e. the one mode a user picks to make the agent think before
+        // acting was the one mode that never received the instructions for thinking
+        // before acting. The thread-level channel (`threadParams`) stays the single
+        // source of DevBridge's rules, exactly like `systemPrompt.append` on Claude.
         if (this.lastCollabMode !== wantCollab) {
             params['collaborationMode'] = {
                 mode: wantCollab,
                 settings: {
                     model: this.model ?? this.threadModel ?? 'gpt-5.5',
                     reasoning_effort: null,
-                    developer_instructions: composeSystemAppend(this.spec),
+                    // «Use the built-in instructions for the selected mode» — the app-server
+                    // schema's own words. Ours already arrived with the thread.
+                    developer_instructions: null,
                 },
             };
             this.lastCollabMode = wantCollab;

package/dist/index.js

@@ -35,6 +35,18 @@ const LAST_EXIT = takeLastExit();
 function print(line) {
     process.stdout.write(line + '\n');
 }
+/**
+ * Дата для оператора, который читает вывод у себя в консоли.
+ *
+ * Раньше здесь стояло `iso.slice(0, 10)` — это UTC-день, а не день того, кто
+ * смотрит: к востоку от Гринвича поздним вечером он показывает вчерашнее число.
+ * Часы машины оператора — единственный разумный ответ: у раннера нет ни
+ * человека с настройкой, ни организации.
+ */
+function formatLocalDay(iso) {
+    const date = new Date(iso);
+    return Number.isNaN(date.getTime()) ? iso.slice(0, 10) : date.toLocaleDateString();
+}
 function fail(message) {
     process.stderr.write(`error: ${message}\n`);
     process.exit(1);
@@ -908,7 +920,7 @@ async function agentChecks() {
             ok: signedIn,
             name: `${agent} login`,
             detail: (info.detail ?? info.status) +
-                (info.expiresAt ? ` · until ${info.expiresAt.slice(0, 10)}` : ''),
+                (info.expiresAt ? ` · until ${formatLocalDay(info.expiresAt)}` : ''),
             ...(signedIn
                 ? {}
                 : {

package/dist/supervisor.d.ts

@@ -136,6 +136,20 @@ export declare class Supervisor {
      * refuse writes to it: in `workMode: DIRECT` the project folder is the
      * agent's own working directory, so without that rule a session could rewrite
      * the prompt it will itself be started with next time (QA-130 MAJOR-3).
+     *
+     * @param resuming This launch continues an existing agent conversation. It
+     *   changes only the WORDS, never the behaviour — and the words matter,
+     *   because a person who has just watched their session crash reads a second
+     *   «Project prompt loaded» as «my context was thrown away» (ticket #177).
+     *   Measured, so the line can say it plainly: a system prompt lives in the
+     *   agent PROCESS, not in the saved conversation. Resuming Claude Code
+     *   without re-supplying `--append-system-prompt` restores every message and
+     *   ZERO bytes of the appended prompt; re-supplying it restores the same
+     *   messages and exactly ONE copy of the prompt, never two. Codex is the same
+     *   fact by a different route — it rebuilds the developer message from the
+     *   current parameters on every request. So re-reading the file here is not
+     *   waste, and skipping it would silently strip the project's rules (and
+     *   DevBridge's own) from every session that ever resumed.
      */
     private resolveAgentPrompt;
     /** Warn the user when this share of the budget is gone. */
@@ -246,6 +260,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).
  *
@@ -352,8 +358,19 @@ export class Supervisor {
             if (descriptor.epoch > 0) {
                 // The API owns the resume transition; the feed marker has to come from
                 // here because the runner is the only writer of the event seq.
+                //
+                // Ticket #177: which of the two sentences is true depends on whether
+                // there is a conversation to go back to. `providerSessionId` is the
+                // agent's own name for it, and it is what the next launch hands to
+                // `--resume` / `thread/resume`. Without it the next process starts the
+                // conversation over — which is a real loss, and promising «continue
+                // where the agent left off» there is the one thing the feed must not do.
+                // It happens for real: a process that dies before it reports its session
+                // id (the SIGABRT this ticket came from) leaves the row with none.
                 this.sendEvent(running, 'system_note', {
-                    text: 'Session resumed — send a message to continue where the agent left off.',
+                    text: descriptor.providerSessionId
+                        ? 'Session resumed — the agent still has this conversation. Send a message to continue where it left off.'
+                        : 'Session resumed, but the agent never got as far as naming its conversation, so it starts this one over. Your files, your branch and everything above are untouched.',
                 });
             }
             running.lastReported = descriptor.status === 'REVIEW' ? 'REVIEW' : 'WAITING_INPUT';
@@ -438,7 +455,14 @@ export class Supervisor {
         // Facts about this session only, plus the one file the project named. The
         // rest of the project's documentation is read by each agent itself — see
         // `composeWorkspaceContext`.
-        const agentPrompt = this.resolveAgentPrompt(running);
+        // Does this launch CONTINUE the agent's conversation or begin a new one?
+        // Read before `rewindAnchor` is consumed below, and without consuming it —
+        // the prompt notice says different things about the two cases (#177).
+        // A rewind resumes a conversation too, but a CUT one — so it gets neither
+        // «loaded» nor «unchanged».
+        const rewinding = Boolean(running.rewindAnchor?.agentSession);
+        const resuming = rewinding || Boolean(resumeId);
+        const agentPrompt = this.resolveAgentPrompt(running, resuming && !rewinding);
         const workspaceContext = composeWorkspaceContext(descriptor, agentPrompt?.text);
         const rewind = running.rewindAnchor;
         delete running.rewindAnchor;
@@ -509,8 +533,22 @@ export class Supervisor {
      * refuse writes to it: in `workMode: DIRECT` the project folder is the
      * agent's own working directory, so without that rule a session could rewrite
      * the prompt it will itself be started with next time (QA-130 MAJOR-3).
+     *
+     * @param resuming This launch continues an existing agent conversation. It
+     *   changes only the WORDS, never the behaviour — and the words matter,
+     *   because a person who has just watched their session crash reads a second
+     *   «Project prompt loaded» as «my context was thrown away» (ticket #177).
+     *   Measured, so the line can say it plainly: a system prompt lives in the
+     *   agent PROCESS, not in the saved conversation. Resuming Claude Code
+     *   without re-supplying `--append-system-prompt` restores every message and
+     *   ZERO bytes of the appended prompt; re-supplying it restores the same
+     *   messages and exactly ONE copy of the prompt, never two. Codex is the same
+     *   fact by a different route — it rebuilds the developer message from the
+     *   current parameters on every request. So re-reading the file here is not
+     *   waste, and skipping it would silently strip the project's rules (and
+     *   DevBridge's own) from every session that ever resumed.
      */
-    resolveAgentPrompt(running) {
+    resolveAgentPrompt(running, resuming = false) {
         const { descriptor } = running;
         const configured = descriptor.workspace.agentPromptPath?.trim();
         if (!configured)
@@ -551,7 +589,9 @@ export class Supervisor {
         // mode.
         this.sendEvent(running, 'notice', {
             level: 'info',
-            text: `Project prompt loaded from ${quotePath(result.relPath)} — ${agentPromptSizeLabel(result.bytes)}, sha ${result.sha}.`,
+            text: resuming
+                ? `Project prompt re-applied from ${quotePath(result.relPath)} — ${agentPromptSizeLabel(result.bytes)}, sha ${result.sha}. A new agent process needs it again; the conversation is unchanged.`
+                : `Project prompt loaded from ${quotePath(result.relPath)} — ${agentPromptSizeLabel(result.bytes)}, sha ${result.sha}.`,
         });
         return { text: result.text, absPath: result.absPath };
     }
@@ -1046,8 +1086,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 };
@@ -2050,7 +2129,13 @@ export class Supervisor {
                  */
                 const wasMidTurn = descriptor.status === 'RUNNING' || descriptor.status === 'WAITING_PERMISSION';
                 const resumeId = descriptor.providerSessionId;
-                const willContinue = wasMidTurn && claimAutoResume(descriptor.id);
+                // Ticket #177: `resumeId` is required, not merely nice to have. Without
+                // it the relaunch starts a FRESH conversation, and `AUTO_RESUME_PROMPT`
+                // — "continue from where you stopped, re-check what you were in the
+                // middle of" — would be addressed to an agent that remembers none of
+                // it. A process killed before it reported its session id (the SIGABRT
+                // this ticket came from) leaves the row in exactly that state.
+                const willContinue = wasMidTurn && Boolean(resumeId) && claimAutoResume(descriptor.id);
                 // The note stays either way (owner's call): an interruption is a fact
                 // about the session and must not disappear just because we recovered
                 // from it. Only the instruction at the end changes — telling someone to
@@ -2058,7 +2143,9 @@ export class Supervisor {
                 this.sendEvent(running, 'system_note', {
                     text: willContinue
                         ? 'Runner reconnected. The session was resumed — continuing the interrupted turn.'
-                        : 'Runner reconnected. The session was resumed — send a message to continue.',
+                        : resumeId
+                            ? 'Runner reconnected. The session was resumed — send a message to continue.'
+                            : 'Runner reconnected, but the agent never got as far as naming its conversation, so it starts this one over. Your files, your branch and everything above are untouched.',
                 });
                 if (willContinue) {
                     // Resumed through the PROVIDER session, so the agent keeps its whole
@@ -2431,6 +2518,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.35.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.35.0';
 //# sourceMappingURL=version.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bridge4dev/runner",
-  "version": "0.33.0",
+  "version": "0.35.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"
   }
 }