@bridge4dev/runner 0.51.0 → 0.53.0

package/dist/supervisor.js

@@ -8,7 +8,7 @@ import { classifyFailure, isRepeatOfSameFailure, MAX_RETRIES_PER_SESSION, retryD
 import { evaluateRecipeCommand, maskSecrets, maskString } from './policy.js';
 import { agentPromptSizeLabel, inspectAgentPrompt, quotePath, readAgentPrompt, } from './agent-prompt.js';
 import { JournalStore } from './journal.js';
-import { deleteSessionBranch, ensurePreviewWorktree, ensureSessionWorktree, prepareDirectWorkspace, previewWorktreePath, removePreviewWorktree, removeSessionWorktree, repoKeyFor, sessionWorktreePath, validateWorkspacePath, } from './git.js';
+import { deleteSessionBranch, ensurePreviewWorktree, ensureSessionWorktree, prepareDirectWorkspace, previewWorktreePath, removePreviewWorktree, removeSessionWorktree, repoKeyFor, sessionWorktreePath, validateWorkspacePath, WorktreePrepareError, } from './git.js';
 import { readRecipeProposal } from './recipe.js';
 import { RECIPE_STEP_NAMES, parseProjectRecipe } from './recipe-schema.js';
 import { proposeCommitMessage } from './commit-message.js';
@@ -26,7 +26,7 @@ import { agentByDbValue } from './agent-registry.js';
 import { invalidateAgentVersions, measureAgentVersions, } from './agent-versions.js';
 import { rememberWorkspacePath } from './environment.js';
 import { composeMessageWithAttachments, saveAttachments, } from './attachments.js';
-import { applyRewind, createCheckpoint, dropCheckpoints, listCheckpoints, previewRewind, pruneCheckpoints, } from './checkpoints.js';
+import { applyRewind, createCheckpoint, dropCheckpoints, listCheckpoints, MAX_BUSY_SESSIONS, previewRewind, pruneCheckpoints, } from './checkpoints.js';
 import { DeliverMessageArgsSchema, QuestionAnswerArgsSchema } from './protocol.js';
 import { availableModes, MODE_REFUSED_TEXT } from './adapters/types.js';
 /** Refusals shared by every checkpoint command (ticket #126). */
@@ -839,10 +839,7 @@ export class Supervisor {
                 running.baseBranch = prepared.baseBranch;
         }
         catch (error) {
-            this.reportStatus(descriptor.id, 'FAILED', {
-                errorMessage: `Failed to prepare git worktree: ${maskSecretText(error)}`,
-            });
-            this.sessions.delete(descriptor.id);
+            this.workspacePrepareFailed(running, error, 'Failed to prepare git worktree');
             return;
         }
         // A session that is already past STARTING (re-sent because this runner
@@ -922,6 +919,50 @@ export class Supervisor {
             ...(descriptor.branchPlan ? { plan: descriptor.branchPlan } : {}),
         }));
     }
