@sjawhar/pi-envoy 8.17.0 → 9.0.0

package/dist/dispatch.js

@@ -13801,7 +13801,10 @@ var AGENT_STREAM_LIMITS = {
   modelChars: 200,
   historyMessages: 200,
   historyBytes: 512 * 1024,
-  snapshotIntervalMs: 100
+  snapshotIntervalMs: 100,
+  commands: 500,
+  commandNameChars: 100,
+  commandDescriptionChars: 200
 };
 // ../contracts/src/claim-holds.ts
 function claimHolds(claim, titles) {

package/dist/envoy.js

@@ -29863,16 +29863,23 @@ function agentStreamControlSubject(sessionID) {
   return `${AGENT_STREAM_SUBJECT_PREFIX}${sessionID}.control`;
 }
 var AGENT_STREAM_WATCH_TTL_MS = 30000;
+var AGENT_STREAM_WATCH_INTERVAL_MS = 1e4;
 var AGENT_STREAM_LIMITS = {
   partChars: 16000,
   toolChars: 8000,
   modelChars: 200,
   historyMessages: 200,
   historyBytes: 512 * 1024,
-  snapshotIntervalMs: 100
+  snapshotIntervalMs: 100,
+  commands: 500,
+  commandNameChars: 100,
+  commandDescriptionChars: 200
 };
 var AGENT_STREAM_TRUNCATION_SUFFIX = `
 \u2026 truncated`;
+function isTypableCommandName(name) {
+  return /^[^\s\p{Cc}]+$/u.test(name);
+}
 function capAgentStreamText(text, limit) {
   if (text.length <= limit)
     return text;
@@ -33505,7 +33512,7 @@ function sourceSession(sessionID) {
 
 // ../pi-shared/src/interface.ts
 import { logger } from "@oh-my-pi/pi-utils";
-var ENVOY_PLUGIN_INTERFACE_VERSION = 1;
+var ENVOY_PLUGIN_INTERFACE_VERSION = 2;
 var ENVOY_PLUGIN_INTERFACE_KEY = Symbol.for("legion.pi-shared.envoy-plugin-interface");
 var LEGION_PLUGIN_LOADED_KEY = Symbol.for("legion.pi-legion.loaded");
 var LEGACY_LEGION_LOADED_KEY = Symbol.for("legion.pi-envoy.legion-loaded");
@@ -33562,35 +33569,68 @@ function userMessageText(content) {
   return pieces.join(`
 `);
 }
-function noteInjectedUserTurn(sessionID, body, messageId) {
+function sessionTurns(sessionID) {
   const turns = envoyPluginInterface().injectedUserTurns;
   const session = turns.get(sessionID) ?? { found: new Map, sent: [] };
-  session.sent.push({ body, messageId });
   turns.set(sessionID, session);
+  return session;
+}
+function noteInjectedUserTurn(sessionID, body, messageId) {
+  sessionTurns(sessionID).sent.push({ body, messageId, via: "text" });
+}
+function noteTypedUserTurn(sessionID, messageId) {
+  sessionTurns(sessionID).sent.push({ messageId, via: "typed" });
+}
+function dropInjectedUserTurn(sessionID, messageId) {
+  const session = envoyPluginInterface().injectedUserTurns.get(sessionID);
+  if (session === undefined)
+    return;
+  const index = session.sent.findIndex((sent) => sent.messageId === messageId);
+  if (index !== -1)
+    session.sent.splice(index, 1);
 }
 function matchInjectedUserTurn(sessionID, message) {
   if (typeof message !== "object" || message === null)
     return;
-  if (!("role" in message) || message.role !== "user")
+  if (!("role" in message) || message.role !== "user" && message.role !== "custom") {
     return;
+  }
   if (!("timestamp" in message) || typeof message.timestamp !== "number")
     return;
   const session = envoyPluginInterface().injectedUserTurns.get(sessionID);
   if (session === undefined)
     return;
-  const known = session.found.get(message.timestamp);
+  const tag = messageTag(message);
+  const memo = tag === undefined ? `${message.timestamp}` : `${message.timestamp}:${tag}`;
+  const known = session.found.get(memo);
   if (known !== undefined)
     return known;
-  const text = userMessageText("content" in message ? message.content : undefined);
-  const index = session.sent.findIndex((sent2) => sent2.body === text);
+  let index = tag === undefined ? -1 : session.sent.findIndex((sent2) => sent2.messageId === tag);
+  if (index === -1 && message.role === "user") {
+    const text = userMessageText("content" in message ? message.content : undefined);
+    index = session.sent.findIndex((sent2) => sent2.via === "text" && sent2.body === text);
+  }
   const sent = session.sent[index];
   if (sent === undefined)
     return;
   session.sent.splice(index, 1);
-  session.found.set(message.timestamp, sent.messageId);
+  session.found.set(memo, sent.messageId);
   return sent.messageId;
 }
+function messageTag(message) {
+  if (typeof message !== "object" || message === null || !("tag" in message))
+    return;
+  return typeof message.tag === "string" ? message.tag : undefined;
+}
 function endInjectedUserTurns(sessionID) {
+  const turns = envoyPluginInterface().injectedUserTurns;
+  const typed = turns.get(sessionID)?.sent.filter((sent) => sent.via === "typed") ?? [];
+  if (typed.length === 0)
+    turns.delete(sessionID);
+  else
+    turns.set(sessionID, { found: new Map, sent: typed });
+}
+function forgetInjectedUserTurns(sessionID) {
   envoyPluginInterface().injectedUserTurns.delete(sessionID);
 }
 
@@ -33724,11 +33764,16 @@ function toolFailure(error48) {
 }
 
 // extensions/envoy.ts
-import { logger as logger3, procmgr } from "@oh-my-pi/pi-utils";
+import * as host2 from "@oh-my-pi/pi-coding-agent";
+import { logger as logger3, procmgr, VERSION } from "@oh-my-pi/pi-utils";
 var import_nats2 = __toESM(require_mod4(), 1);
 
 // src/agent-stream.ts
 var encoder = new TextEncoder;
+var REPLAY_ARRAY_BYTES = 2;
+function jsonBytes(value) {
+  return encoder.encode(JSON.stringify(value)).length;
+}
 function readModel(message) {
   if (typeof message.model !== "string" || message.model === "")
     return;
@@ -33749,16 +33794,19 @@ function readMessage(raw) {
     role: message.role,
     timestamp: message.timestamp,
     toolCallId: typeof message.toolCallId === "string" ? message.toolCallId : undefined,
-    toolName: typeof message.toolName === "string" ? message.toolName : undefined
+    toolName: typeof message.toolName === "string" ? message.toolName : undefined,
+    tag: typeof message.tag === "string" ? message.tag : undefined
   };
 }
 function keyFor(message) {
   if (message.role === "toolResult") {
     return message.toolCallId === undefined ? null : `t:${message.toolCallId}`;
   }
-  if (message.role !== "assistant" && message.role !== "user")
+  if (message.role === "assistant")
+    return `m:a${message.timestamp}`;
+  if (message.role !== "user")
     return null;
-  return `m:${message.role === "assistant" ? "a" : "u"}${message.timestamp}`;
+  return message.tag === undefined ? `m:u${message.timestamp}` : `m:u${message.timestamp}:${message.tag}`;
 }
 function contentText(content) {
   if (typeof content === "string")
@@ -33858,6 +33906,8 @@ class AgentStreamPublisher {
   #publishedAt = new Map;
   #seq = 0;
   #watchedUntil = 0;
+  #commands;
+  #commandsSeq = 0;
   constructor(deps) {
     this.#deps = deps;
   }
@@ -33872,6 +33922,46 @@ class AgentStreamPublisher {
     this.#settled.clear();
     this.#publishedAt.clear();
     this.#watchedUntil = 0;
+    this.#commands = undefined;
+  }
+  setCommands(subject2, commands) {
+    const limit = AGENT_STREAM_LIMITS.historyBytes - REPLAY_ARRAY_BYTES;
+    let bytes = jsonBytes(this.#commandsFrame([], this.#seq + 1));
+    const seen = new Set;
+    const kept = [];
+    for (const command of commands) {
+      if (kept.length >= AGENT_STREAM_LIMITS.commands)
+        break;
+      const name = command.name;
+      if (name.length > AGENT_STREAM_LIMITS.commandNameChars)
+        continue;
+      if (!isTypableCommandName(name) || seen.has(name))
+        continue;
+      const listed = {
+        name,
+        source: command.source,
+        ...command.description !== undefined && {
+          description: capAgentStreamText(command.description, AGENT_STREAM_LIMITS.commandDescriptionChars)
+        },
+        ...command.terminalOnly === true && { terminalOnly: true }
+      };
+      const cost = jsonBytes(listed) + (kept.length === 0 ? 0 : 1);
+      if (bytes + cost > limit)
+        break;
+      bytes += cost;
+      seen.add(name);
+      kept.push(listed);
+    }
+    if (JSON.stringify(kept) === JSON.stringify(this.#commands))
+      return;
+    this.#commands = kept;
+    this.#seq += 1;
+    this.#commandsSeq = this.#seq;
+    if (this.watched)
+      this.#deps.publish(subject2, JSON.stringify(this.#commandsFrame(kept)));
+  }
+  #commandsFrame(commands, seq = this.#commandsSeq) {
+    return { commands, kind: "commands", seq, v: AGENT_STREAM_PROTOCOL };
   }
   record(subject2, raw, streaming, dispatchMessageId) {
     const message = readMessage(raw);
@@ -33918,18 +34008,23 @@ class AgentStreamPublisher {
     if (!this.watched)
       return { frames: [], session_id: sessionID, v: AGENT_STREAM_PROTOCOL };
     const ordered = [...this.#history.values()].sort((left, right) => left.at === right.at ? left.seq - right.seq : left.at - right.at);
-    let budget = AGENT_STREAM_LIMITS.historyBytes;
+    const commands = this.#commands === undefined ? undefined : this.#commandsFrame(this.#commands);
+    let used = REPLAY_ARRAY_BYTES + (commands === undefined ? 0 : jsonBytes(commands));
     const kept = [];
     for (let index = ordered.length - 1;index >= 0; index -= 1) {
       const entry = ordered[index];
       if (entry === undefined)
         continue;
       const frame = frameFor(entry);
-      budget -= encoder.encode(JSON.stringify(frame)).length;
-      if (budget < 0)
+      const separated = kept.length > 0 || commands !== undefined;
+      const cost = jsonBytes(frame) + (separated ? 1 : 0);
+      if (used + cost > AGENT_STREAM_LIMITS.historyBytes)
         break;
+      used += cost;
       kept.unshift(frame);
     }
+    if (commands !== undefined)
+      kept.push(commands);
     return { frames: kept, session_id: sessionID, v: AGENT_STREAM_PROTOCOL };
   }
 }
@@ -34074,6 +34169,26 @@ function handledAttempts(entries) {
   }
   return handled;
 }
+function typedInputReply(text, outcome) {
+  const typed = /^\/\S+/.exec(text)?.[0];
+  const command = typed ?? "This message";
+  let reply;
+  if ("error" in outcome)
+    reply = `${command} was not run: ${outcome.error}`;
+  else if ("hostVersion" in outcome) {
+    if (typed !== undefined) {
+      reply = `${typed} was not run: this session's Oh My Pi ${outcome.hostVersion} cannot run commands sent from Dispatch; nothing was sent.`;
+    }
+  } else if (outcome.handled === "terminal-only") {
+    reply = `${command} runs only in the session's own terminal; nothing was sent.`;
+  } else if (outcome.handled === "unavailable") {
+    reply = `${command} was not run: this session's host cannot run typed input from Dispatch; nothing was sent.`;
+  } else if (outcome.output?.trim())
+    reply = outcome.output;
+  if (reply === undefined || reply.length <= DISPATCH_BODY_MAX)
+    return reply;
+  return `${reply.slice(0, DISPATCH_BODY_MAX - 1)}\u2026`;
+}
 
 // src/envoy-session.ts
 import path3 from "path";
@@ -34161,6 +34276,53 @@ function sideTurn(context) {
   return ({ prompt, signal }) => runEphemeralTurn({ promptText: btwPrompt(prompt), signal });
 }
 
+// src/typed-pictures.ts
+class TypedPictures {
+  #admissions = new Map;
+  admit(messageId, turn) {
+    this.#admissions.set(messageId, {
+      addresses: turn.addresses,
+      body: turn.body,
+      images: turn.images,
+      sessionID: turn.sessionID
+    });
+  }
+  handOver(text) {
+    for (const admission of this.#admissions.values()) {
+      if (admission.images === undefined || admission.body !== text)
+        continue;
+      const { images } = admission;
+      admission.images = undefined;
+      return images;
+    }
+    return;
+  }
+  withdraw(messageId) {
+    this.#admissions.delete(messageId);
+  }
+  inputPassed(messageId) {
+    if (this.#admissions.get(messageId)?.images !== undefined)
+      this.#admissions.delete(messageId);
+  }
+  started(message) {
+    const tag = messageTag(message);
+    if (tag === undefined)
+      return;
+    const admission = this.#admissions.get(tag);
+    if (admission === undefined)
+      return;
+    this.#admissions.delete(tag);
+    return admission.images === undefined ? admission.addresses : undefined;
+  }
+  dropOtherSessions(sessionID) {
+    for (const [messageId, admission] of this.#admissions) {
+      if (admission.sessionID !== sessionID && admission.images === undefined) {
+        this.#admissions.delete(messageId);
+      }
+    }
+  }
+}
+
 // extensions/envoy-message-renderer.ts
 import { Box, Spacer, Text } from "@oh-my-pi/pi-tui";
 var ENVOY_MESSAGE_COLLAPSED_LINES = 12;
@@ -34216,6 +34378,12 @@ async function copySessionID(copyToClipboard2, sessionID) {
 }
 
 // extensions/envoy.ts
+var hostBuiltinCommands;
+import("@oh-my-pi/pi-coding-agent/extensibility/extensions/send-user-input-handler").then((module) => {
+  hostBuiltinCommands = module.listUserInputBuiltinCommands;
+}, () => {
+  return;
+});
 var codec2 = import_nats2.StringCodec();
 var NATS_RETRY_INTERVAL_MS = 15000;
 var DELIVERY_PICTURES_TIMEOUT_MS = 20000;
@@ -34264,16 +34432,16 @@ var ASK_SELF_CHECK_PROMPT = (asks) => {
     ...asks.length > askLimit ? [`+${asks.length - askLimit} more`] : []
   ].join(`
 `);
-  return "Your run has just ended. " + `${promptAsks}
+  return `Your run has just ended. ${promptAsks}
 
-` + "Are you right now waiting on a human for anything none of those asks covers? " + "Answer with exactly one word and nothing else: WAITING or PROCEEDING. " + "WAITING \u2014 you stopped because you need a decision, an approval, or information from a human. " + "PROCEEDING \u2014 you finished, you will carry on by yourself, or you are waiting only on tools, " + "subagents, or events.";
+Are you right now waiting on a human for anything none of those asks covers? Answer with exactly one word and nothing else: WAITING or PROCEEDING. ` + "WAITING \u2014 you stopped because you need a decision, an approval, or information from a human. " + "PROCEEDING \u2014 you finished, you will carry on by yourself, or you are waiting only on tools, " + "subagents, or events.";
 };
 var WAITING_VERDICT = /^\W*WAITING\b/;
 var ECHOED_CHOICE = /\bPROCEEDING\b/;
 var isWaitingVerdict = (reply) => WAITING_VERDICT.test(reply) && !ECHOED_CHOICE.test(reply);
 var ASK_SELF_CHECK_TIMEOUT_MS = 60000;
 var ASK_CHECKS_PER_PERIOD = 5;
-var UNASKED_WAIT_REMINDER = "You just said you are waiting on a human for something no open ask in Dispatch covers. " + "Open it now: a decision block in the document it concerns (dispatch doc-edit with an ask block), or " + "dispatch ask for a to-do only a human can do, naming exactly what you need and from whom.";
+var UNASKED_WAIT_REMINDER = "You just said you are waiting on a human for something no open ask in Dispatch covers. Open it now: a decision block in the document it concerns (dispatch doc-edit with an ask block), or dispatch ask for a to-do only a human can do, naming exactly what you need and from whom.";
 function isLegionManagedEntry(entry) {
   if (typeof entry !== "object" || entry === null)
     return false;
@@ -34367,6 +34535,7 @@ function envoyExtension(pi) {
   let legionManagedTranscript = false;
   const legionManaged = (id) => legionManagedTranscript || legionRoleClaimBridge().managedSessions.has(id);
   let handledDispatchAttempts = new Set;
+  const notedSessionIDs = new Set;
   const availabilityWarningSessionIDs = new Set;
   const warnAskAvailability = (context, error48) => {
     const sessionID2 = context.sessionManager.getSessionId();
@@ -34431,8 +34600,12 @@ function envoyExtension(pi) {
     legionManagedTranscript = branch.some(isLegionManagedEntry);
     handledDispatchAttempts = handledAttempts(context.sessionManager.getEntries());
     markPicturesShown(shownPictures(sessionID), transcriptPictures(branch));
-    if (previousSessionID !== sessionID)
+    if (previousSessionID !== sessionID) {
       forgetShownPictures(previousSessionID);
+      if (notedSessionIDs.delete(previousSessionID))
+        forgetInjectedUserTurns(previousSessionID);
+      typedPictures.dropOtherSessions(sessionID);
+    }
   };
   let dispatchLedger;
   const bindDispatchSession = (id) => {
@@ -34475,10 +34648,57 @@ function envoyExtension(pi) {
     });
     return connection;
   };
-  const postDispatchReply = async (delivery, result) => {
-    await postDeliveryReply(currentDispatchConfig(), sessionID, delivery, result);
+  const postDispatchReply = async (delivery, result, replySessionID = sessionID) => {
+    await postDeliveryReply(currentDispatchConfig(), replySessionID, delivery, result);
   };
-  const acceptedUserTurn = async (rendered) => {
+  const typedPictures = new TypedPictures;
+  pi.on("input", async (event) => {
+    if (event.source !== "extension")
+      return;
+    const images = typedPictures.handOver(event.text);
+    return images === undefined ? undefined : { images: [...event.images ?? [], ...images] };
+  });
+  const runTypedInput = (sendUserInput, delivery, replySessionID, turn, content, pictureAddresses2) => {
+    const images = typeof content === "string" ? [] : content.filter((block) => block.type === "image");
+    const noted = sessionID;
+    if (images.length > 0) {
+      typedPictures.admit(turn.messageId, {
+        addresses: pictureAddresses2,
+        body: turn.body,
+        images,
+        sessionID: noted
+      });
+    }
+    noteTypedUserTurn(noted, turn.messageId);
+    notedSessionIDs.add(noted);
+    Promise.resolve().then(() => sendUserInput(turn.body, {
+      ...turn.mode === "aside" && { deliverAs: "aside" },
+      tag: turn.messageId
+    })).then((result) => {
+      const submitted = result.handled === "prompt" || result.handled === "skill";
+      if (submitted) {
+        typedPictures.inputPassed(turn.messageId);
+      } else {
+        dropInjectedUserTurn(noted, turn.messageId);
+        typedPictures.withdraw(turn.messageId);
+      }
+      return typedInputReply(turn.body, result);
+    }, (error48) => {
+      dropInjectedUserTurn(noted, turn.messageId);
+      typedPictures.withdraw(turn.messageId);
+      return typedInputReply(turn.body, { error: messageFor(error48) });
+    }).then(async (reply) => {
+      if (reply !== undefined)
+        await postDispatchReply(delivery, { body: reply }, replySessionID);
+    }).catch((error48) => {
+      logger3.warn("envoy: the reply to a person's typed input did not reach Dispatch", {
+        attempt: delivery.attempt,
+        error: messageFor(error48),
+        messageID: delivery.id
+      });
+    });
+  };
+  const acceptedUserTurn = async (rendered, acceptedSessionID) => {
     if (!isUserTurnCandidate(rendered))
       return;
     const { delivery } = rendered;
@@ -34494,13 +34714,14 @@ function envoyExtension(pi) {
       if (dispatch === undefined)
         return;
       const accepted = await dispatch.acceptMessageDelivery(delivery.id, delivery.attempt, {
-        actor: { id: sessionID, kind: "session" }
+        actor: { id: acceptedSessionID, kind: "session" }
       });
       const turn = turnFromAccept(accepted);
       if (turn === undefined) {
         logger3.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;
       }
-      return turn;
+      return { delivery, turn };
     } catch (error48) {
       logger3.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;
@@ -34562,20 +34783,34 @@ function envoyExtension(pi) {
             }
           }
         } else {
-          const turn = await acceptedUserTurn(rendered);
+          const acceptedSessionID = sessionID;
+          const accepted = await acceptedUserTurn(rendered, acceptedSessionID);
           const shown = shownPictures(sessionID);
-          if (turn === undefined) {
+          if (accepted === undefined) {
             const card = await withDeliveredPictures(rendered.content, rendered.pictures ?? [], () => timedDispatchClient(DELIVERY_PICTURES_TIMEOUT_MS), true, shown);
             pi.sendMessage({ customType: "envoy-message", content: card.content, display: true }, {
               deliverAs: rendered.delivery?.mode === "aside" ? "aside" : "steer",
               triggerTurn: true
             });
-            markPicturesShown(shown, card.shown);
+            markPicturesShown(shownPictures(sessionID), card.shown);
           } else {
+            const { turn } = accepted;
             const delivery = await withDeliveredPictures(turn.body, pictureAddresses(turn.body), () => timedDispatchClient(DELIVERY_PICTURES_TIMEOUT_MS), false, shown);
-            noteInjectedUserTurn(sessionID, turn.body, turn.messageId);
-            pi.sendUserMessage(delivery.content, turn.mode === "aside" ? { deliverAs: "aside" } : undefined);
-            markPicturesShown(shown, delivery.shown);
+            const sendUserInput = pi.sendUserInput;
+            if (sendUserInput === undefined) {
+              const refusal = typedInputReply(turn.body, { hostVersion: VERSION });
+              if (refusal !== undefined) {
+                await postDispatchReply(accepted.delivery, { body: refusal }, acceptedSessionID);
+              } else {
+                const injectionSessionID = sessionID;
+                noteInjectedUserTurn(injectionSessionID, turn.body, turn.messageId);
+                notedSessionIDs.add(injectionSessionID);
+                pi.sendUserMessage(delivery.content, turn.mode === "aside" ? { deliverAs: "aside" } : undefined);
+                markPicturesShown(shownPictures(injectionSessionID), delivery.shown);
+              }
+            } else {
+              runTypedInput(sendUserInput, accepted.delivery, acceptedSessionID, turn, delivery.content, delivery.shown);
+            }
           }
         }
       } catch (error48) {
@@ -34649,6 +34884,39 @@ function envoyExtension(pi) {
   });
   let agentStreamControl;
   let agentStreamControlSession = "";
+  let agentStreamCommandsRefreshedOnWatchAt = -Infinity;
+  let agentStreamViewerAttached = false;
+  const refreshAgentStreamCommands = (session) => {
+    if (typeof pi.sendUserInput !== "function")
+      return;
+    const builtins = hostBuiltinCommands?.() ?? [];
+    const reserved = new Set(builtins.flatMap((builtin) => [builtin.name, ...builtin.aliases]));
+    const live = host2.AgentRegistry?.global().list().find((ref) => ref.session?.sessionManager.getSessionId() === session)?.session;
+    const commands = builtins.map((builtin) => ({
+      description: builtin.description,
+      name: builtin.name,
+      source: "builtin",
+      ...builtin.terminalOnly && { terminalOnly: true }
+    }));
+    for (const command of [
+      ...pi.getCommands?.() ?? [],
+      ...[...live?.slashCommands ?? [], ...live?.promptTemplates ?? []].map((file2) => ({
+        description: file2.description,
+        name: file2.name,
+        source: "prompt"
+      }))
+    ]) {
+      if (reserved.has(command.name))
+        continue;
+      const description = typeof command.description === "string" ? { description: command.description } : {};
+      commands.push({
+        name: command.name,
+        source: command.source,
+        ...description
+      });
+    }
+    agentStream.setCommands(agentStreamFramesSubject(session), commands);
+  };
   const pumpAgentStreamControl = async (subscription, session) => {
     try {
       for await (const message of subscription) {
@@ -34659,9 +34927,24 @@ function envoyExtension(pi) {
           const request = parsed;
           if (request.type !== "replay" && request.type !== "watch")
             continue;
+          const attached = agentStreamViewerAttached;
+          if (request.type === "replay" || !attached || Date.now() - agentStreamCommandsRefreshedOnWatchAt >= AGENT_STREAM_WATCH_INTERVAL_MS) {
+            try {
+              refreshAgentStreamCommands(session);
+            } catch (error48) {
+              logger3.warn("envoy: could not refresh agent stream commands", {
+                error: messageFor(error48),
+                sessionID: session
+              });
+            }
+            if (request.type === "watch" && attached) {
+              agentStreamCommandsRefreshedOnWatchAt = Date.now();
+            }
+          }
           const reply = message.reply;
           const answer = request.type === "replay" && reply !== undefined ? JSON.stringify(agentStream.replay(session)) : undefined;
           agentStream.noteViewer();
+          agentStreamViewerAttached = true;
           if (answer === undefined || reply === undefined)
             continue;
           connection?.publish(reply, codec2.encode(answer));
@@ -34690,8 +34973,11 @@ function envoyExtension(pi) {
       return;
     agentStreamControl?.unsubscribe();
     agentStreamControl = undefined;
-    if (agentStreamControlSession !== session)
+    if (agentStreamControlSession !== session) {
       agentStream.reset();
+      agentStreamViewerAttached = false;
+      agentStreamCommandsRefreshedOnWatchAt = -Infinity;
+    }
     agentStreamControlSession = session;
     const active = await ensureConnection();
     const subscription = active.subscribe(agentStreamControlSubject(session));
@@ -34704,6 +34990,9 @@ function envoyExtension(pi) {
     agentStream.record(agentStreamFramesSubject(sessionID), message, streaming, matchInjectedUserTurn(sessionID, message));
   };
   pi.on("message_start", async (event) => {
+    const shown = typedPictures.started(event.message);
+    if (shown !== undefined)
+      markPicturesShown(shownPictures(sessionID), shown);
     recordAgentStreamMessage(event.message, true);
   });
   pi.on("message_update", async (event) => {

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

@@ -32,10 +32,19 @@ session with no issue (`POST /api/v1/agents/{session_id}/messages`) stays human-
 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
+own fresh message to you, and runs 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.
 
+A Send or Aside that starts with `/` runs as the command it names, as it would at your terminal:
+a prompt template or command file arrives as the user message it expands to, a `/skill:<name>`
+as that skill's prompt, and slash text that names no command as the words themselves; answer each
+as you would typed. A command that runs without reaching you (`/session`, `/compact`), or that
+did not run (one only your own terminal runs, such as `/new`), is answered on Dispatch by your
+plugin, as your reply to that message: what the command printed, or why it did not run. You
+receive nothing for it and write nothing for it. A command that prints and then submits a prompt
+(`/force:<tool> <prompt>`) gets the same reply, and you answer only the prompt it submitted.
+
 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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sjawhar/pi-envoy",
-  "version": "8.17.0",
+  "version": "9.0.0",
   "license": "Apache-2.0",
   "type": "module",
   "omp": {