@sjawhar/pi-legion-envoy 5.29.0 → 5.30.1

package/dist/envoy.js

@@ -29796,6 +29796,7 @@ var DispatchTargetedMessagePayloadSchema = MessageEventPayloadSchema.extend({
   body: exports_external.string(),
   target: exports_external.string(),
   in_reply_to: exports_external.string().nullable(),
+  broadcast_id: exports_external.string().nullish(),
   deliveries: exports_external.array(exports_external.unknown()),
   created_at: exports_external.string()
 });
@@ -32030,7 +32031,8 @@ function renderInbound(raw, sessionID, subject2) {
               replyPath: dispatchReplyPath("message", message2.data.id),
               replyFields: {},
               issueKey: frame.event.issue_key,
-              body: message2.data.body
+              body: message2.data.body,
+              ...typeof message2.data.broadcast_id === "string" ? { broadcastId: message2.data.broadcast_id } : {}
             };
             dispatchReply = {
               tool: "dispatch_message",
@@ -32578,6 +32580,9 @@ class DispatchClient {
   async getMessageThread(id, session) {
     return this.#json("GET", ["api", "v1", "messages", id], undefined, { session });
   }
+  async acceptMessageDelivery(id, attempt, input) {
+    return this.#json("POST", ["api", "v1", "messages", id, "deliveries", String(attempt), "accept"], input);
+  }
   async artifact(issue2, input) {
     const artifactPath = ["api", "v1", "issues", await this.#resolveIssue(issue2), "artifacts"];
     if ("content" in input)
@@ -35297,7 +35302,7 @@ function conversationParts(content) {
   return parts;
 }
 function frameFor(entry) {
-  const { message } = entry;
+  const { dispatchMessageId, message } = entry;
   if (message.role === "toolResult" && message.toolCallId !== undefined) {
     return {
       kind: "tool-result",
@@ -35319,7 +35324,8 @@ function frameFor(entry) {
       id: entry.key.slice(2),
       parts: conversationParts(message.host.content),
       role: message.role === "assistant" ? "assistant" : "user",
-      streaming: entry.streaming
+      streaming: entry.streaming,
+      ...dispatchMessageId === undefined ? {} : { dispatchMessageId }
     },
     seq: entry.seq,
     v: AGENT_STREAM_PROTOCOL
@@ -35348,7 +35354,7 @@ class AgentStreamPublisher {
     this.#publishedAt.clear();
     this.#watchedUntil = 0;
   }
-  record(subject2, raw, streaming) {
+  record(subject2, raw, streaming, dispatchMessageId) {
     const message = readMessage(raw);
     if (message === null)
       return false;
@@ -35361,6 +35367,7 @@ class AgentStreamPublisher {
     this.#seq += 1;
     const entry = {
       at: message.timestamp,
+      dispatchMessageId: dispatchMessageId ?? this.#history.get(key)?.dispatchMessageId,
       key,
       message,
       seq: this.#seq,
@@ -35431,6 +35438,101 @@ function withDispatchFirst(messages, context) {
   ];
 }
 
+// src/dispatch-user-turn.ts
+function isUserTurnCandidate(rendered) {
+  const { delivery } = rendered;
+  return rendered.envelope?.source === "dispatch" && delivery?.resource === "message" && delivery.issueKey === null && delivery.broadcastId === undefined && rendered.dispatchActor?.kind === "user" && (delivery.mode === "aside" || delivery.mode === "steer");
+}
+var AcceptedDeliverySchema = exports_external.object({
+  message_id: exports_external.string(),
+  body: exports_external.string(),
+  delivery: exports_external.enum(["aside", "steer"])
+});
+function turnFromAccept(accepted) {
+  const parsed = AcceptedDeliverySchema.safeParse(accepted);
+  if (!parsed.success)
+    return;
+  return { body: parsed.data.body, messageId: parsed.data.message_id, mode: parsed.data.delivery };
+}
+var HANDLED_ATTEMPT_ENTRY = "envoy-dispatch-handled-attempt";
+function handledAttemptKey(messageId, attempt) {
+  return `${messageId}#${attempt}`;
+}
+function handledAttempts(entries) {
+  const handled = new Set;
+  for (const entry of entries) {
+    if (typeof entry !== "object" || entry === null)
+      continue;
+    if (!("type" in entry) || entry.type !== "custom")
+      continue;
+    if (!("customType" in entry) || entry.customType !== HANDLED_ATTEMPT_ENTRY)
+      continue;
+    if (!("data" in entry) || typeof entry.data !== "object" || entry.data === null)
+      continue;
+    const { data } = entry;
+    if (!("message_id" in data) || typeof data.message_id !== "string")
+      continue;
+    if (!("attempt" in data) || typeof data.attempt !== "number")
+      continue;
+    handled.add(handledAttemptKey(data.message_id, data.attempt));
+  }
+  return handled;
+}
+function userMessageText(content) {
+  if (typeof content === "string")
+    return content;
+  if (!Array.isArray(content))
+    return "";
+  const pieces = [];
+  for (const part of content) {
+    if (typeof part !== "object" || part === null)
+      continue;
+    if ("type" in part && part.type === "text" && "text" in part && typeof part.text === "string") {
+      pieces.push(part.text);
+    }
+  }
+  return pieces.join(`
+`);
+}
+var INJECTED_USER_TURNS = Symbol.for("legion.pi-envoy.injected-user-turns");
+function injectedUserTurns() {
+  const store = globalThis;
+  const turns = store[INJECTED_USER_TURNS] ?? new Map;
+  store[INJECTED_USER_TURNS] = turns;
+  return turns;
+}
+function noteInjectedUserTurn(sessionID, body, messageId) {
+  const turns = injectedUserTurns();
+  const session = turns.get(sessionID) ?? { found: new Map, sent: [] };
+  session.sent.push({ body, messageId });
+  turns.set(sessionID, session);
+}
+function matchInjectedUserTurn(sessionID, message) {
+  if (typeof message !== "object" || message === null)
+    return;
+  if (!("role" in message) || message.role !== "user")
+    return;
+  if (!("timestamp" in message) || typeof message.timestamp !== "number")
+    return;
+  const session = injectedUserTurns().get(sessionID);
+  if (session === undefined)
+    return;
+  const known = session.found.get(message.timestamp);
+  if (known !== undefined)
+    return known;
+  const text = userMessageText("content" in message ? message.content : undefined);
+  const index = session.sent.findIndex((sent2) => sent2.body === text);
+  const sent = session.sent[index];
+  if (sent === undefined)
+    return;
+  session.sent.splice(index, 1);
+  session.found.set(message.timestamp, sent.messageId);
+  return sent.messageId;
+}
+function endInjectedUserTurns(sessionID) {
+  injectedUserTurns().delete(sessionID);
+}
+
 // src/envoy-session.ts
 import path2 from "path";
 var ENVOY_SESSIONS = Symbol.for("legion.pi-envoy.envoy-session");
@@ -35687,6 +35789,7 @@ var NATS_RETRY_INTERVAL_MS = 15000;
 var CAPABILITIES_WITHOUT_BTW = DELIVERY_CAPABILITIES.filter((capability) => capability !== "btw");
 var ROLE_CLAIM_ENTRY = "envoy-role-claim";
 var OPEN_ASKS_TIMEOUT_MS = 3000;
+var USER_TURN_ACCEPT_TIMEOUT_MS = 1e4;
 var LEGION_MANAGED_ENTRY = "legion-managed-session";
 var ASK_REMINDER_MESSAGE = "dispatch-ask-reminder";
 var ASK_PROMPT_LINE_SEPARATOR = /\r\n|[\r\n\u0085\u2028\u2029]/;
@@ -35816,6 +35919,7 @@ function envoyExtension(pi) {
   let runSeq = 0;
   let legionManagedTranscript = false;
   const legionManaged = (id) => legionManagedTranscript || legionRoleClaimBridge().managedSessions.has(id);
+  let handledDispatchAttempts = new Set;
   const availabilityWarningSessionIDs = new Set;
   const warnAskAvailability = (context, error48) => {
     const sessionID2 = context.sessionManager.getSessionId();
@@ -35873,6 +35977,7 @@ function envoyExtension(pi) {
       awarenessGeneration++;
     }
     legionManagedTranscript = branch.some(isLegionManagedEntry);
+    handledDispatchAttempts = handledAttempts(context.sessionManager.getEntries());
   };
   pi.on("resources_discover", async () => ({ skillPaths: [SKILLS_DIRECTORY] }));
   registerEnvoyMessageRenderer(pi);
@@ -35892,6 +35997,34 @@ function envoyExtension(pi) {
   const postDispatchReply = async (delivery, result) => {
     await postDeliveryReply(currentDispatchConfig(), sessionID, delivery, result);
   };
+  const acceptedUserTurn = async (rendered) => {
+    if (!isUserTurnCandidate(rendered))
+      return;
+    const { delivery } = rendered;
+    const key = handledAttemptKey(delivery.id, delivery.attempt);
+    if (handledDispatchAttempts.has(key)) {
+      logger.warn("envoy: a frame names a Dispatch attempt this session already delivered; it arrives as a card", { attempt: delivery.attempt, messageID: delivery.id });
+      return;
+    }
+    handledDispatchAttempts.add(key);
+    pi.appendEntry(HANDLED_ATTEMPT_ENTRY, { attempt: delivery.attempt, message_id: delivery.id });
+    try {
+      const config2 = activeDispatchConfig(process.env, { cwd: process.cwd() });
+      if (config2 === null)
+        return;
+      const accepted = await new DispatchClient(config2.url, config2.token, fetch, AbortSignal.timeout(USER_TURN_ACCEPT_TIMEOUT_MS)).acceptMessageDelivery(delivery.id, delivery.attempt, {
+        actor: { id: sessionID, kind: "session" }
+      });
+      const turn = turnFromAccept(accepted);
+      if (turn === undefined) {
+        logger.warn("envoy: Dispatch accepted a direct message without the stored body and mode to inject; it arrives as a card", { attempt: delivery.attempt, messageID: delivery.id });
+      }
+      return turn;
+    } catch (error48) {
+      logger.warn("envoy: Dispatch did not accept a direct message as this session's turn; it arrives as a card", { attempt: delivery.attempt, messageID: delivery.id, error: messageFor(error48) });
+      return;
+    }
+  };
   const deliver = async (subject2, raw, reply) => {
     const rendered = renderInbound(raw, sessionID, subject2);
     const directSubject = agentSubject(sessionID);
@@ -35950,10 +36083,16 @@ function envoyExtension(pi) {
             }
           }
         } else {
-          pi.sendMessage({ customType: "envoy-message", content: rendered.content, display: true }, {
-            deliverAs: rendered.delivery?.mode === "aside" ? "aside" : "steer",
-            triggerTurn: true
-          });
+          const turn = await acceptedUserTurn(rendered);
+          if (turn === undefined) {
+            pi.sendMessage({ customType: "envoy-message", content: rendered.content, display: true }, {
+              deliverAs: rendered.delivery?.mode === "aside" ? "aside" : "steer",
+              triggerTurn: true
+            });
+          } else {
+            noteInjectedUserTurn(sessionID, turn.body, turn.messageId);
+            pi.sendUserMessage(turn.body, turn.mode === "aside" ? { deliverAs: "aside" } : undefined);
+          }
         }
       } catch (error48) {
         console.warn(`[envoy] failed to deliver envelope ${envelope2?.event_id ?? "unknown"}`, error48);
@@ -36079,7 +36218,7 @@ function envoyExtension(pi) {
   const recordAgentStreamMessage = (message, streaming) => {
     if (sessionID === "")
       return;
-    agentStream.record(agentStreamFramesSubject(sessionID), message, streaming);
+    agentStream.record(agentStreamFramesSubject(sessionID), message, streaming, matchInjectedUserTurn(sessionID, message));
   };
   pi.on("message_start", async (event) => {
     recordAgentStreamMessage(event.message, true);
@@ -36556,6 +36695,7 @@ function envoyExtension(pi) {
   }
   pi.on("agent_end", async (event, context) => {
     const id = context.sessionManager.getSessionId();
+    endInjectedUserTurns(sessionID);
     const lastReply = event.messages?.findLast((message) => message.role === "assistant");
     const ask = sideTurn(pi, context);
     if (event.willContinue === true || lastReply?.stopReason !== "stop" || !context.hasUI || id === "" || ask === undefined || !checkOwed(id)) {

package/dist/legion.js

@@ -29965,6 +29965,7 @@ var DispatchTargetedMessagePayloadSchema = MessageEventPayloadSchema.extend({
   body: exports_external.string(),
   target: exports_external.string(),
   in_reply_to: exports_external.string().nullable(),
+  broadcast_id: exports_external.string().nullish(),
   deliveries: exports_external.array(exports_external.unknown()),
   created_at: exports_external.string()
 });
@@ -31484,6 +31485,9 @@ class DispatchClient {
   async getMessageThread(id, session) {
     return this.#json("GET", ["api", "v1", "messages", id], undefined, { session });
   }
+  async acceptMessageDelivery(id, attempt, input) {
+    return this.#json("POST", ["api", "v1", "messages", id, "deliveries", String(attempt), "accept"], input);
+  }
   async artifact(issue2, input) {
     const artifactPath = ["api", "v1", "issues", await this.#resolveIssue(issue2), "artifacts"];
     if ("content" in input)
@@ -33672,7 +33676,7 @@ import { logger } from "@oh-my-pi/pi-utils";
 // package.json
 var package_default = {
   name: "@sjawhar/pi-legion-envoy",
-  version: "5.29.0",
+  version: "5.30.1",
   type: "module",
   omp: {
     extensions: [
@@ -33717,6 +33721,101 @@ var package_default = {
   }
 };
 
+// src/dispatch-user-turn.ts
+function isUserTurnCandidate(rendered) {
+  const { delivery } = rendered;
+  return rendered.envelope?.source === "dispatch" && delivery?.resource === "message" && delivery.issueKey === null && delivery.broadcastId === undefined && rendered.dispatchActor?.kind === "user" && (delivery.mode === "aside" || delivery.mode === "steer");
+}
+var AcceptedDeliverySchema = exports_external.object({
+  message_id: exports_external.string(),
+  body: exports_external.string(),
+  delivery: exports_external.enum(["aside", "steer"])
+});
+function turnFromAccept(accepted) {
+  const parsed = AcceptedDeliverySchema.safeParse(accepted);
+  if (!parsed.success)
+    return;
+  return { body: parsed.data.body, messageId: parsed.data.message_id, mode: parsed.data.delivery };
+}
+var HANDLED_ATTEMPT_ENTRY = "envoy-dispatch-handled-attempt";
+function handledAttemptKey(messageId, attempt) {
+  return `${messageId}#${attempt}`;
+}
+function handledAttempts(entries) {
+  const handled = new Set;
+  for (const entry of entries) {
+    if (typeof entry !== "object" || entry === null)
+      continue;
+    if (!("type" in entry) || entry.type !== "custom")
+      continue;
+    if (!("customType" in entry) || entry.customType !== HANDLED_ATTEMPT_ENTRY)
+      continue;
+    if (!("data" in entry) || typeof entry.data !== "object" || entry.data === null)
+      continue;
+    const { data } = entry;
+    if (!("message_id" in data) || typeof data.message_id !== "string")
+      continue;
+    if (!("attempt" in data) || typeof data.attempt !== "number")
+      continue;
+    handled.add(handledAttemptKey(data.message_id, data.attempt));
+  }
+  return handled;
+}
+function userMessageText(content) {
+  if (typeof content === "string")
+    return content;
+  if (!Array.isArray(content))
+    return "";
+  const pieces = [];
+  for (const part of content) {
+    if (typeof part !== "object" || part === null)
+      continue;
+    if ("type" in part && part.type === "text" && "text" in part && typeof part.text === "string") {
+      pieces.push(part.text);
+    }
+  }
+  return pieces.join(`
+`);
+}
+var INJECTED_USER_TURNS = Symbol.for("legion.pi-envoy.injected-user-turns");
+function injectedUserTurns() {
+  const store = globalThis;
+  const turns = store[INJECTED_USER_TURNS] ?? new Map;
+  store[INJECTED_USER_TURNS] = turns;
+  return turns;
+}
+function noteInjectedUserTurn(sessionID, body, messageId) {
+  const turns = injectedUserTurns();
+  const session = turns.get(sessionID) ?? { found: new Map, sent: [] };
+  session.sent.push({ body, messageId });
+  turns.set(sessionID, session);
+}
+function matchInjectedUserTurn(sessionID, message) {
+  if (typeof message !== "object" || message === null)
+    return;
+  if (!("role" in message) || message.role !== "user")
+    return;
+  if (!("timestamp" in message) || typeof message.timestamp !== "number")
+    return;
+  const session = injectedUserTurns().get(sessionID);
+  if (session === undefined)
+    return;
+  const known = session.found.get(message.timestamp);
+  if (known !== undefined)
+    return known;
+  const text = userMessageText("content" in message ? message.content : undefined);
+  const index = session.sent.findIndex((sent2) => sent2.body === text);
+  const sent = session.sent[index];
+  if (sent === undefined)
+    return;
+  session.sent.splice(index, 1);
+  session.found.set(message.timestamp, sent.messageId);
+  return sent.messageId;
+}
+function endInjectedUserTurns(sessionID) {
+  injectedUserTurns().delete(sessionID);
+}
+
 // src/legion/classify.ts
 function classifySession(env) {
   if (env.LEGION_CONTROLLER !== undefined && env.LEGION_TREE !== undefined) {
@@ -35838,7 +35937,8 @@ function legionExtension(pi) {
   pi.on("message_start", async (event, context) => {
     if (!phaseWorkerSession(context))
       return;
-    const kind = inboundKind(event.message);
+    const injected = matchInjectedUserTurn(context.sessionManager.getSessionId(), event.message) !== undefined;
+    const kind = injected ? "inbound-event" : inboundKind(event.message);
     if (kind !== undefined)
       advancePhaseStall({ kind });
   });

package/dist/skills/dispatch/references/messages.md

@@ -6,7 +6,8 @@ human messages you directly from the Agents page.
 ## Targeted agent messages
 
 A human — or any bearer caller over HTTP, such as a test rig — can target the issue message at a
-live Envoy session or role as **BTW**, **Aside**, or **Steer**. The incoming Dispatch frame names
+live Envoy session or role as **BTW**, **Aside**, or **Steer** (the dashboard calls a steer
+**Send**). The incoming Dispatch frame names
 the issue and includes a `reply_with` hint (`{ tool, args }`, ready to issue on any host); reply on the same open issue with the existing
 tool, never a new targeted send:
 
@@ -32,9 +33,17 @@ target only a session that advertises the mode you want. Sending to a session wi
 
 ## Answering a direct message
 
-A human can also message you directly from the **Agents** page, with no issue at all. That frame
-names no issue and its `reply_with` hint carries none either; answer it with the message's bare
-id in `in_reply_to`, alone:
+A human can also message you directly from the **Agents** page, with no issue at all. On Oh My
+Pi, a person's **Send** or **Aside** arrives as their own user message, exactly as if they had
+typed it at your terminal: your Envoy plugin takes it only once Dispatch accepts it as a person's
+own fresh message to you, and injects the text Dispatch stored. Answer it in the conversation as
+you would anything typed, with no `dispatch_message`; the Agents page shows your conversation
+live, so they read your answer there.
+
+Everything else still arrives as a Dispatch frame: a **BTW**, a broadcast, a direct message on a
+host that takes no user turn from its plugin (Claude Code), and one Dispatch did not accept.
+That frame names no issue and its `reply_with` hint carries none either; answer it with the
+message's bare id in `in_reply_to`, alone:
 
 ```ts
 dispatch_message({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sjawhar/pi-legion-envoy",
-  "version": "5.29.0",
+  "version": "5.30.1",
   "type": "module",
   "omp": {
     "extensions": [