+    /**
+     * The working folder could not be built — say so in the feed, pin the fork
+     * point, and let the session go (#360).
+     *
+     * Both doors into `prepareWorkspace` end here. Three things happen in an
+     * order that is not free:
+     *
+     *  1. **The fork point is recorded first.** `git.ts` resolves it before it
+     *     writes anything, precisely so that a failure still knows it. Without it
+     *     the API keeps `base_sha = null` for the session's whole life, and
+     *     «Continue» can never prove the leftover branch is the empty one this
+     *     session created — which is the trap the ticket is about.
+     *  2. **The feed event goes out before the map entry is dropped**, because
+     *     `sendEvent` needs it. Until now neither door sent one: a failed start
+     *     was visible only as an `errorMessage` on the session row, and pressing
+     *     «Continue» wipes that.
+     *  3. **Then the status, then the entry.** A FAILED session is over, and a
+     *     leftover entry would hold one of the runner's few slots.
+     */
+    workspacePrepareFailed(running, error, prefix) {
+        const { descriptor } = running;
+        if (error instanceof WorktreePrepareError) {
+            if (error.baseSha && !running.baseSha)
+                running.baseSha = error.baseSha;
+            if (error.baseBranch && !running.baseBranch)
+                running.baseBranch = error.baseBranch;
+        }
+        const message = maskSecretText(error);
+        log.error('supervisor: the working folder could not be prepared', {
+            sessionId: descriptor.id,
+            workMode: descriptor.workMode ?? 'BRANCH',
+            code: error instanceof WorktreePrepareError ? error.code : 'unknown',
+            error: message,
+        });
+        this.sendEvent(running, 'error', {
+            message,
+            // Not an enum on either side (`RunnerEventPayloadSchema` is a record, and
+            // the dashboard carries whatever code it is given), so this stays a plain
+            // string and a new one costs nobody a deployment.
+            code: error instanceof WorktreePrepareError ? error.code : 'worktree_prepare_failed',
+        });
+        this.reportStatus(descriptor.id, 'FAILED', { errorMessage: `${prefix}: ${message}` });
+        this.sessions.delete(descriptor.id);
+    }
     /**
      * Spin the adapter up — for a fresh session, a resume-on-next-message, or a
      * free CHAT session with no prompt at all (the agent boots, reports its
@@ -1040,6 +1081,10 @@ export class Supervisor {
                 // (`resolveGitPolicy` gives both the restrictive reading), and passing it
                 // unconditionally keeps one code path instead of two.
                 gitPolicy: gitPolicyOf(descriptor),
+                // #361 п. 5: whether this session shares its folder with everybody else.
+                // Rides down for the same reason as `gitPolicy` — it lands in
+                // `PolicyContext` and it decides one line of the system prompt.
+                ...(descriptor.workMode ? { workMode: descriptor.workMode } : {}),
                 mode: running.mode,
                 ...(running.model ? { model: running.model } : {}),
                 ...(running.effort ? { effort: running.effort } : {}),
@@ -1726,7 +1771,8 @@ export class Supervisor {
     /**
      * Make room for one more agent process.
      *
-     * Up to `maxSessions` agents run side by side, each in its own worktree. Over
+     * Up to `maxSessions` agents run side by side — since session 16 most of them
+     * share the project folder rather than each having a worktree of its own. Over
      * that, idle-but-resumable sessions (REVIEW / WAITING_INPUT) are parked —
      * their provider session survives on disk and relaunches on the next message,
      * so parking costs context nothing. Only mid-turn sessions (RUNNING /
@@ -2456,7 +2502,13 @@ export class Supervisor {
             case 'settings':
                 if (event.mode)
                     running.mode = event.mode;
-                if (event.model)
+                // null = the agent dropped the pinned MODEL, because the installed CLI
+                // stopped offering it (#374). Dropped from the local record too: this
+                // object is what a relaunch inside the same runner process starts from,
+                // so keeping it would re-pin the model the adapter just refused.
+                if (event.model === null)
+                    delete running.model;
+                else if (event.model)
                     running.model = event.model;
                 // null = the agent dropped the pinned level (model without it) — the
                 // API must clear its column, so the value is forwarded as-is.
@@ -2465,7 +2517,7 @@ export class Supervisor {
                 else if (event.effort)
                     running.effort = event.effort;
                 this.sendEvent(running, 'settings', {
-                    model: event.model,
+                    ...(event.model === undefined ? {} : { model: event.model }),
                     mode: event.mode,
                     ...(event.effort === undefined ? {} : { effort: event.effort }),
                 });
@@ -3100,17 +3152,42 @@ export class Supervisor {
      * Three reasons it declines, and each of them is a state in which a snapshot
      * would be a lie rather than a restore point:
      *  - the machine's owner switched checkpoints off;
-     *  - the agent is mid-turn, so the tree is being written to as we read it;
+     *  - THIS session is mid-turn, so its own tree is being written as we read it;
      *  - a repo-mutating command holds the repository.
+     *
+     * «A neighbour in the same folder is working» used to be a fourth reason, and
+     * it was the wrong one (#310): in DIRECT mode the folder is shared by design,
+     * so that rule silently switched restore points off for everybody the moment
+     * a second session opened. The neighbours are recorded on the point instead —
+     * the conversation can always be rewound to it, the files cannot.
+     *
+     * Every refusal is now audible. A restore point that was never taken is
+     * invisible until the day somebody reaches for it, and «the button is not
+     * there» is not a sentence anybody can act on.
      */
     async captureCheckpoint(running, kind, messageSeq) {
         const worktreePath = running.worktreePath;
-        if (!worktreePath || this.opts.checkpointsEnabled === false)
+        if (!worktreePath)
             return;
-        if (kind === 'TURN' && this.isWorktreeBusy(worktreePath))
+        if (this.opts.checkpointsEnabled === false) {
+            // Once per session: this is a machine-wide setting, not an event.
+            if (!running.checkpointsOffSaid) {
+                running.checkpointsOffSaid = true;
+                this.sendEvent(running, 'notice', {
+                    level: 'info',
+                    text: 'Restore points are switched off on this dev server, so this session cannot be rewound. A server administrator turns them back on.',
+                });
+            }
             return;
-        if (await this.isRepoLocked(worktreePath))
+        }
+        if (kind === 'TURN' && this.isSessionMidTurn(running)) {
+            this.noticeOncePerTurn(running, 'checkpoint-self-busy', 'No restore point was taken for this step: this session was still answering when it was due.');
             return;
+        }
+        if (await this.isRepoLocked(worktreePath)) {
+            this.noticeOncePerTurn(running, 'checkpoint-repo-locked', 'No restore point was taken for this step: another git command holds this repository. It will be taken on the next one.');
+            return;
+        }
         // The anchor and the conversation it names travel TOGETHER: a point
         // recorded against an older provider session stays usable, because the
         // rewind resumes the session the point names rather than whichever one the
@@ -3122,6 +3199,10 @@ export class Supervisor {
             kind,
             ...(messageSeq === undefined ? {} : { messageSeq }),
             ...(anchor ? { agentAnchor: anchor.anchor, agentSession: anchor.agentSession } : {}),
+            // A getter, not a value: taking the snapshot is not instantaneous, and
+            // «who was working while it was taken» is a question about the whole of
+            // that interval (#310).
+            busySessions: () => this.busyNeighbours(running),
         });
         if (this.isStale(running))
             return;
