@bridge4dev/runner 0.60.0 → 0.61.0

package/dist/adapters/claude.js

@@ -2180,6 +2180,65 @@ class ClaudeSession {
     conversationAnchor() {
         return this.lastMessageUuid;
     }
+    /** A compaction the CLI has announced and not yet ended (#348). */
+    compacting = false;
+    /**
+     * `system:status` — the CLI's own word on what it is doing (#348).
+     *
+     * Read the way the CLI's own remote client reads it (`noteInbound`):
+     * «compacting» opens a compaction, `requesting` says nothing about one (the
+     * summary itself is a model request, and this status arrives DURING a
+     * compaction), and any other status closes it — with `compact_result` when
+     * the CLI says how it went, and as «skipped» when it does not: a PreCompact
+     * hook that said no, or a reactive compaction that found nothing to fold,
+     * both end on a bare `status: null`. Left unclosed, that start line would
+     * keep the dashboard saying «compacting» until the turn ended, minutes later.
+     *
+     * De-duplicated here as well as in the supervisor: the CLI re-says
+     * «compacting» every thirty seconds while it waits on a precomputed summary.
+     *
+     * No `standalone` on this agent: `/compact` is a turn, and its `result`
+     * settles the status the ordinary way.
+     */
+    noteStatus(msg) {
+        const status = msg.status;
+        if (status === 'requesting')
+            return;
+        if (status === 'compacting') {
+            if (this.compacting)
+                return;
+            this.compacting = true;
+            this.emit({ type: 'compaction', phase: 'started' });
+            return;
+        }
+        // An end is only an end of something that began: without a start on
+        // record there is nothing to close, and the second of two endings (a
+        // `compact_result` after a `compact_boundary`) must not open a second
+        // pair. A mode change also travels on this message — `{status: null,
+        // permissionMode}` on every `setPermissionMode` in CLI 2.1.271 — and says
+        // nothing about a compaction at all.
+        if (!this.compacting)
+            return;
+        const compactResult = msg.compact_result;
+        if (compactResult === undefined && msg.permissionMode !== undefined)
+            return;
+        this.compacting = false;
+        if (compactResult === 'failed') {
+            this.emit({
+                type: 'compaction',
+                phase: 'finished',
+                ok: false,
+                error: maskString(String(msg.compact_error ?? 'unknown')).slice(0, 300),
+            });
+            return;
+        }
+        this.emit({
+            type: 'compaction',
+            phase: 'finished',
+            ok: true,
+            ...(compactResult === 'success' ? {} : { skipped: true }),
+        });
+    }
     /**
      * `/compact` — the CLI's own command, delivered as ordinary user input.
      *
@@ -2296,19 +2355,15 @@ class ClaudeSession {
                             this.refreshUsage();
                         }
                         else if (msg.subtype === 'status') {
-                            const status = msg.status;
-                            const compactResult = msg.compact_result;
-                            if (status === 'compacting') {
-                                this.emit({ type: 'notice', level: 'info', text: 'Compacting the conversation…' });
-                            }
-                            else if (compactResult) {
-                                this.emit({
-                                    type: 'notice',
-                                    level: compactResult === 'failed' ? 'warn' : 'info',
-                                    text: compactResult === 'failed'
-                                        ? `Compaction failed: ${maskString(String(msg.compact_error ?? 'unknown')).slice(0, 300)}`
-                                        : 'Conversation compacted',
-                                });
+                            this.noteStatus(msg);
+                        }
+                        else if (msg.subtype === 'compact_boundary') {
+                            // The summary is in place: this marker is the end of a
+                            // compaction whether or not a status said so first (#348) — the
+                            // CLI's own remote client reads it the same way.
+                            if (this.compacting) {
+                                this.compacting = false;
+                                this.emit({ type: 'compaction', phase: 'finished', ok: true });
                             }
                         }
                         else if (msg.subtype === 'api_retry') {
@@ -2440,6 +2495,10 @@ class ClaudeSession {
                         break;
                     }
                     case 'result': {
+                        // A turn's end is the end of any compaction it carried (#348):
+                        // the supervisor closes the pair on `turn_end`, and the flag here
+                        // has to agree, or the next «compacting» would be read as a repeat.
+                        this.compacting = false;
                         this.emit({
                             type: 'cost',
                             costUsd: msg.total_cost_usd,

package/dist/adapters/codex.js

@@ -876,6 +876,7 @@ class CodexSession {
             return false;
         try {
             await this.client.request('thread/compact/start', { threadId: this.threadId });
+            this.requestedCompaction = true;
             return true;
         }
         catch (error) {
@@ -883,6 +884,14 @@ class CodexSession {
             return false;
         }
     }
+    /**
+     * A compaction THIS adapter asked for with `thread/compact/start` (#348) —
+     * the one kind that runs outside any turn and therefore has nothing to
+     * settle the session status behind it. The agent's own compaction inside a
+     * turn is not it, even when its item happens to complete before the
+     * `turn/started` that announces the turn.
+     */
+    requestedCompaction = false;
     stop(reason = 'session_stopped') {
         if (this.stopped)
             return;
@@ -1472,8 +1481,19 @@ class CodexSession {
                 return;
             }
             case 'contextCompaction': {
-                if (done)
-                    this.notice('info', 'Conversation compacted');
+                // #348: an event, not a notice — see `AgentEvent['compaction']`. A
+                // compaction started from the dashboard runs outside any turn on this
+                // agent (`thread/compact/start` creates none), so nothing will settle
+                // the status behind it; `standalone` tells the supervisor to.
+                if (method === 'item/started') {
+                    this.emit({ type: 'compaction', phase: 'started' });
+                    return;
+                }
+                if (done) {
+                    const standalone = this.requestedCompaction && this.activeTurnId === null;
+                    this.requestedCompaction = false;
+                    this.emit({ type: 'compaction', phase: 'finished', ok: true, standalone });
+                }
                 return;
             }
             case 'webSearch':

package/dist/adapters/questions.js

@@ -110,6 +110,7 @@ const INVALIDATION_PHRASES = {
     turn_aborted: 'the turn was interrupted',
     agent_cancelled: 'the agent withdrew it',
     budget_spent: 'the session ran out of its allowed working time',
+    not_held: 'the agent no longer holds this question',
 };
 /** The question was taken away from the user — say why, never fake an answer. */
 export function invalidationMessage(reason) {

package/dist/adapters/types.d.ts

@@ -366,7 +366,16 @@ export interface AgentQuestionAnswer {
     notes?: string;
 }
 /** Why a question was taken away from the user without them answering it. */
-export type QuestionInvalidationReason = 'session_stopped' | 'session_parked' | 'runner_restarted' | 'turn_aborted' | 'agent_cancelled' | 'budget_spent';
+export type QuestionInvalidationReason = 'session_stopped' | 'session_parked' | 'runner_restarted' | 'turn_aborted' | 'agent_cancelled' | 'budget_spent'
+/**
+ * An answer arrived for a card no live process holds (#392): the card
+ * outlived the process that asked, or the ask was withdrawn before the
+ * answer got here. The runner does not know which, and says only what it
+ * does know. Never handed to an agent — there is no agent holding the ask
+ * to hand it to — so its phrase in `INVALIDATION_PHRASES` is for the type
+ * checker; the words a person reads are the dashboard's.
+ */
+ | 'not_held';
 /** The dashboard's answer to one open ask. */
 export interface QuestionReply {
     askId: string;
@@ -502,6 +511,38 @@ export type AgentEvent = {
     type: 'notice';
     level: 'info' | 'warn';
     text: string;
+}
+/**
+ * The conversation is being folded into a summary, or just was (#348).
+ *
+ * Its own event and not a `notice` on purpose: adapter notices are
+ * de-duplicated per session on their text (gotcha §148), so «Conversation
+ * compacted» reached the feed once and every later compaction was silence.
+ * A compaction is a fact the feed has to hear every time — the dashboard's
+ * «compacting…» indicator is read off the feed, and a second compaction
+ * with no lines is a second compaction the person cannot see end.
+ *
+ * `standalone` on the ending: `true` when NO turn is going to close behind
+ * this compaction, so the supervisor has to settle the session status
+ * itself. Codex runs a compaction started from the dashboard outside any
+ * turn (`thread/compact/start`); Claude delivers `/compact` as a turn, and
+ * that turn's own ending settles the status the ordinary way.
+ */
+ | {
+    type: 'compaction';
+    phase: 'started';
+} | {
+    type: 'compaction';
+    phase: 'finished';
+    ok: boolean;
+    error?: string;
+    standalone?: boolean;
+    /**
+     * It ended without a summary: the CLI decided not to compact after all
+     * (a PreCompact hook said no, or it found nothing worth folding). Not a
+     * failure — nothing broke — and not a compaction either.
+     */
+    skipped?: boolean;
 } | {
     type: 'cost';
     costUsd: number;

package/dist/journal.d.ts

@@ -58,6 +58,23 @@ export declare class SessionJournal {
         anchor: string;
         providerSessionId: string;
     } | null;
+    /**
+     * Every card this journal has published, and whether it is still open —
+     * in the order they were asked (#392).
+     *
+     * The persistent twin of the supervisor's `running.openQuestions`: that set
+     * dies with the process, and a process that dies ungracefully never gets to
+     * `shutdown()`, which is the only place it withdraws them. This one is
+     * rebuilt from the file, so the next process can close what the last one
+     * left open — the card in the browser does not know the runner restarted.
+     *
+     * Closed cards are remembered too, not only dropped: «this card was closed
+     * by somebody» is the fact that stops a SECOND tombstone. A queued answer
+     * that reaches the next process after a restore has already closed the card
+     * must rescue the words and say nothing more about the card — and the only
+     * witness that the card was closed is this file.
+     */
+    private readonly asks;
     constructor(sessionId: string, dir?: string);
     private replay;
     private write;
@@ -86,6 +103,29 @@ export declare class SessionJournal {
     recordStatus(status: string, extra?: Record<string, unknown>, epoch?: number): void;
     /** Assign the next seq and persist the event before it is sent. */
     append(eventType: string, payload: Record<string, unknown>): JournalEvent;
+    /**
+     * Keep `openAsks` in step with the cards going out through `append` (#392).
+     *
+     * Here and not in the supervisor, because `append` is the one door every
+     * event takes: a card that was published was published through it, and so
+     * was every resolution — the adapter's own, `withdrawOpenQuestions`, the
+     * `not_open` miss. A set kept beside the callers would need every one of
+     * them to remember it, which is exactly how the in-memory set came to be
+     * empty at the moment it was needed.
+     *
+     * A resolution for a card this journal never published writes nothing:
+     * there is nothing to close, and remembering strangers would only grow the
+     * file.
+     */
+    private trackAsk;
+    /** The cards still waiting on a person, oldest first (#392). */
+    openAskIds(): string[];
+    /**
+     * What this journal knows about one card (#392): `open`, `closed`, or
+     * nothing at all — a card asked by a runner from before these lines existed,
+     * or one this state directory never saw.
+     */
+    askState(askId: string): 'open' | 'closed' | undefined;
     /**
      * Never reuse a seq the API already stored: after a runner state-dir wipe the
      * local counter restarts at 1 and every replayed event would collide with an

package/dist/journal.js

@@ -21,6 +21,23 @@ export class SessionJournal {
     lastStatus = null;
     /** The agent's conversation tip, and the provider session it lives in. */
     lastAnchor = null;
+    /**
+     * Every card this journal has published, and whether it is still open —
+     * in the order they were asked (#392).
+     *
+     * The persistent twin of the supervisor's `running.openQuestions`: that set
+     * dies with the process, and a process that dies ungracefully never gets to
+     * `shutdown()`, which is the only place it withdraws them. This one is
+     * rebuilt from the file, so the next process can close what the last one
+     * left open — the card in the browser does not know the runner restarted.
+     *
+     * Closed cards are remembered too, not only dropped: «this card was closed
+     * by somebody» is the fact that stops a SECOND tombstone. A queued answer
+     * that reaches the next process after a restore has already closed the card
+     * must rescue the words and say nothing more about the card — and the only
+     * witness that the card was closed is this file.
+     */
+    asks = new Map();
     constructor(sessionId, dir = journalDir()) {
         this.sessionId = sessionId;
         fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
@@ -50,6 +67,16 @@ export class SessionJournal {
                 });
                 if (parsed.seq >= this.nextSeq)
                     this.nextSeq = parsed.seq + 1;
+                // The event lines carry the same fact as `ask_open`/`ask_closed`, and
+                // replaying both is harmless: the set is a set.
+                this.trackAsk(parsed.eventType, parsed.payload, false);
+            }
+            else if (parsed.kind === 'ask_open') {
+                if (this.asks.get(parsed.askId) !== 'closed')
+                    this.asks.set(parsed.askId, 'open');
+            }
+            else if (parsed.kind === 'ask_closed') {
+                this.asks.set(parsed.askId, 'closed');
             }
             else if (parsed.kind === 'ack') {
                 this.unackedBySeq.delete(parsed.seq);
@@ -107,6 +134,11 @@ export class SessionJournal {
         if (this.lastAnchor) {
             lines.push({ kind: 'anchor', ...this.lastAnchor });
         }
+        // AFTER the event lines: an unacked `question` re-written above would
+        // otherwise reopen, on the next replay, a card these lines say is closed.
+        for (const [askId, state] of this.asks) {
+            lines.push({ kind: state === 'open' ? 'ask_open' : 'ask_closed', askId });
+        }
         if (this.lastStatus) {
             lines.push({
                 kind: 'status',
@@ -182,8 +214,58 @@ export class SessionJournal {
         const event = { seq: this.nextSeq++, eventType, payload };
         this.write({ kind: 'event', ...event, ts: new Date().toISOString() });
         this.unackedBySeq.set(event.seq, event);
+        this.trackAsk(eventType, payload, true);
         return event;
     }
+    /**
+     * Keep `openAsks` in step with the cards going out through `append` (#392).
+     *
+     * Here and not in the supervisor, because `append` is the one door every
+     * event takes: a card that was published was published through it, and so
+     * was every resolution — the adapter's own, `withdrawOpenQuestions`, the
+     * `not_open` miss. A set kept beside the callers would need every one of
+     * them to remember it, which is exactly how the in-memory set came to be
+     * empty at the moment it was needed.
+     *
+     * A resolution for a card this journal never published writes nothing:
+     * there is nothing to close, and remembering strangers would only grow the
+     * file.
+     */
+    trackAsk(eventType, payload, persist) {
+        if (eventType !== 'question' && eventType !== 'question_resolved')
+            return;
+        const askId = payload['askId'];
+        if (typeof askId !== 'string' || !askId)
+            return;
+        const state = this.asks.get(askId);
+        if (eventType === 'question') {
+            // A card is asked once; a replayed event line for one already closed
+            // (compaction keeps unacked events) must not reopen it.
+            if (state !== undefined)
+                return;
+            this.asks.set(askId, 'open');
+            if (persist)
+                this.write({ kind: 'ask_open', askId });
+            return;
+        }
+        if (state !== 'open')
+            return;
+        this.asks.set(askId, 'closed');
+        if (persist)
+            this.write({ kind: 'ask_closed', askId });
+    }
+    /** The cards still waiting on a person, oldest first (#392). */
+    openAskIds() {
+        return [...this.asks].filter(([, state]) => state === 'open').map(([askId]) => askId);
+    }
+    /**
+     * What this journal knows about one card (#392): `open`, `closed`, or
+     * nothing at all — a card asked by a runner from before these lines existed,
+     * or one this state directory never saw.
+     */
+    askState(askId) {
+        return this.asks.get(askId);
+    }
     /**
      * Never reuse a seq the API already stored: after a runner state-dir wipe the
      * local counter restarts at 1 and every replayed event would collide with an

package/dist/protocol.d.ts

@@ -32,6 +32,20 @@ export declare const SessionDescriptorSchema: z.ZodObject<{
      * behaviour every runner had before this release.
      */
     pausedUntil: z.ZodCatch<z.ZodOptional<z.ZodNullable<z.ZodString>>>;
+    /**
+     * Subagents the API still believes to be alive in this session (#393).
+     *
+     * The number is the dead process's last word, kept by the API: a runner
+     * restart takes every subagent with it, and the new process seeds its own
+     * count at zero — so the descriptor is the only place the number survives
+     * long enough to be written down. The API sends it only while it still
+     * believes it (its own trust window on the count's age); absent or zero
+     * means «nothing to say», and a restore says nothing.
+     *
+     * `.catch(undefined)` like its neighbours: one malformed value must cost
+     * its own session a line at most, never the frame (QA-100 MAJOR-1).
+     */
+    backgroundTasks: z.ZodCatch<z.ZodOptional<z.ZodNumber>>;
     /**
      * The newest published version of THIS session's agent — Р13, §4.8.
      *
@@ -246,6 +260,7 @@ export declare const SessionDescriptorSchema: z.ZodObject<{
     } | undefined;
     workMode?: "DIRECT" | "BRANCH" | undefined;
     pausedUntil?: string | null | undefined;
+    backgroundTasks?: number | undefined;
     agentLatestVersion?: string | undefined;
     skipAgentPrompt?: boolean | undefined;
     branchHint?: string | undefined;
@@ -295,6 +310,7 @@ export declare const SessionDescriptorSchema: z.ZodObject<{
     activeMsBase?: number | undefined;
     extraBudgetMinutes?: number | null | undefined;
     pausedUntil?: unknown;
+    backgroundTasks?: unknown;
     agentLatestVersion?: unknown;
     skipAgentPrompt?: unknown;
     branchHint?: unknown;
@@ -450,6 +466,20 @@ export declare const GatewayFrameSchema: z.ZodDiscriminatedUnion<"type", [z.ZodO
          * behaviour every runner had before this release.
          */
         pausedUntil: z.ZodCatch<z.ZodOptional<z.ZodNullable<z.ZodString>>>;
+        /**
+         * Subagents the API still believes to be alive in this session (#393).
+         *
+         * The number is the dead process's last word, kept by the API: a runner
+         * restart takes every subagent with it, and the new process seeds its own
+         * count at zero — so the descriptor is the only place the number survives
+         * long enough to be written down. The API sends it only while it still
+         * believes it (its own trust window on the count's age); absent or zero
+         * means «nothing to say», and a restore says nothing.
+         *
+         * `.catch(undefined)` like its neighbours: one malformed value must cost
+         * its own session a line at most, never the frame (QA-100 MAJOR-1).
+         */
+        backgroundTasks: z.ZodCatch<z.ZodOptional<z.ZodNumber>>;
         /**
          * The newest published version of THIS session's agent — Р13, §4.8.
          *
@@ -664,6 +694,7 @@ export declare const GatewayFrameSchema: z.ZodDiscriminatedUnion<"type", [z.ZodO
         } | undefined;
         workMode?: "DIRECT" | "BRANCH" | undefined;
         pausedUntil?: string | null | undefined;
+        backgroundTasks?: number | undefined;
         agentLatestVersion?: string | undefined;
         skipAgentPrompt?: boolean | undefined;
         branchHint?: string | undefined;
@@ -713,6 +744,7 @@ export declare const GatewayFrameSchema: z.ZodDiscriminatedUnion<"type", [z.ZodO
         activeMsBase?: number | undefined;
         extraBudgetMinutes?: number | null | undefined;
         pausedUntil?: unknown;
+        backgroundTasks?: unknown;
         agentLatestVersion?: unknown;
         skipAgentPrompt?: unknown;
         branchHint?: unknown;
@@ -759,6 +791,7 @@ export declare const GatewayFrameSchema: z.ZodDiscriminatedUnion<"type", [z.ZodO
         } | undefined;
         workMode?: "DIRECT" | "BRANCH" | undefined;
         pausedUntil?: string | null | undefined;
+        backgroundTasks?: number | undefined;
         agentLatestVersion?: string | undefined;
         skipAgentPrompt?: boolean | undefined;
         branchHint?: string | undefined;
@@ -814,6 +847,7 @@ export declare const GatewayFrameSchema: z.ZodDiscriminatedUnion<"type", [z.ZodO
         activeMsBase?: number | undefined;
         extraBudgetMinutes?: number | null | undefined;
         pausedUntil?: unknown;
+        backgroundTasks?: unknown;
         agentLatestVersion?: unknown;
         skipAgentPrompt?: unknown;
         branchHint?: unknown;
@@ -883,6 +917,20 @@ export declare const GatewayFrameSchema: z.ZodDiscriminatedUnion<"type", [z.ZodO
          * behaviour every runner had before this release.
          */
         pausedUntil: z.ZodCatch<z.ZodOptional<z.ZodNullable<z.ZodString>>>;
+        /**
+         * Subagents the API still believes to be alive in this session (#393).
+         *
+         * The number is the dead process's last word, kept by the API: a runner
+         * restart takes every subagent with it, and the new process seeds its own
+         * count at zero — so the descriptor is the only place the number survives
+         * long enough to be written down. The API sends it only while it still
+         * believes it (its own trust window on the count's age); absent or zero
+         * means «nothing to say», and a restore says nothing.
+         *
+         * `.catch(undefined)` like its neighbours: one malformed value must cost
+         * its own session a line at most, never the frame (QA-100 MAJOR-1).
+         */
+        backgroundTasks: z.ZodCatch<z.ZodOptional<z.ZodNumber>>;
         /**
          * The newest published version of THIS session's agent — Р13, §4.8.
          *
@@ -1097,6 +1145,7 @@ export declare const GatewayFrameSchema: z.ZodDiscriminatedUnion<"type", [z.ZodO
         } | undefined;
         workMode?: "DIRECT" | "BRANCH" | undefined;
         pausedUntil?: string | null | undefined;
+        backgroundTasks?: number | undefined;
         agentLatestVersion?: string | undefined;
         skipAgentPrompt?: boolean | undefined;
         branchHint?: string | undefined;
@@ -1146,6 +1195,7 @@ export declare const GatewayFrameSchema: z.ZodDiscriminatedUnion<"type", [z.ZodO
         activeMsBase?: number | undefined;
         extraBudgetMinutes?: number | null | undefined;
         pausedUntil?: unknown;
+        backgroundTasks?: unknown;
         agentLatestVersion?: unknown;
         skipAgentPrompt?: unknown;
         branchHint?: unknown;
@@ -1192,6 +1242,7 @@ export declare const GatewayFrameSchema: z.ZodDiscriminatedUnion<"type", [z.ZodO
         } | undefined;
         workMode?: "DIRECT" | "BRANCH" | undefined;
         pausedUntil?: string | null | undefined;
+        backgroundTasks?: number | undefined;
         agentLatestVersion?: string | undefined;
         skipAgentPrompt?: boolean | undefined;
         branchHint?: string | undefined;
@@ -1244,6 +1295,7 @@ export declare const GatewayFrameSchema: z.ZodDiscriminatedUnion<"type", [z.ZodO
         activeMsBase?: number | undefined;
         extraBudgetMinutes?: number | null | undefined;
         pausedUntil?: unknown;
+        backgroundTasks?: unknown;
         agentLatestVersion?: unknown;
         skipAgentPrompt?: unknown;
         branchHint?: unknown;

package/dist/protocol.js

@@ -59,6 +59,20 @@ export const SessionDescriptorSchema = z.object({
      * behaviour every runner had before this release.
      */
     pausedUntil: z.string().max(40).nullable().optional().catch(undefined),
+    /**
+     * Subagents the API still believes to be alive in this session (#393).
+     *
+     * The number is the dead process's last word, kept by the API: a runner
+     * restart takes every subagent with it, and the new process seeds its own
+     * count at zero — so the descriptor is the only place the number survives
+     * long enough to be written down. The API sends it only while it still
+     * believes it (its own trust window on the count's age); absent or zero
+     * means «nothing to say», and a restore says nothing.
+     *
+     * `.catch(undefined)` like its neighbours: one malformed value must cost
+     * its own session a line at most, never the frame (QA-100 MAJOR-1).
+     */
+    backgroundTasks: z.number().int().min(0).optional().catch(undefined),
     /**
      * The newest published version of THIS session's agent — Р13, §4.8.
      *