agent-relay-runner 0.10.23 → 0.10.25

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-relay-runner",
-  "version": "0.10.23",
+  "version": "0.10.25",
   "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.10.23",
+  "version": "0.10.25",
   "agentRelayContracts": {
     "providerPluginProtocol": 1
   }

package/plugins/claude/hooks/relay-status.sh

@@ -41,12 +41,16 @@ relay_post_session_turn() {
   # the captured turn clears the reply obligation before the stop decision check
   # below, so the agent is not nagged to /reply (and does not re-emit).
   local transcript_path="${1:-}"
+  local last_assistant_message="${2:-}"
   local port="${AGENT_RELAY_RUNNER_PORT:-}"
   [ -z "$port" ] && return 0
   [ -z "$transcript_path" ] && return 0
+  local body="{\"transcriptPath\":\"$(relay_json_escape "$transcript_path")\""
+  [ -n "$last_assistant_message" ] && body="${body},\"lastAssistantMessage\":${last_assistant_message}"
+  body="${body}}"
   curl -fsS -X POST "http://127.0.0.1:${port}/session-turn" \
     -H 'Content-Type: application/json' \
-    -d "{\"transcriptPath\":\"$(relay_json_escape "$transcript_path")\"}" >/dev/null 2>&1 || true
+    -d "$body" >/dev/null 2>&1 || true
 }
 
 relay_pending_reply_stop_decision() {

package/plugins/claude/hooks/stop.sh

@@ -5,7 +5,8 @@ source "${CLAUDE_PLUGIN_ROOT:-$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)}/
 payload="$(cat || true)"
 stop_hook_active="$(relay_json_bool_field stop_hook_active "$payload")"
 if [ "$stop_hook_active" != "true" ]; then
-  relay_post_session_turn "$(relay_json_string_field transcript_path "$payload")"
+  last_assistant_msg="$(echo "$payload" | jq -c '.last_assistant_message // empty' 2>/dev/null || true)"
+  relay_post_session_turn "$(relay_json_string_field transcript_path "$payload")" "$last_assistant_msg"
   stop_decision="$(relay_pending_reply_stop_decision)"
   if [ -n "$stop_decision" ]; then
     printf '%s\n' "$stop_decision"

package/src/adapters/claude-transcript.ts

@@ -49,6 +49,28 @@ function assistantText(entry: TranscriptEntry): string {
     .join("\n\n");
 }
 
+/**
+ * Returns true when the transcript's final parseable entry is an assistant
+ * message with stop_reason "end_turn", meaning the full turn has been flushed.
+ * Used to detect a race where the Stop hook reads the file before the last
+ * assistant block is written to disk.
+ */
+export function transcriptLooksComplete(jsonl: string): boolean {
+  const lines = jsonl.split("\n");
+  let lastAssistantStopReason: string | undefined;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      const entry = JSON.parse(trimmed) as TranscriptEntry;
+      if (entry.type === "assistant") lastAssistantStopReason = entry.message?.stop_reason;
+    } catch {
+      continue;
+    }
+  }
+  return lastAssistantStopReason === "end_turn";
+}
+
 /**
  * Returns the concatenated assistant `text` for the most recent turn (since the
  * last real user prompt), or "" if there is nothing user-visible to surface.
@@ -74,3 +96,19 @@ export function extractLastAssistantTurn(jsonl: string): string {
   }
   return collected.join("\n\n").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
+ * string or an array of content blocks (same shape as transcript entries).
+ * Thinking and tool_use blocks are dropped, matching extractLastAssistantTurn.
+ */
+export function extractHookAssistantMessage(content: unknown): string {
+  if (typeof content === "string") return content.trim();
+  if (!Array.isArray(content)) return "";
+  return (content as TranscriptBlock[])
+    .filter((b) => b.type === "text" && typeof b.text === "string")
+    .map((b) => b.text!.trim())
+    .filter(Boolean)
+    .join("\n\n");
+}

package/src/control-server.ts