@@ -3134,6 +3215,16 @@ export class Supervisor {
                     text: 'This working tree is too large to take a restore point — rewind is unavailable for this step. Check that build output is in .gitignore.',
                 });
             }
+            else {
+                // Not a repository, or git refused: every time, because unlike the two
+                // conditions above this one does not clear itself.
+                this.sendEvent(running, 'notice', {
+                    level: 'warn',
+                    text: result.reason === 'not-a-repo'
+                        ? 'No restore point could be taken: this folder is not a git repository, so there is nothing to rewind to.'
+                        : 'No restore point could be taken for this step, so it cannot be rewound. The session itself is unaffected.',
+                });
+            }
             return;
         }
         this.sendEvent(running, 'checkpoint', {
@@ -3144,8 +3235,36 @@ export class Supervisor {
             canRewindContext: Boolean(result.record.agentAnchor),
             ...(messageSeq === undefined ? {} : { messageSeq }),
             ...(result.skippedFiles.length ? { skippedFiles: result.skippedFiles.slice(0, 20) } : {}),
+            // Only when non-empty (#310, gotcha 433): on this path the DASHBOARD
+            // reads an empty list as «the folder was quiet», which is the opposite
+            // convention to the rewind preview, where the presence of the key is the
+            // warning. Two paths, two conventions, both deliberate.
+            ...(result.record.busySessions?.length
+                ? { busySessions: result.record.busySessions.slice(0, MAX_BUSY_SESSIONS) }
+                : {}),
         });
     }
