@bridge4dev/runner 0.69.1 → 0.70.1

package/dist/index.js

@@ -397,6 +397,17 @@ function runnerCapabilities(apiUrlOverride) {
          * machine in the fleet is up to date.
          */
         agentOutsideFolder: true,
+        /**
+         * «Tell the agent who is writing»: the name the API attaches to a message
+         * (`author` on `deliver_message` and `session_message`, `promptAuthor` on
+         * the descriptor) goes on top of the agent's prompt, never into the feed.
+         *
+         * Announced for the settings card only, and as a warning rather than a
+         * refusal, like `agentOutsideFolder` above it: an older runner drops the
+         * field unread and the message still arrives — just unsigned — so a
+         * manager can record the decision before the last machine is current.
+         */
+        messageAuthors: true,
         /**
          * #137: this runner can read a repository that has no commits yet.
          *

package/dist/journal.d.ts

@@ -30,6 +30,13 @@ export interface PendingMessage {
      * those cannot be recalled, which is correct — they predate the feature.
      */
     seq?: number;
+    /**
+     * Who typed it, as DevBridge shows them — present only when the project has
+     * «Tell the agent who is writing» switched on. Held with the words so a
+     * message that waited out a restart is still signed for the agent when it
+     * finally goes (`message-author.ts`).
+     */
+    author?: string;
 }
 export interface PendingAttachment {
     id: string;
@@ -140,7 +147,7 @@ export declare class SessionJournal {
      * it is queued in memory, so the ordering is "on disk, then held" — a crash
      * between the two costs a duplicate delivery at worst, never a lost message.
      */
-    appendPending(text: string, attachments?: PendingAttachment[], seq?: number): PendingMessage;
+    appendPending(text: string, attachments?: PendingAttachment[], seq?: number, author?: string): PendingMessage;
     /** The message reached an agent — stop replaying it after a restart. */
     resolvePending(id: string): void;
     /**

package/dist/journal.js

@@ -97,6 +97,7 @@ export class SessionJournal {
                     text: parsed.text,
                     ...(parsed.attachments?.length ? { attachments: parsed.attachments } : {}),
                     ...(typeof parsed.seq === 'number' ? { seq: parsed.seq } : {}),
+                    ...(typeof parsed.author === 'string' ? { author: parsed.author } : {}),
                 });
                 // Ids are `p<n>`; keep the counter above whatever the file holds so a
                 // restarted runner cannot mint an id that is already in flight.
@@ -157,6 +158,7 @@ export class SessionJournal {
                 text: record.text,
                 ...(record.attachments?.length ? { attachments: record.attachments } : {}),
                 ...(record.seq === undefined ? {} : { seq: record.seq }),
+                ...(record.author === undefined ? {} : { author: record.author }),
                 ts: new Date().toISOString(),
             });
         }
@@ -294,13 +296,14 @@ export class SessionJournal {
      * it is queued in memory, so the ordering is "on disk, then held" — a crash
      * between the two costs a duplicate delivery at worst, never a lost message.
      */
-    appendPending(text, attachments, seq) {
+    appendPending(text, attachments, seq, author) {
         const id = `p${this.pendingCounter++}`;
         const record = {
             id,
             text,
             ...(attachments?.length ? { attachments } : {}),
             ...(seq === undefined ? {} : { seq }),
+            ...(author === undefined ? {} : { author }),
         };
         this.write({
             kind: 'pending',
@@ -308,6 +311,7 @@ export class SessionJournal {
             text,
             ...(attachments?.length ? { attachments } : {}),
             ...(seq === undefined ? {} : { seq }),
+            ...(author === undefined ? {} : { author }),
             ts: new Date().toISOString(),
         });
         this.pendingById.set(id, record);

package/dist/message-author.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Who typed this — for the agent, not for the feed.
+ *
+ * ## Why the agent needs it
+ *
+ * Several people write into one session: the developer, a colleague forwarding
+ * a client's email, the platform owner stepping in to help. The runner echoes
+ * every message into the feed as `role: 'user'` and the API stamps the author
+ * onto that echo for people to see — but the AGENT got the bare words, and
+ * could not tell one person from another. A project prompt that says «if Andy
+ * writes, do not start development — say you are waiting for Dima» had nothing
+ * to go on.
+ *
+ * ## What it is, and what it is not
+ *
+ * A line the platform puts on top of the composed prompt, named after the
+ * person as DevBridge shows them. The feed never sees it: `acceptUserMessage`
+ * echoes the text the person typed, and this runs on the way to the agent, the
+ * same place the attachment paths are added. It is a hint to the model, not an
+ * access control — the project's real permissions are its roles, and the line
+ * carries no authority of its own. The API decides per message whether to send
+ * a name at all (the project setting «Tell the agent who is writing»); the
+ * runner adds the line whenever one arrives and never invents one.
+ *
+ * The name comes off the wire and is treated as such: folded onto one line,
+ * trimmed, and an empty one means no line at all.
+ */
+export declare function signMessage(text: string, author: string | undefined): string;
+//# sourceMappingURL=message-author.d.ts.map

package/dist/message-author.js

@@ -0,0 +1,34 @@
+/**
+ * Who typed this — for the agent, not for the feed.
+ *
+ * ## Why the agent needs it
+ *
+ * Several people write into one session: the developer, a colleague forwarding
+ * a client's email, the platform owner stepping in to help. The runner echoes
+ * every message into the feed as `role: 'user'` and the API stamps the author
+ * onto that echo for people to see — but the AGENT got the bare words, and
+ * could not tell one person from another. A project prompt that says «if Andy
+ * writes, do not start development — say you are waiting for Dima» had nothing
+ * to go on.
+ *
+ * ## What it is, and what it is not
+ *
+ * A line the platform puts on top of the composed prompt, named after the
+ * person as DevBridge shows them. The feed never sees it: `acceptUserMessage`
+ * echoes the text the person typed, and this runs on the way to the agent, the
+ * same place the attachment paths are added. It is a hint to the model, not an
+ * access control — the project's real permissions are its roles, and the line
+ * carries no authority of its own. The API decides per message whether to send
+ * a name at all (the project setting «Tell the agent who is writing»); the
+ * runner adds the line whenever one arrives and never invents one.
+ *
+ * The name comes off the wire and is treated as such: folded onto one line,
+ * trimmed, and an empty one means no line at all.
+ */
+export function signMessage(text, author) {
+    const name = (author ?? '').replace(/\s+/g, ' ').trim();
+    if (name === '')
+        return text;
+    return `[Message from ${name}]\n\n${text}`;
+}
+//# sourceMappingURL=message-author.js.map

package/dist/protocol.d.ts

@@ -1,6 +1,12 @@
 import { z } from 'zod';
 import type { HostLoadFrame } from './host-load.js';
 import type { SessionLimitsFrame } from './session-limits.js';
+/**
+ * The longest name the wire accepts for «who typed this». A display name from a
+ * profile, not a document — anything longer is not a name, and the field is a
+ * nicety: over the limit it is dropped and the message goes on without it.
+ */
+export declare const MESSAGE_AUTHOR_MAX = 200;
 export declare const SessionDescriptorSchema: z.ZodObject<{
     id: z.ZodString;
     kind: z.ZodEnum<["TICKET", "CHAT"]>;
@@ -71,6 +77,18 @@ export declare const SessionDescriptorSchema: z.ZodObject<{
      * arrives as `undefined`, which is the same as «auto-update is off».
      */
     agentLatestVersion: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+    /**
+     * Who handed over the first message — the person who created the session, as
+     * DevBridge shows them. Sent only when the project has «Tell the agent who is
+     * writing» switched on and the prompt is not empty; `composeInitialPrompt`
+     * puts the name on top of the whole first message (`message-author.ts`).
+     *
+     * Optional, and absent means «no name»: an older API never sends it, and a
+     * project with the setting off gets exactly the first message it always had.
+     * `.catch(undefined)` like its neighbours — a bad value costs the signature,
+     * never the descriptor, never the `hello_ack` it rides in (QA-100 MAJOR-1).
+     */
+    promptAuthor: z.ZodCatch<z.ZodOptional<z.ZodString>>;
     workspace: z.ZodObject<{
         id: z.ZodString;
         path: z.ZodString;
@@ -277,6 +295,7 @@ export declare const SessionDescriptorSchema: z.ZodObject<{
     pausedUntil?: string | null | undefined;
     backgroundTasks?: number | undefined;
     agentLatestVersion?: string | undefined;
+    promptAuthor?: string | undefined;
     skipAgentPrompt?: boolean | undefined;
     branchHint?: string | undefined;
     branchPlan?: {
@@ -328,6 +347,7 @@ export declare const SessionDescriptorSchema: z.ZodObject<{
     pausedUntil?: unknown;
     backgroundTasks?: unknown;
     agentLatestVersion?: unknown;
+    promptAuthor?: unknown;
     skipAgentPrompt?: unknown;
     branchHint?: unknown;
     branchPlan?: unknown;
@@ -362,6 +382,14 @@ export declare const QuestionAnswerShape: {
         notes?: string | undefined;
     }>, "many">>;
     readonly text: z.ZodOptional<z.ZodString>;
+    /**
+     * Who typed `text` — sent only when the project has «Tell the agent who is
+     * writing» on. Signs the free text of a «discuss» reply (words a person typed
+     * into an open card are a message like any other) and the words rescued when
+     * the card turns out to be dead; a pick stays a pick. `.catch(undefined)`
+     * like the message author: a bad name costs the signature, not the answer.
+     */
+    readonly author: z.ZodCatch<z.ZodOptional<z.ZodString>>;
 };
 /** The `answer_question` command's arguments — the shape above on its own. */
 export declare const QuestionAnswerArgsSchema: z.ZodObject<{
@@ -384,10 +412,19 @@ export declare const QuestionAnswerArgsSchema: z.ZodObject<{
         notes?: string | undefined;
     }>, "many">>;
     readonly text: z.ZodOptional<z.ZodString>;
+    /**
+     * Who typed `text` — sent only when the project has «Tell the agent who is
+     * writing» on. Signs the free text of a «discuss» reply (words a person typed
+     * into an open card are a message like any other) and the words rescued when
+     * the card turns out to be dead; a pick stays a pick. `.catch(undefined)`
+     * like the message author: a bad name costs the signature, not the answer.
+     */
+    readonly author: z.ZodCatch<z.ZodOptional<z.ZodString>>;
 }, "strip", z.ZodTypeAny, {
     action: "answer" | "discuss";
     askId: string;
     text?: string | undefined;
+    author?: string | undefined;
     answers?: {
         values: string[];
         questionId: string;
@@ -398,6 +435,7 @@ export declare const QuestionAnswerArgsSchema: z.ZodObject<{
     action: "answer" | "discuss";
     askId: string;
     text?: string | undefined;
+    author?: unknown;
     answers?: {
         values: string[];
         questionId: string;
@@ -432,9 +470,18 @@ export declare const DeliverMessageArgsSchema: z.ZodObject<{
         mimeType: string;
         fileSize: number;
     }>, "many">>>;
+    /**
+     * Who typed it, as DevBridge shows them — present only when the project has
+     * «Tell the agent who is writing» switched on. Goes on top of the composed
+     * prompt (`message-author.ts`), never into the feed echo. `.catch(undefined)`
+     * for the same reason attachments have it: a malformed name must cost the
+     * signature, never the sentence the person typed.
+     */
+    author: z.ZodCatch<z.ZodOptional<z.ZodString>>;
 }, "strip", z.ZodTypeAny, {
     text: string;
     messageId: string;
+    author?: string | undefined;
     attachments?: {
         id: string;
         fileName: string;
@@ -444,6 +491,7 @@ export declare const DeliverMessageArgsSchema: z.ZodObject<{
 }, {
     text: string;
     messageId: string;
+    author?: unknown;
     attachments?: unknown;
 }>;
 export declare const GatewayFrameSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
@@ -521,6 +569,18 @@ export declare const GatewayFrameSchema: z.ZodDiscriminatedUnion<"type", [z.ZodO
          * arrives as `undefined`, which is the same as «auto-update is off».
          */
         agentLatestVersion: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+        /**
+         * Who handed over the first message — the person who created the session, as
+         * DevBridge shows them. Sent only when the project has «Tell the agent who is
+         * writing» switched on and the prompt is not empty; `composeInitialPrompt`
+         * puts the name on top of the whole first message (`message-author.ts`).
+         *
+         * Optional, and absent means «no name»: an older API never sends it, and a
+         * project with the setting off gets exactly the first message it always had.
+         * `.catch(undefined)` like its neighbours — a bad value costs the signature,
+         * never the descriptor, never the `hello_ack` it rides in (QA-100 MAJOR-1).
+         */
+        promptAuthor: z.ZodCatch<z.ZodOptional<z.ZodString>>;
         workspace: z.ZodObject<{
             id: z.ZodString;
             path: z.ZodString;
@@ -727,6 +787,7 @@ export declare const GatewayFrameSchema: z.ZodDiscriminatedUnion<"type", [z.ZodO
         pausedUntil?: string | null | undefined;
         backgroundTasks?: number | undefined;
         agentLatestVersion?: string | undefined;
+        promptAuthor?: string | undefined;
         skipAgentPrompt?: boolean | undefined;
         branchHint?: string | undefined;
         branchPlan?: {
@@ -778,6 +839,7 @@ export declare const GatewayFrameSchema: z.ZodDiscriminatedUnion<"type", [z.ZodO
         pausedUntil?: unknown;
         backgroundTasks?: unknown;
         agentLatestVersion?: unknown;
+        promptAuthor?: unknown;
         skipAgentPrompt?: unknown;
         branchHint?: unknown;
         branchPlan?: unknown;
@@ -827,6 +889,7 @@ export declare const GatewayFrameSchema: z.ZodDiscriminatedUnion<"type", [z.ZodO
         pausedUntil?: string | null | undefined;
         backgroundTasks?: number | undefined;
         agentLatestVersion?: string | undefined;
+        promptAuthor?: string | undefined;
         skipAgentPrompt?: boolean | undefined;
         branchHint?: string | undefined;
         branchPlan?: {
@@ -884,6 +947,7 @@ export declare const GatewayFrameSchema: z.ZodDiscriminatedUnion<"type", [z.ZodO
         pausedUntil?: unknown;
         backgroundTasks?: unknown;
         agentLatestVersion?: unknown;
+        promptAuthor?: unknown;
         skipAgentPrompt?: unknown;
         branchHint?: unknown;
         branchPlan?: unknown;
@@ -990,6 +1054,18 @@ export declare const GatewayFrameSchema: z.ZodDiscriminatedUnion<"type", [z.ZodO
          * arrives as `undefined`, which is the same as «auto-update is off».
          */
         agentLatestVersion: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+        /**
+         * Who handed over the first message — the person who created the session, as
+         * DevBridge shows them. Sent only when the project has «Tell the agent who is
+         * writing» switched on and the prompt is not empty; `composeInitialPrompt`
+         * puts the name on top of the whole first message (`message-author.ts`).
+         *
+         * Optional, and absent means «no name»: an older API never sends it, and a
+         * project with the setting off gets exactly the first message it always had.
+         * `.catch(undefined)` like its neighbours — a bad value costs the signature,
+         * never the descriptor, never the `hello_ack` it rides in (QA-100 MAJOR-1).
+         */
+        promptAuthor: z.ZodCatch<z.ZodOptional<z.ZodString>>;
         workspace: z.ZodObject<{
             id: z.ZodString;
             path: z.ZodString;
@@ -1196,6 +1272,7 @@ export declare const GatewayFrameSchema: z.ZodDiscriminatedUnion<"type", [z.ZodO
         pausedUntil?: string | null | undefined;
         backgroundTasks?: number | undefined;
         agentLatestVersion?: string | undefined;
+        promptAuthor?: string | undefined;
         skipAgentPrompt?: boolean | undefined;
         branchHint?: string | undefined;
         branchPlan?: {
@@ -1247,6 +1324,7 @@ export declare const GatewayFrameSchema: z.ZodDiscriminatedUnion<"type", [z.ZodO
         pausedUntil?: unknown;
         backgroundTasks?: unknown;
         agentLatestVersion?: unknown;
+        promptAuthor?: unknown;
         skipAgentPrompt?: unknown;
         branchHint?: unknown;
         branchPlan?: unknown;
@@ -1295,6 +1373,7 @@ export declare const GatewayFrameSchema: z.ZodDiscriminatedUnion<"type", [z.ZodO
         pausedUntil?: string | null | undefined;
         backgroundTasks?: number | undefined;
         agentLatestVersion?: string | undefined;
+        promptAuthor?: string | undefined;
         skipAgentPrompt?: boolean | undefined;
         branchHint?: string | undefined;
         branchPlan?: {
@@ -1349,6 +1428,7 @@ export declare const GatewayFrameSchema: z.ZodDiscriminatedUnion<"type", [z.ZodO
         pausedUntil?: unknown;
         backgroundTasks?: unknown;
         agentLatestVersion?: unknown;
+        promptAuthor?: unknown;
         skipAgentPrompt?: unknown;
         branchHint?: unknown;
         branchPlan?: unknown;
@@ -1380,10 +1460,12 @@ export declare const GatewayFrameSchema: z.ZodDiscriminatedUnion<"type", [z.ZodO
         mimeType: string;
         fileSize: number;
     }>, "many">>>;
+    author: z.ZodCatch<z.ZodOptional<z.ZodString>>;
 }, "strip", z.ZodTypeAny, {
     text: string;
     sessionId: string;
     type: "session_message";
+    author?: string | undefined;
     attachments?: {
         id: string;
         fileName: string;
@@ -1395,6 +1477,7 @@ export declare const GatewayFrameSchema: z.ZodDiscriminatedUnion<"type", [z.ZodO
     text: string;
     sessionId: string;
     type: "session_message";
+    author?: unknown;
     attachments?: unknown;
     messageId?: unknown;
 }>, z.ZodObject<{
@@ -1435,6 +1518,7 @@ export declare const GatewayFrameSchema: z.ZodDiscriminatedUnion<"type", [z.ZodO
         notes?: string | undefined;
     }>, "many">>;
     text: z.ZodOptional<z.ZodString>;
+    author: z.ZodCatch<z.ZodOptional<z.ZodString>>;
     type: z.ZodLiteral<"question_answer">;
     sessionId: z.ZodString;
 }, "strip", z.ZodTypeAny, {
@@ -1443,6 +1527,7 @@ export declare const GatewayFrameSchema: z.ZodDiscriminatedUnion<"type", [z.ZodO
     action: "answer" | "discuss";
     askId: string;
     text?: string | undefined;
+    author?: string | undefined;
     answers?: {
         values: string[];
         questionId: string;
@@ -1455,6 +1540,7 @@ export declare const GatewayFrameSchema: z.ZodDiscriminatedUnion<"type", [z.ZodO
     action: "answer" | "discuss";
     askId: string;
     text?: string | undefined;
+    author?: unknown;
     answers?: {
         values: string[];
         questionId: string;

package/dist/protocol.js

@@ -3,6 +3,12 @@ import { AGENT_DB_VALUES, AGENT_VERSION_PATTERN } from './agent-registry.js';
 // Wire protocol with the DevBridge API (mirror of
 // packages/api/src/modules/dev-orchestration/dev-orchestration.schema.ts —
 // the API side is the source of truth).
+/**
+ * The longest name the wire accepts for «who typed this». A display name from a
+ * profile, not a document — anything longer is not a name, and the field is a
+ * nicety: over the limit it is dropped and the message goes on without it.
+ */
+export const MESSAGE_AUTHOR_MAX = 200;
 export const SessionDescriptorSchema = z.object({
     id: z.string().uuid(),
     kind: z.enum(['TICKET', 'CHAT']),
@@ -102,6 +108,18 @@ export const SessionDescriptorSchema = z.object({
         .regex(new RegExp(AGENT_VERSION_PATTERN))
         .optional()
         .catch(undefined),
+    /**
+     * Who handed over the first message — the person who created the session, as
+     * DevBridge shows them. Sent only when the project has «Tell the agent who is
+     * writing» switched on and the prompt is not empty; `composeInitialPrompt`
+     * puts the name on top of the whole first message (`message-author.ts`).
+     *
+     * Optional, and absent means «no name»: an older API never sends it, and a
+     * project with the setting off gets exactly the first message it always had.
+     * `.catch(undefined)` like its neighbours — a bad value costs the signature,
+     * never the descriptor, never the `hello_ack` it rides in (QA-100 MAJOR-1).
+     */
+    promptAuthor: z.string().max(MESSAGE_AUTHOR_MAX).optional().catch(undefined),
     workspace: z.object({
         id: z.string().uuid(),
         path: z.string(),
@@ -263,6 +281,14 @@ export const QuestionAnswerShape = {
         .max(4)
         .optional(),
     text: z.string().max(20_000).optional(),
+    /**
+     * Who typed `text` — sent only when the project has «Tell the agent who is
+     * writing» on. Signs the free text of a «discuss» reply (words a person typed
+     * into an open card are a message like any other) and the words rescued when
+     * the card turns out to be dead; a pick stays a pick. `.catch(undefined)`
+     * like the message author: a bad name costs the signature, not the answer.
+     */
+    author: z.string().max(MESSAGE_AUTHOR_MAX).optional().catch(undefined),
 };
 /** The `answer_question` command's arguments — the shape above on its own. */
 export const QuestionAnswerArgsSchema = z.object(QuestionAnswerShape);
@@ -295,6 +321,14 @@ export const DeliverMessageArgsSchema = z.object({
     messageId: z.string().min(1).max(120),
     text: z.string(),
     attachments: MessageAttachmentsSchema,
+    /**
+     * Who typed it, as DevBridge shows them — present only when the project has
+     * «Tell the agent who is writing» switched on. Goes on top of the composed
+     * prompt (`message-author.ts`), never into the feed echo. `.catch(undefined)`
+     * for the same reason attachments have it: a malformed name must cost the
+     * signature, never the sentence the person typed.
+     */
+    author: z.string().max(MESSAGE_AUTHOR_MAX).optional().catch(undefined),
 });
 export const GatewayFrameSchema = z.discriminatedUnion('type', [
     z.object({
@@ -334,6 +368,10 @@ export const GatewayFrameSchema = z.discriminatedUnion('type', [
         // fetched with the runner's own token. `.catch` so a malformed entry costs
         // the attachments, never the message the user typed.
         attachments: MessageAttachmentsSchema,
+        // Who typed it — the same field `deliver_message` carries, on the legacy
+        // door too, so a project with the setting on is not silently unsigned on
+        // an API that still sends the frame.
+        author: z.string().max(MESSAGE_AUTHOR_MAX).optional().catch(undefined),
     }),
     z.object({
         type: z.literal('permission_answer'),

package/dist/supervisor.js

@@ -35,6 +35,7 @@ import { countRunningCommands, freshStallState, pickKillCandidate, readScopeProc
 import { machineReserveBytes } from './service-unit.js';
 import { sessionLimitsChangedEnough, sessionLimitsHeartbeatDue, SESSION_LIMITS_HEARTBEAT_MS, } from './session-limits.js';
 import { composeMessageWithAttachments, saveAttachments, } from './attachments.js';
+import { signMessage } from './message-author.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';
@@ -1828,7 +1829,7 @@ export class Supervisor {
                 // command yet. Its outcome goes nowhere because nobody is listening —
                 // which is the whole defect ticket #299 is about, and why the command
                 // below exists.
-                this.acceptUserMessage(frame.sessionId, frame.text, frame.attachments, frame.messageId ?? undefined);
+                this.acceptUserMessage(frame.sessionId, frame.text, frame.attachments, frame.messageId ?? undefined, frame.author);
                 break;
             case 'permission_answer': {
                 const running = this.sessions.get(frame.sessionId);
@@ -1914,6 +1915,16 @@ export class Supervisor {
                 existing.stopRequested = true;
                 existing.session?.stop('session_stopped');
             }
+            // The descriptor also knows the feed better than this life does (#472).
+            // The API writes lines of its own into a feed this runner numbers: the
+            // refusal service puts «Continuing the session by itself» at the next
+            // free seq and resumes a moment later, while this life is still going
+            // down. The words that come with the resume are echoed by THIS life, and
+            // its counter knew nothing of that line – the echo reused its number and
+            // the API dropped it as a duplicate. Before the `await` below: the words
+            // arrive right behind this frame. A no-op whenever this runner wrote the
+            // last row itself.
+            existing.journal.ensureSeqAbove(descriptor.lastSeq);
             // The descriptor is newer than what this session was built from, so its
             // clock is too (QA-149 MAJOR-1). Applied on the way out of every early
             // return, not just the reconnect one — a descriptor re-sent for any
@@ -2021,7 +2032,7 @@ export class Supervisor {
         if (orphaned) {
             this.orphanMessages.delete(descriptor.id);
             for (const message of orphaned) {
-                this.acceptUserMessage(descriptor.id, message.text, message.attachments, message.messageId);
+                this.acceptUserMessage(descriptor.id, message.text, message.attachments, message.messageId, message.author);
             }
         }
         try {
@@ -2935,9 +2946,18 @@ export class Supervisor {
         }
         // Keep the journal while offline: the recorded terminal status is what
         // reconcile replays after the next reconnect (QA-96 F1).
+        //
+        // …and while a resume is queued behind this life (#472). The next life
+        // opens this same journal, and two things it needs live only here: the
+        // words parked for it (`acceptUserMessage` holds a message that reached a
+        // life already on its way out) and the seq counter. Deleted, the resume
+        // started from an empty file – the platform's «continue» after a refusal
+        // was gone, and «Session resumed» reused a seq the old life had already
+        // sent, so the API dropped it. The session sat idle with nothing on screen.
         if (this.ws.connected &&
             running.journal.unacked().length === 0 &&
-            isTerminal(running.lastReported)) {
+            isTerminal(running.lastReported) &&
+            !running.pendingRestart) {
             this.journals.closeAndDelete(descriptor.id);
         }
         // The map just lost an entry, and this is the one place where that happens
@@ -4293,11 +4313,18 @@ export class Supervisor {
         // own events reach the feed a microtask later, so the user's words still
         // land before the agent's reaction — and on a miss we can hand the text to
         // the ordinary delivery path, which does the echo itself.
+        //
+        // The free text of a «discuss» reply is a person's message like any other,
+        // so it is signed for the agent the way `acceptUserMessage` signs one
+        // (`message-author.ts`) — and only for the agent: the echo below stays the
+        // words as typed. A pick (`answer`) is structured and gets no line.
         const accepted = running.session?.answerQuestion({
             askId: frame.askId,
             action: frame.action,
             ...(frame.answers ? { answers: frame.answers } : {}),
-            ...(frame.text !== undefined ? { text: frame.text } : {}),
+            ...(frame.text !== undefined
+                ? { text: frame.action === 'discuss' ? signMessage(frame.text, frame.author) : frame.text }
+                : {}),
         });
         if (accepted) {
             running.answeredAsks.add(frame.askId);
@@ -4372,7 +4399,7 @@ export class Supervisor {
             this.sendEvent(running, 'system_note', {
                 text: 'That question is no longer open — sending your reply as an ordinary message instead.',
             });
-            this.acceptUserMessage(frame.sessionId, rescued);
+            this.acceptUserMessage(frame.sessionId, rescued, undefined, undefined, frame.author);
             return 'not_open';
         }
         // Nothing to deliver — but the API optimistically flipped the session to
@@ -4395,7 +4422,14 @@ export class Supervisor {
      * thrown away, because «I wrote it into a socket» was never an answer to
      * «did the runner get it».
      */
-    acceptUserMessage(sessionId, text, attachments, messageId) {
+    acceptUserMessage(sessionId, text, attachments, messageId, 
+    /**
+     * Who typed it, as DevBridge shows them — sent only when the project has
+     * «Tell the agent who is writing» on. Goes on top of the COMPOSED prompt
+     * (`message-author.ts`), the way attachment paths do; the feed echo below
+     * stays the bare text, exactly as the person wrote it.
+     */
+    author) {
         const running = this.sessions.get(sessionId);
         if (!running) {
             // The API believes this session lives here but the runner lost track of
@@ -4417,6 +4451,7 @@ export class Supervisor {
                 text,
                 ...(attachments?.length ? { attachments } : {}),
                 ...(messageId ? { messageId } : {}),
+                ...(author ? { author } : {}),
             });
             this.orphanMessages.set(sessionId, queued.slice(-Supervisor.ORPHAN_MESSAGE_CAP));
             this.ws.send({ type: 'session_unknown', sessionId });
@@ -4483,17 +4518,17 @@ export class Supervisor {
             // check — the outbox flushes on reconnect, and the git service posts its
             // own conflict tasks. Held here rather than delivered, so «на паузе»
             // means the same thing whichever door the words came through.
-            this.queueMessage(running, running.journal.appendPending(text, attachments, originSeq));
+            this.queueMessage(running, running.journal.appendPending(text, attachments, originSeq, author));
             return 'accepted';
         }
         this.enqueueDelivery(running, async () => {
-            const composed = await this.materializeAttachments(running, text, attachments);
+            const composed = signMessage(await this.materializeAttachments(running, text, attachments), author);
             if (this.isStale(running)) {
                 // The session ended while the files downloaded. Park the message on
                 // disk rather than dropping it — «Продолжить» carries it to the agent.
                 // Announced like every other queueing decision: a bubble that is
                 // waiting must say so, whichever door it came through.
-                const parked = running.journal.appendPending(text, attachments, originSeq);
+                const parked = running.journal.appendPending(text, attachments, originSeq, author);
                 if (parked.seq !== undefined) {
                     this.sendEvent(running, 'message_queued', { targetSeq: parked.seq });
                 }
@@ -5077,7 +5112,10 @@ export class Supervisor {
             const parts = [];
             try {
                 for (const record of pending) {
-                    parts.push(await this.materializeAttachments(running, record.text, record.attachments));
+                    // Each part under its own name: two people who wrote while the
+                    // session was held go to the agent together, and the agent must
+                    // still be able to tell which words are whose.
+                    parts.push(signMessage(await this.materializeAttachments(running, record.text, record.attachments), record.author));
                 }
             }
             catch (error) {
@@ -6507,7 +6545,7 @@ export class Supervisor {
                             error: parsed.error.issues[0]?.message ?? 'malformed message',
                         });
                     }
-                    const outcome = this.acceptUserMessage(sessionId, parsed.data.text, parsed.data.attachments, parsed.data.messageId);
+                    const outcome = this.acceptUserMessage(sessionId, parsed.data.text, parsed.data.attachments, parsed.data.messageId, parsed.data.author);
                     // `ok` is about the RELAY, like the answer above: `unknown_session` is
                     // the one case the API can fix by asking again after it has re-sent
                     // the descriptor, so it is the one case reported as a failure.
@@ -8219,6 +8257,15 @@ export function carryOnMessage(refusedWhole) {
  * prompt beside `CLAUDE.md` — which is read last and therefore overrides ours.
  */
 export function composeInitialPrompt(descriptor) {
+    const body = composeInitialBody(descriptor);
+    // Signed like every later message (`message-author.ts`): the API names the
+    // creator only when the project has «Tell the agent who is writing» on. The
+    // name goes above the assignment too — handing a ticket over is that
+    // person's act. An empty first message stays empty: there is nothing to sign
+    // and the agent is meant to boot and wait.
+    return body === '' ? body : signMessage(body, descriptor.promptAuthor);
+}
+function composeInitialBody(descriptor) {
     // A free chat may carry tickets as CONTEXT. Assigning them would put an agent
     // nobody asked onto somebody else's ticket (session 13).
     if (descriptor.kind === 'CHAT' || descriptor.tickets.length === 0)

package/dist/version.d.ts

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

package/package.json

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