@bridge4dev/runner 0.34.0 → 0.35.0

package/dist/adapters/codex.js

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

package/dist/index.js

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

package/dist/supervisor.d.ts

@@ -136,6 +136,20 @@ export declare class Supervisor {
      * refuse writes to it: in `workMode: DIRECT` the project folder is the
      * agent's own working directory, so without that rule a session could rewrite
      * the prompt it will itself be started with next time (QA-130 MAJOR-3).
+     *
+     * @param resuming This launch continues an existing agent conversation. It
+     *   changes only the WORDS, never the behaviour — and the words matter,
+     *   because a person who has just watched their session crash reads a second
+     *   «Project prompt loaded» as «my context was thrown away» (ticket #177).
+     *   Measured, so the line can say it plainly: a system prompt lives in the
+     *   agent PROCESS, not in the saved conversation. Resuming Claude Code
+     *   without re-supplying `--append-system-prompt` restores every message and
+     *   ZERO bytes of the appended prompt; re-supplying it restores the same
+     *   messages and exactly ONE copy of the prompt, never two. Codex is the same
+     *   fact by a different route — it rebuilds the developer message from the
+     *   current parameters on every request. So re-reading the file here is not
+     *   waste, and skipping it would silently strip the project's rules (and
+     *   DevBridge's own) from every session that ever resumed.
      */
     private resolveAgentPrompt;
     /** Warn the user when this share of the budget is gone. */

package/dist/supervisor.js

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

package/dist/version.d.ts

@@ -1,2 +1,2 @@
-export declare const RUNNER_VERSION = "0.34.0";
+export declare const RUNNER_VERSION = "0.35.0";
 //# sourceMappingURL=version.d.ts.map

package/dist/version.js

@@ -1,3 +1,3 @@
 // Kept in sync with package.json by the release script (manual for now).
-export const RUNNER_VERSION = '0.34.0';
+export const RUNNER_VERSION = '0.35.0';
 //# sourceMappingURL=version.js.map

package/package.json

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