agent-relay-runner 0.63.1 → 0.64.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-relay-runner",
-  "version": "0.63.1",
+  "version": "0.64.0",
   "description": "Unified provider lifecycle runner for Agent Relay",
   "type": "module",
   "bin": {

package/plugins/claude/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "agent-relay-runner",
   "description": "Thin Agent Relay runner bridge for Claude Code",
-  "version": "0.63.1",
+  "version": "0.64.0",
   "agentRelayContracts": {
     "providerPluginProtocol": 1
   }

package/src/adapters/claude-transcript.ts

@@ -202,6 +202,40 @@ export function extractFinalAssistantMessage(jsonl: string): string {
   return lastText.trim();
 }
 
+/**
+ * Like extractFinalAssistantMessage but skips the first `afterEntry` valid JSON
+ * entries. Used when a PreToolUse pre-flush already emitted the text before a
+ * blocking control, so final-mode Stop capture only sees later assistant text.
+ */
+export function extractFinalAssistantMessageAfterEntry(jsonl: string, afterEntry: number): string {
+  const lines = jsonl.split("\n");
+  let lastText = "";
+  let pastLastUserPrompt = afterEntry > 0;
+  let entryIndex = 0;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    let entry: TranscriptEntry;
+    try {
+      entry = JSON.parse(trimmed) as TranscriptEntry;
+    } catch {
+      continue;
+    }
+    entryIndex++;
+    if (isSidechainEntry(entry)) continue;
+    if (entryIndex <= afterEntry) continue;
+    if (isRealUserPrompt(entry)) {
+      pastLastUserPrompt = true;
+      lastText = "";
+      continue;
+    }
+    if (!pastLastUserPrompt) continue;
+    const text = assistantText(entry);
+    if (text) lastText = text;
+  }
+  return lastText.trim();
+}
+
 /**
  * Extract text from the `last_assistant_message` field in the Stop hook
  * payload. This is the content of the final assistant message — either a plain

package/src/runner-core.ts

@@ -12,7 +12,7 @@ import { ClaimTracker } from "./claim-tracker";
 import { startControlServer, type ControlServer } from "./control-server";
 import { ReplyObligationCache, obligationRequiresExplicitReply } from "./reply-obligation-cache";
 import { Outbox, type OutboxRecord } from "./outbox";
-import { extractLastAssistantTurn, extractLastAssistantTurnAfterEntry, countTranscriptEntries, extractFinalAssistantMessage, extractHookAssistantMessage, extractLatestTurnSteps, stepDedupKeys, transcriptLooksComplete } from "./adapters/claude-transcript";
+import { extractLastAssistantTurn, extractLastAssistantTurnAfterEntry, countTranscriptEntries, extractFinalAssistantMessage, extractFinalAssistantMessageAfterEntry, extractHookAssistantMessage, extractLatestTurnSteps, stepDedupKeys, transcriptLooksComplete } from "./adapters/claude-transcript";
 import { profileUsesHostProviderGlobals } from "./profile-home";
 import { RELAY_MCP_TOKEN_ENV, relayMcpEndpoint } from "./relay-mcp";
 import { RelayMcpProxy } from "./relay-mcp-proxy";
@@ -1306,10 +1306,9 @@ export class AgentRunner {
   // no relay message) are mirrored too. A reply obligation, when present, is still
   // used as replyTo so the Stop hook stops nagging the agent to /reply.
   //
-  // isPreFlush: true (#435) — mid-turn call from a PreToolUse hook (AskUserQuestion /
-  // ExitPlanMode / permission). Emits any un-mirrored narrative from the transcript
-  // tail immediately, before the interactive form appears in chat, then updates the
-  // entry-count cursor so the eventual Stop-hook call (full mode) skips it.
+  // isPreFlush: true (#435/#499) — mid-turn PreToolUse boundary. Drain the live
+  // tail and force-flush session messages before showing the blocking control;
+  // the entry cursor lets Stop capture skip already-emitted text.
   private async publishSessionTurn(input: { transcriptPath: string; lastAssistantMessage?: unknown; isPreFlush?: boolean }): Promise<void> {
     if (input.transcriptPath) this.lastTranscriptPath = input.transcriptPath;
 
@@ -1321,15 +1320,12 @@ export class AgentRunner {
       const body = extractLastAssistantTurnAfterEntry(jsonl, this.narrativeFlushEntryCount);
       await this.drainReasoningTail();
       this.narrativeFlushEntryCount = countTranscriptEntries(jsonl);
-      if (!body || this.preFlushBodyAlreadyMirroredByReasoningTail(jsonl, body)) return;
-      const turnId = this.currentTurnId;
-      this.sessionLog(`pre-flush narrative for turn ${turnId ?? "?"} (${body.length} chars)`);
-      await this.publishSessionEvent({
-        from: this.agentId,
-        to: "user",
-        body,
-        session: { type: "response", origin: "provider", ...(turnId ? { turnId } : {}) },
-      });
+      if (body && !this.preFlushBodyAlreadyMirroredByReasoningTail(jsonl, body)) {
+        const turnId = this.currentTurnId;
+        this.sessionLog(`pre-flush narrative for turn ${turnId ?? "?"} (${body.length} chars)`);
+        await this.publishSessionEvent({ from: this.agentId, to: "user", body, session: { type: "response", origin: "provider", ...(turnId ? { turnId } : {}) } });
+      }
+      await this.sessionOutbox.flush(2_000).then((ok) => { if (!ok) this.sessionLog(`pre-flush session outbox incomplete before blocking control (${this.sessionOutbox.pendingCount()} pending)`); }, (error) => this.sessionLog(`pre-flush session outbox failed before blocking control: ${errMessage(error)}`));
       return;
     }
 
@@ -1368,11 +1364,10 @@ export class AgentRunner {
           try { jsonl = await readFile(input.transcriptPath, "utf8"); } catch { break; }
         }
         if (!transcriptLooksComplete(jsonl)) continue;
-        // Full mode: if a pre-flush already emitted entries 1..flushCount, only
-        // collect text from entries after that mark to avoid double-emit (#435).
+        // If a pre-flush already emitted entries 1..flushCount, resume after that mark to avoid double-emit (#435/#499).
         const extract = this.options.providerConfig.chatCaptureMode === "full"
           ? (j: string) => (flushCount > 0 ? extractLastAssistantTurnAfterEntry(j, flushCount) : extractLastAssistantTurn(j))
-          : extractFinalAssistantMessage;
+          : (j: string) => (flushCount > 0 ? extractFinalAssistantMessageAfterEntry(j, flushCount) : extractFinalAssistantMessage(j));
         body = extract(jsonl);
         if (body) break;
       }