+    /**
+     * Say something once per BUSY PERIOD, not once per message (#310).
+     *
+     * A folder held by a neighbour stays held for minutes, and a session mid-turn
+     * can be sent three follow-up notes inside one answer. Keying this on the
+     * message seq would have counted each of those as its own turn and said the
+     * same sentence three times — the noise the frequency policy exists to
+     * prevent. The set is cleared when the session next comes to rest
+     * (`reportStatus`), which is exactly when the reason stops being true.
+     *
+     * A SET of keys, not the last one said: two different reasons can both come
+     * up inside one period, and remembering only the most recent would let them
+     * take turns re-announcing each other.
+     */
+    noticeOncePerTurn(running, key, text) {
+        running.noticesThisTurn ??= new Set();
+        if (running.noticesThisTurn.has(key))
+            return;
+        running.noticesThisTurn.add(key);
+        this.sendEvent(running, 'notice', { level: 'info', text });
+    }
     /**
      * Deliver messages that raced session start (already journaled).
      *
@@ -3219,7 +3338,7 @@ export class Supervisor {
             return;
         }
         const open = running.stopCycle;
-        if (open && ownsProcess(open, running.session) && !open.settled) {
+        if (open && Supervisor.stopInFlight(running)) {
             // #357 part 2, and invariant 2 of the pause plan. Ten frames arrive while
             // the CLI is waiting out a provider retry — from a phone and a laptop at
             // once, or from a person pressing a button that gave them no sign it had
@@ -3618,7 +3737,7 @@ export class Supervisor {
         // could not tell a tool RESULT from a tool starting, so the tail of the stop
         // read as a turn beginning.
         const cycle = running.stopCycle;
-        if (cycle && ownsProcess(cycle, running.session) && !cycle.settled) {
+        if (cycle && Supervisor.stopInFlight(running)) {
             log.info('supervisor: output under a pause belongs to the stop in flight', {
                 sessionId: running.descriptor.id,
                 phase: cycle.phase,
@@ -3740,12 +3859,17 @@ export class Supervisor {
         }
         await this.applyLiveSettings(running, model, mode, effort);
     }
-    /** Is a turn (or a question the agent is parked on) in flight right now? */
+    /**
+     * Is a turn (or a question the agent is parked on) in flight right now?
+     *
+     * The same status list as `holdsTheTree` plus one term: an open question
+     * parks the session without any of those statuses, and a live settings change
+     * must not land under it. Reading the shared array rather than spelling the
+     * statuses out again is the whole point of Р8 — a fourth waiting status has
+     * to arrive in one place, not four.
+     */
     isMidTurn(running) {
-        return (running.lastReported === 'RUNNING' ||
-            running.lastReported === 'STARTING' ||
-            running.lastReported === 'WAITING_PERMISSION' ||
-            running.openQuestions.size > 0);
+        return (Supervisor.MID_TURN_STATUSES.includes(running.lastReported) || running.openQuestions.size > 0);
     }
     /** The three live setters, in the order that lets an explicit pick win. */
     async applyLiveSettings(running, model, mode, effort) {
@@ -4090,10 +4214,12 @@ export class Supervisor {
                             running.baseBranch = prepared.baseBranch;
                     }
                     catch (error) {
-                        this.reportStatus(descriptor.id, 'FAILED', {
-                            errorMessage: `Failed to restore session worktree: ${String(error instanceof Error ? error.message : error).slice(0, 500)}`,
-                        });
-                        this.sessions.delete(descriptor.id);
+                        // The same treatment as the start door (#360). Two doors doing one
+                        // thing is how the pause bug of #373 stayed half-fixed for a
+                        // release; this one used to mask its text differently AND emit no
+                        // feed event at all, so a session that could not be restored went
+                        // FAILED with nothing to read anywhere.
+                        this.workspacePrepareFailed(running, error, 'Failed to restore session worktree');
                         continue;
                     }
                     /**
@@ -4247,7 +4373,24 @@ export class Supervisor {
     }
     // ─── Commands ──────────────────────────────────────────────────────
     async runCommand(frame) {
-        const reply = (result) => this.ws.send({ type: 'command_result', requestId: frame.requestId, ...result });
+        // How long a command actually took on THIS machine. Nothing measured it
+        // before, which is why «the branch probe timed out after 4 s» could never be
+        // answered with «it takes 9 s on that server» or «it never arrived» — the
+        // two failures #316 turned out to be. One line, at INFO, per command.
+        const startedAt = Date.now();
+        let answered = false;
+        const reply = (result) => {
+            if (!answered) {
+                answered = true;
+                log.info('supervisor: command handled', {
+                    command: frame.name,
+                    ...(frame.sessionId ? { sessionId: frame.sessionId } : {}),
+                    elapsedMs: Date.now() - startedAt,
+                    ok: result.ok,
+                });
+            }
+            this.ws.send({ type: 'command_result', requestId: frame.requestId, ...result });
+        };
         try {
             switch (frame.name) {
                 case 'validate_path': {
@@ -4440,7 +4583,9 @@ export class Supervisor {
                     if (!running.worktreePath) {
                         return void reply({ ok: false, error: 'The session has no working folder yet' });
                     }
-                    if (this.isWorktreeBusy(running.worktreePath)) {
+                    // #310: this session's own turn, not the folder's. A neighbour
+                    // working next door marks the point; it does not forbid it.
+                    if (this.isSessionMidTurn(running)) {
                         return void reply({ ok: false, error: AGENT_BUSY });
                     }
                     const before = (await listCheckpoints(running.worktreePath, running.descriptor.id))
@@ -4471,6 +4616,12 @@ export class Supervisor {
                                 // conversation is still on disk.
                                 canRewindContext: Boolean(item.agentAnchor),
                                 ...(item.messageSeq === undefined ? {} : { messageSeq: item.messageSeq }),
+                                // The mark travels with the LIST as well as with the live event
+                                // (#310): the list is how a reloaded page rebuilds state, and a
+                                // mark that only ever rode the event would be lost there.
+                                ...(item.busySessions?.length
+                                    ? { busySessions: item.busySessions.slice(0, MAX_BUSY_SESSIONS) }
+                                    : {}),
                             })),
                         },
                     });
@@ -4501,8 +4652,18 @@ export class Supervisor {
                     if (ordinal === null || !running.worktreePath) {
                         return void reply({ ok: false, error: 'ordinal is required' });
                     }
+                    // The folder check STAYS here: this one writes files, and files are
+                    // shared. What changes is the sentence — `AGENT_BUSY` talks about
+                    // «the agent», meaning this session's own, and names nobody. When it
+                    // is a neighbour holding the folder, say so (#310).
                     if (this.isWorktreeBusy(running.worktreePath)) {
-                        return void reply({ ok: false, error: AGENT_BUSY });
+                        const neighbours = this.busyNeighbours(running);
+                        return void reply({
+                            ok: false,
+                            error: neighbours.length > 0
+                                ? `Another session in this folder is still working (${neighbours.join(', ')}), so the files cannot be put back until it stops. Only the conversation can be rewound.`
+                                : AGENT_BUSY,
+                        });
                     }
                     const confirmRaw = frame.args?.['confirmDeletes'];
                     const confirmDeletes = Array.isArray(confirmRaw)
@@ -4516,6 +4677,10 @@ export class Supervisor {
                         sessionId: running.descriptor.id,
                         ordinal,
                         confirmDeletes,
+                        // The safety point is a restore point like any other and gets the
+                        // same question asked of it. Non-empty only through the #373
+                        // window — the folder check above has already passed.
+                        busySessions: () => this.busyNeighbours(running),
                         ...(typeof expectedTreeOid === 'string' && expectedTreeOid
                             ? { expectedTreeOid }
                             : {}),
@@ -4526,12 +4691,20 @@ export class Supervisor {
                         createdAt: result.safety.createdAt,
                         fileCount: result.safety.fileCount,
                         canRewindContext: Boolean(result.safety.agentAnchor),
+                        ...(result.safety.busySessions?.length
+                            ? { busySessions: result.safety.busySessions.slice(0, MAX_BUSY_SESSIONS) }
+                            : {}),
                         // This frame IS the browser's offer of «Undo rewind» — the point it
                         // names belongs to no message, so there is nowhere else the offer
                         // could come from. Withheld when the rewind was itself an undo:
                         // going back again is a redo, and a button that quietly changes
                         // meaning after one press is worse than no button.
-                        undoable: result.rewoundToKind !== 'SAFETY',
+                        //
+                        // Also withheld when the safety point itself came out marked (#310).
+                        // That happens through the #373 window — a neighbour woke between
+                        // the folder check and the snapshot — and `applyRewind` refuses a
+                        // marked point, so the offer would be a button that cannot work.
+                        undoable: result.rewoundToKind !== 'SAFETY' && !(result.safety.busySessions?.length ?? 0),
                     });
                     this.sendEvent(running, 'system_note', {
                         code: 'files_rewound',
@@ -4547,7 +4720,11 @@ export class Supervisor {
                     if (ordinal === null || !running.worktreePath) {
                         return void reply({ ok: false, error: 'ordinal is required' });
                     }
-                    if (this.isWorktreeBusy(running.worktreePath)) {
+                    // #310: the conversation can be rewound whatever the neighbours are
+                    // doing — it touches no file of theirs. This session's OWN unfinished
+                    // turn still has to stop first: the rewind parks and relaunches this
+                    // very process, and the button is hidden mid-turn anyway.
+                    if (this.isSessionMidTurn(running)) {
                         return void reply({ ok: false, error: AGENT_BUSY });
                     }
                     const items = await listCheckpoints(running.worktreePath, running.descriptor.id);
@@ -5451,19 +5628,90 @@ export class Supervisor {
             return 'sessionId is required';
         return this.sessions.get(sessionId) ?? 'Unknown session';
     }
+    /**
+     * The statuses in which a session is holding its working tree (#310).
+     *
+     * One array, read by all three predicates below. There used to be one
+     * literal, then two would have been needed, and a third would have been
+     * written the day somebody added a waiting state — which is how «the agent
+     * is busy» and «the folder is busy» come to disagree about what busy means.
+     * (`rewindActionsLive` in the dashboard is a fourth reader and a deliberate
+     * mirror: the runner does not depend on `@devbridge/shared`.)
+     */
+    static MID_TURN_STATUSES = [
+        'STARTING',
+        'RUNNING',
+        'WAITING_PERMISSION',
+    ];
+    /**
+     * Is a stop still in flight over this session's live process?
+     *
+     * Three terms, written out in three places before this: an open cycle, that
+     * cycle owning the process that is running NOW, and the cycle not yet
+     * settled. #373 is what makes it load-bearing — the resting status is
+     * published before the process dies, so this is the difference between «the
+     * session is quiet» and «the session is still writing files».
+     */
+    static stopInFlight(running) {
+        const cycle = running.stopCycle;
+        return cycle !== undefined && ownsProcess(cycle, running.session) && !cycle.settled;
+    }
+    static holdsTheTree(running) {
+        return Boolean(running.session) && Supervisor.MID_TURN_STATUSES.includes(running.lastReported);
+    }
     /** A session actively mid-turn in this worktree — git writes must wait. */
     isWorktreeBusy(worktreePath) {
         for (const running of this.sessions.values()) {
-            if (running.worktreePath !== worktreePath || !running.session)
+            if (running.worktreePath !== worktreePath)
                 continue;
-            if (running.lastReported === 'STARTING' ||
-                running.lastReported === 'RUNNING' ||
-                running.lastReported === 'WAITING_PERMISSION') {
+            if (Supervisor.holdsTheTree(running))
                 return true;
-            }
         }
         return false;
     }
+    /**
+     * Is THIS session mid-turn? (#310)
+     *
+     * The question `isWorktreeBusy` was answering in three places where the right
+     * question was this one. They are the same question only when a folder holds
+     * exactly one session — and DIRECT mode, the default since session 16, is
+     * precisely the arrangement in which it holds several. A restore point is a
+     * snapshot of this session's own conversation; a neighbour typing in the same
+     * folder is a reason to MARK it, not to refuse to take it.
+     */
+    isSessionMidTurn(running) {
+        return Supervisor.holdsTheTree(running);
+    }
+    /**
+     * Everybody else who is working in this folder right now (#310).
+     *
+     * Includes a neighbour whose stop is still running: after #373 the resting
+     * status is published BEFORE the process is actually gone, so a session that
+     * reports IDLE while its stop cycle still owns a live process is still
+     * writing files. Reading `lastReported` alone would call that folder quiet.
+     */
+    busyNeighbours(running) {
+        const worktreePath = running.worktreePath;
+        if (!worktreePath)
+            return [];
+        const ids = [];
+        for (const other of this.sessions.values()) {
+            // By id as well as by identity: a session that was re-started under a
+            // higher epoch is a NEW entry for the SAME session, and it must not end
+            // up marking its own restore point with its own id.
+            if (other === running ||
+                other.descriptor.id === running.descriptor.id ||
+                other.worktreePath !== worktreePath) {
+                continue;
+            }
+            if (Supervisor.holdsTheTree(other) || Supervisor.stopInFlight(other)) {
+                ids.push(other.descriptor.id);
+            }
+            if (ids.length >= MAX_BUSY_SESSIONS)
+                break;
+        }
+        return ids;
+    }
     // ─── Outbound helpers ──────────────────────────────────────────────
     // Hard cap far below the API's 128KB Zod limit — an oversized payload would
     // be rejected forever and wedge the journal (QA-96 F2).
@@ -5505,6 +5753,11 @@ export class Supervisor {
         const running = this.sessions.get(sessionId);
         if (running) {
             running.lastReported = status;
+            // Coming to rest ends the busy period the once-per-turn notices were
+            // limited to: the next one is about a new answer and deserves saying.
+            if (!Supervisor.MID_TURN_STATUSES.includes(status)) {
+                delete running.noticesThisTurn;
+            }
             this.syncBudgetClock(running);
         }
         // The fork point rides along on the first frame after the branch was

package/dist/version.d.ts

@@ -1,2 +1,2 @@
-export declare const RUNNER_VERSION = "0.51.0";
+export declare const RUNNER_VERSION = "0.53.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.51.0';
+export const RUNNER_VERSION = '0.53.0';
 //# sourceMappingURL=version.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bridge4dev/runner",
-  "version": "0.51.0",
+  "version": "0.53.0",
   "description": "DevBridge dev runner — connects a dev server to DevBridge and runs agent sessions (Claude Code / Codex)",
   "homepage": "https://bridge4.dev",
   "license": "MIT",