@@ -23,7 +23,7 @@ interface ControlServerOptions {
   // Phase 1 live-session lane: a provider Stop hook hands over its transcript
   // path so the runner can capture the assistant turn and surface it in the
   // dashboard chat without the agent re-emitting it via /reply.
-  onSessionTurn?(input: { transcriptPath: string }): Promise<void>;
+  onSessionTurn?(input: { transcriptPath: string; lastAssistantMessage?: unknown }): Promise<void>;
 }
 
 export function startControlServer(options: ControlServerOptions): ControlServer {
@@ -253,11 +253,12 @@ async function handleSessionTurn(req: Request, options: ControlServerOptions): P
   const body = await req.json().catch(() => null);
   const transcriptPath = isRecord(body) && typeof body.transcriptPath === "string" ? body.transcriptPath : "";
   if (!transcriptPath) return Response.json({ ok: false, reason: "transcriptPath required" }, { status: 400 });
+  const lastAssistantMessage = isRecord(body) ? body.lastAssistantMessage : undefined;
   // Awaited on purpose: the Stop hook posts this synchronously before its
   // reply-obligation check, so the captured turn must be persisted (and the
   // obligation cleared) before this response returns.
   try {
-    await options.onSessionTurn({ transcriptPath });
+    await options.onSessionTurn({ transcriptPath, lastAssistantMessage });
     return Response.json({ ok: true });
   } catch (error) {
     return Response.json({ ok: false, reason: error instanceof Error ? error.message : String(error) }, { status: 500 });

package/src/runner.ts

@@ -9,7 +9,7 @@ import type { ManagedProcess, ProviderAdapter, ProviderConfig, ProviderPermissio
 import { messagesWithCachedAttachments } from "./attachment-cache";
 import { ClaimTracker } from "./claim-tracker";
 import { startControlServer, type ControlServer } from "./control-server";
-import { extractLastAssistantTurn } from "./adapters/claude-transcript";
+import { extractLastAssistantTurn, extractHookAssistantMessage, transcriptLooksComplete } from "./adapters/claude-transcript";
 import { agentProfileProjectionReport } from "./profile-projection";
 import { profileUsesHostProviderGlobals } from "./profile-home";
 import { runtimeMetadata } from "./version";
@@ -665,7 +665,7 @@ export class AgentRunner {
   // dashboard chat with zero agent tokens. Posting it as a reply to the
   // triggering message also clears the reply obligation, so the Stop hook no
   // longer nags the agent to /reply — which is what made it re-emit before.
-  private async publishSessionTurn(input: { transcriptPath: string }): Promise<void> {
+  private async publishSessionTurn(input: { transcriptPath: string; lastAssistantMessage?: unknown }): Promise<void> {
     // Find the triggering message to reply to: either a pending prompt injection
     // (Phase 2 direct lane) or a reply obligation from the dashboard human.
     let replyToMessageId: number | undefined;
@@ -690,7 +690,27 @@ export class AgentRunner {
     } catch {
       return;
     }
-    const body = extractLastAssistantTurn(jsonl);
+    // The Stop hook can fire before the final assistant entry is flushed to
+    // disk. Claude Code writes thinking and text as separate entries (both with
+    // end_turn), so the transcript can "look complete" while the text entry is
+    // still pending. Retry until both the transcript has an end_turn AND the
+    // extraction yields non-empty text.
+    let body = "";
+    for (let attempt = 0; attempt < 5; attempt++) {
+      if (attempt > 0) {
+        await new Promise((r) => setTimeout(r, 100));
+        try { jsonl = await readFile(input.transcriptPath, "utf8"); } catch { return; }
+      }
+      if (!transcriptLooksComplete(jsonl)) continue;
+      body = extractLastAssistantTurn(jsonl);
+      if (body) break;
+    }
+    // Fallback: use last_assistant_message from the Stop hook payload directly.
+    // This bypasses the transcript file race entirely — Claude Code provides the
+    // content in-memory before the hook even fires.
+    if (!body && input.lastAssistantMessage) {
+      body = extractHookAssistantMessage(input.lastAssistantMessage);
+    }
     if (!body) return;
 
     try {