@bridge4dev/runner 0.36.0 → 0.37.0

package/dist/index.js

@@ -389,6 +389,11 @@ function runnerCapabilities(apiUrlOverride) {
             'agent_prompt_state',
             'propose_commit_message',
             'recall_message',
+            // The answer to a parked question, as a command that ANSWERS rather than
+            // a frame written into a socket and hoped for. Announced here because
+            // this list is what `runCommand` actually dispatches on, and the API
+            // falls back to the old frame for runners that do not name it.
+            'answer_question',
             'compact_context',
             ...(checkpointsEnabled
                 ? [

package/dist/protocol.d.ts

@@ -272,6 +272,78 @@ export declare const SessionDescriptorSchema: z.ZodObject<{
     workMode?: unknown;
 }>;
 export type SessionDescriptor = z.infer<typeof SessionDescriptorSchema>;
+/**
+ * One human answer to a parked agent question, minus the session it belongs to.
+ *
+ * Written once and used twice on purpose: as the body of the `question_answer`
+ * frame every runner since 0.14 understands, and as the arguments of the
+ * `answer_question` COMMAND that replaced it (session 18). The two must not
+ * drift — an answer that the frame accepts and the command rejects would fail
+ * exactly on the machines whose connection is bad enough to need the command.
+ */
+export declare const QuestionAnswerShape: {
+    readonly askId: z.ZodString;
+    readonly action: z.ZodEnum<["answer", "discuss"]>;
+    readonly answers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        questionId: z.ZodString;
+        values: z.ZodArray<z.ZodString, "many">;
+        custom: z.ZodOptional<z.ZodString>;
+        notes: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        values: string[];
+        questionId: string;
+        custom?: string | undefined;
+        notes?: string | undefined;
+    }, {
+        values: string[];
+        questionId: string;
+        custom?: string | undefined;
+        notes?: string | undefined;
+    }>, "many">>;
+    readonly text: z.ZodOptional<z.ZodString>;
+};
+/** The `answer_question` command's arguments — the shape above on its own. */
+export declare const QuestionAnswerArgsSchema: z.ZodObject<{
+    readonly askId: z.ZodString;
+    readonly action: z.ZodEnum<["answer", "discuss"]>;
+    readonly answers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        questionId: z.ZodString;
+        values: z.ZodArray<z.ZodString, "many">;
+        custom: z.ZodOptional<z.ZodString>;
+        notes: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        values: string[];
+        questionId: string;
+        custom?: string | undefined;
+        notes?: string | undefined;
+    }, {
+        values: string[];
+        questionId: string;
+        custom?: string | undefined;
+        notes?: string | undefined;
+    }>, "many">>;
+    readonly text: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    askId: string;
+    action: "answer" | "discuss";
+    text?: string | undefined;
+    answers?: {
+        values: string[];
+        questionId: string;
+        custom?: string | undefined;
+        notes?: string | undefined;
+    }[] | undefined;
+}, {
+    askId: string;
+    action: "answer" | "discuss";
+    text?: string | undefined;
+    answers?: {
+        values: string[];
+        questionId: string;
+        custom?: string | undefined;
+        notes?: string | undefined;
+    }[] | undefined;
+}>;
 export declare const GatewayFrameSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
     type: z.ZodLiteral<"hello_ack">;
     serverId: z.ZodString;
@@ -1104,8 +1176,6 @@ export declare const GatewayFrameSchema: z.ZodDiscriminatedUnion<"type", [z.ZodO
     requestId: string;
     note?: string | undefined;
 }>, z.ZodObject<{
-    type: z.ZodLiteral<"question_answer">;
-    sessionId: z.ZodString;
     askId: z.ZodString;
     action: z.ZodEnum<["answer", "discuss"]>;
     answers: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -1125,6 +1195,8 @@ export declare const GatewayFrameSchema: z.ZodDiscriminatedUnion<"type", [z.ZodO
         notes?: string | undefined;
     }>, "many">>;
     text: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"question_answer">;
+    sessionId: z.ZodString;
 }, "strip", z.ZodTypeAny, {
     sessionId: string;
     type: "question_answer";

package/dist/protocol.js

@@ -183,6 +183,31 @@ export const SessionDescriptorSchema = z.object({
     // project). Preferred over the [mcp] section of config.toml when present.
     mcp: z.object({ url: z.string().url(), token: z.string().min(1) }).optional(),
 });
+/**
+ * One human answer to a parked agent question, minus the session it belongs to.
+ *
+ * Written once and used twice on purpose: as the body of the `question_answer`
+ * frame every runner since 0.14 understands, and as the arguments of the
+ * `answer_question` COMMAND that replaced it (session 18). The two must not
+ * drift — an answer that the frame accepts and the command rejects would fail
+ * exactly on the machines whose connection is bad enough to need the command.
+ */
+export const QuestionAnswerShape = {
+    askId: z.string().min(1).max(64),
+    action: z.enum(['answer', 'discuss']),
+    answers: z
+        .array(z.object({
+        questionId: z.string().min(1).max(120),
+        values: z.array(z.string().max(2_000)).max(16),
+        custom: z.string().max(10_000).optional(),
+        notes: z.string().max(2_000).optional(),
+    }))
+        .max(4)
+        .optional(),
+    text: z.string().max(20_000).optional(),
+};
+/** The `answer_question` command's arguments — the shape above on its own. */
+export const QuestionAnswerArgsSchema = z.object(QuestionAnswerShape);
 export const GatewayFrameSchema = z.discriminatedUnion('type', [
     z.object({
         type: z.literal('hello_ack'),
@@ -238,18 +263,7 @@ export const GatewayFrameSchema = z.discriminatedUnion('type', [
     z.object({
         type: z.literal('question_answer'),
         sessionId: z.string().uuid(),
-        askId: z.string().min(1).max(64),
-        action: z.enum(['answer', 'discuss']),
-        answers: z
-            .array(z.object({
-            questionId: z.string().min(1).max(120),
-            values: z.array(z.string().max(2_000)).max(16),
-            custom: z.string().max(10_000).optional(),
-            notes: z.string().max(2_000).optional(),
-        }))
-            .max(4)
-            .optional(),
-        text: z.string().max(20_000).optional(),
+        ...QuestionAnswerShape,
     }),
     z.object({ type: z.literal('session_stop'), sessionId: z.string().uuid() }),
     z.object({ type: z.literal('session_interrupt'), sessionId: z.string().uuid() }),

package/dist/supervisor.js

@@ -18,6 +18,7 @@ import { selfUpdate } from './self-update.js';
 import { rememberWorkspacePath } from './environment.js';
 import { composeMessageWithAttachments, saveAttachments, } from './attachments.js';
 import { applyRewind, createCheckpoint, dropCheckpoints, listCheckpoints, previewRewind, pruneCheckpoints, } from './checkpoints.js';
+import { QuestionAnswerArgsSchema } from './protocol.js';
 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)';
@@ -309,6 +310,7 @@ export class Supervisor {
             extraBudgetMinutes: descriptor.extraBudgetMinutes,
             epoch: descriptor.epoch,
             openQuestions: new Set(),
+            answeredAsks: new Set(),
             // Ticket #196: a pause is part of what a session IS, so it is read off
             // the descriptor rather than waiting for a frame. Without this a runner
             // that restarted mid-pause would come back knowing nothing and pick the
@@ -1471,8 +1473,13 @@ export class Supervisor {
         if (!running) {
             log.warn('supervisor: question answer for unknown session', { sessionId: frame.sessionId });
             this.ws.send({ type: 'session_unknown', sessionId: frame.sessionId });
-            return;
+            return 'unknown_session';
         }
+        // A redelivery of an answer this runner already took. Silence here is the
+        // point: the first copy did everything, and the second must not add a note,
+        // a message or a status report — see `answeredAsks`.
+        if (running.answeredAsks.has(frame.askId))
+            return 'duplicate';
         const typed = frame.text?.trim();
         // Asked first, echoed second: the adapter resolves synchronously but its
         // own events reach the feed a microtask later, so the user's words still
@@ -1485,12 +1492,17 @@ export class Supervisor {
             ...(frame.text !== undefined ? { text: frame.text } : {}),
         });
         if (accepted) {
+            running.answeredAsks.add(frame.askId);
             // What the user typed belongs in the conversation, whichever exit they took.
             if (typed)
                 this.sendEvent(running, 'message', { role: 'user', text: typed });
-            return;
+            return 'answered';
         }
         running.openQuestions.delete(frame.askId);
+        // Remembered even though it was a miss: whatever happened to the ask, the
+        // words below have now been published once, and a redelivery must not
+        // publish them again.
+        running.answeredAsks.add(frame.askId);
         this.sendEvent(running, 'system_note', {
             text: typed
                 ? 'That question is no longer open — sending your reply as an ordinary message instead.'
@@ -1505,11 +1517,12 @@ export class Supervisor {
                 sessionId: frame.sessionId,
                 error: String(error),
             }));
-            return;
+            return 'not_open';
         }
         // Nothing to deliver — but the API optimistically flipped the session to
         // RUNNING when it relayed the answer, so put the real status back.
         this.reportStatus(frame.sessionId, statusForReport(running), {});
+        return 'not_open';
     }
     async onUserMessage(sessionId, text, attachments) {
         const running = this.sessions.get(sessionId);
@@ -2258,6 +2271,7 @@ export class Supervisor {
                     extraBudgetMinutes: descriptor.extraBudgetMinutes,
                     epoch: descriptor.epoch,
                     openQuestions: new Set(),
+                    answeredAsks: new Set(),
                     ...pausedUntilOf(descriptor),
                     mode: descriptor.mode,
                     ...(descriptor.model ? { model: descriptor.model } : {}),
@@ -2457,6 +2471,39 @@ export class Supervisor {
                         ok: false,
                         error: 'reset_workspace is not supported by this runner version',
                     });
+                case 'answer_question': {
+                    // The same work as the `question_answer` frame, with one difference
+                    // that is the whole point: this one ANSWERS. The frame was
+                    // fire-and-forget, so the API called a write into a socket a delivery
+                    // — and a socket reports OPEN for up to three missed pongs after the
+                    // machine behind it has gone. An answer lost in that window took the
+                    // card with it for a day (2026-08-11).
+                    //
+                    // No `await` before the reply, for the same reason as `recall_message`
+                    // below: `onQuestionAnswer` is synchronous, and a yield here would let
+                    // a concurrent frame close the ask between the check and the answer.
+                    const sessionId = frame.sessionId;
+                    if (!sessionId)
+                        return void reply({ ok: false, error: 'sessionId is required' });
+                    const parsed = QuestionAnswerArgsSchema.safeParse(frame.args ?? {});
+                    if (!parsed.success) {
+                        return void reply({
+                            ok: false,
+                            error: parsed.error.issues[0]?.message ?? 'malformed answer',
+                        });
+                    }
+                    const outcome = this.onQuestionAnswer({
+                        type: 'question_answer',
+                        sessionId,
+                        ...parsed.data,
+                    });
+                    // `ok` is about the RELAY, not about the agent's luck: an answer for a
+                    // session this runner no longer holds is the one case the API can fix
+                    // by trying again later, so it is the one case reported as a failure.
+                    return void reply(outcome === 'unknown_session'
+                        ? { ok: false, error: 'Unknown session', result: { outcome } }
+                        : { ok: true, result: { outcome } });
+                }
                 case 'recall_message': {
                     // Ticket #125: take a queued message back before any agent sees it.
                     const sessionId = frame.sessionId;

package/dist/version.d.ts

@@ -1,2 +1,2 @@
-export declare const RUNNER_VERSION = "0.36.0";
+export declare const RUNNER_VERSION = "0.37.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.36.0';
+export const RUNNER_VERSION = '0.37.0';
 //# sourceMappingURL=version.js.map

package/package.json

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