@vellumai/assistant 0.11.1 → 0.11.2-staging.1

package/src/live-voice/live-activity-reporter.ts

@@ -109,21 +109,45 @@ export function phaseForFrame(
  */
 export class LiveActivityReporter {
   private lastPhase: LiveActivityPhase | null = null;
+  private lastDetail = "";
   private ended = false;
 
   constructor(private readonly conversationId: string) {}
 
   /**
-   * Report the phase a frame implies, if it changed. Fire-and-forget: callers
-   * are on the session's send path and must not await this.
+   * Report what a frame implies about the phase or the activity line, if
+   * either changed. Fire-and-forget: callers are on the session's send path
+   * and must not await this.
+   *
+   * Both travel in one dispatch because they are two fields of one content
+   * state: ActivityKit replaces the whole thing per push, so a dispatch that
+   * carried only the field that moved would blank the other.
    */
   report(frame: LiveVoiceServerFramePayload): void {
+    if (this.ended) {
+      return;
+    }
     const phase = phaseForFrame(frame, this.lastPhase);
-    if (phase === null || phase === this.lastPhase || this.ended) {
+    // The session sends this frame only on a change it wants surfaced, and
+    // sends an empty label when the turn stops working, so it is taken
+    // verbatim rather than derived.
+    const detail = frame.type === "activity" ? frame.label : this.lastDetail;
+    const phaseMoved = phase !== null && phase !== this.lastPhase;
+    if (!phaseMoved && detail === this.lastDetail) {
+      return;
+    }
+    if (phase !== null) {
+      this.lastPhase = phase;
+    }
+    this.lastDetail = detail;
+    // An activity line can arrive before any phase has been established (a
+    // turn whose first tool starts before the phase-bearing frame lands).
+    // There is no content state to attach it to yet, and the phase the next
+    // frame sets will carry it.
+    if (this.lastPhase === null) {
       return;
     }
-    this.lastPhase = phase;
-    void this.dispatch(phase, "update");
+    void this.dispatch(this.lastPhase, "update", this.lastDetail);
   }
 
   /**
@@ -139,13 +163,17 @@ export class LiveActivityReporter {
       return;
     }
     this.ended = true;
-    void this.dispatch("ending", "end");
+    // No detail on the way out: whatever the turn was doing, it is not doing
+    // it any more, and this state is the one that lingers on the Lock Screen
+    // through the dismissal window.
+    void this.dispatch("ending", "end", "");
   }
 
   /** `protected` so a test can observe what would be sent without sending it. */
   protected async dispatch(
     phase: LiveActivityPhase,
     event: "update" | "end",
+    detail: string,
   ): Promise<void> {
     try {
       const client = await VellumPlatformClient.create();
@@ -162,6 +190,7 @@ export class LiveActivityReporter {
           conversation_id: this.conversationId,
           phase,
           event,
+          detail,
         }),
       });
       if (!response.ok) {

package/src/live-voice/live-voice-session.ts

@@ -8,7 +8,6 @@ import {
 import { sanitizeForTts } from "../calls/tts-text-sanitizer.js";
 import {
   isIncompleteControlMarkerTail,
-  MINIMIZE_ROOM_MARKER,
   stripInternalSpeechMarkers,
 } from "../calls/voice-control-protocol.js";
 import type {
@@ -59,6 +58,11 @@ import { getToolOwner } from "../tools/registry.js";
 import { extractSpeakableSegments } from "../tts/speakable-segments.js";
 import { createAbortReason } from "../util/abort-reasons.js";
 import { getLogger } from "../util/logger.js";
+import {
+  activityLabelForTool,
+  dismissesUiSurface,
+  revealsUiSurface,
+} from "./activity-label.js";
 import {
   createVoiceFrontDecider,
   type VoiceFrontDecider,
@@ -478,9 +482,19 @@ interface ActiveAssistantTurn {
   progress: TurnProgressState;
   assistantCompleted: boolean;
   ttsDone: boolean;
-  // Latched when the leg's stream contains MINIMIZE_ROOM_MARKER; consumed
+  // Latched when the turn puts something on screen (a ui tool ran); consumed
   // once at TTS drain, where the minimize_room frame goes out after tts_done.
+  // Never set from anything the model says: the reveal is a consequence of
+  // showing a surface, not a token the model has to remember.
   minimizeRequested: boolean;
+  // The activity label the client was last told about, so a run of tools that
+  // map to the same line sends one frame rather than one per call. Empty means
+  // the client believes nothing is running, which is also where a turn ends.
+  activityLabel: string;
+  // Set while the turn is blocked on a decision the user has to make. Suppresses
+  // progress narration, whose entire vocabulary ("still on it", "almost there")
+  // describes work in flight and would be false here.
+  awaitingApproval: boolean;
   // A tts_audio frame actually went out to the client — latches on the first
   // forwarded chunk so the firstTtsAudio metric is marked exactly once per turn.
   ttsAudioStarted: boolean;
@@ -599,13 +613,16 @@ interface ActiveAssistantTurn {
  * runs forward from the emitted boundary — not from the last "[" — so
  * brackets INSIDE a streaming marker body (a JSON array or "]"-bearing string
  * in ASK_GUARDIAN_APPROVAL) can neither mask the marker's start nor pass as
- * its terminator. As a side effect the force flush latches the turn's
- * `minimizeRequested` when the completed stream ENDS with
- * MINIMIZE_ROOM_MARKER — terminal position only, matching the prompt's
- * "end the reply with it" contract, so a reply whose CONTENT happens to
- * contain "[-1]" (an array literal, a temperature) never minimizes the
- * room. The marker itself is stripped wherever it appears (the shared
- * marker-strip convention), so the latch is the only observable.
+ * its terminator.
+ *
+ * **Markers are stripped, never acted on.** Nothing the model can say
+ * minimizes the room any more: that is decided by whether a ui tool ran (see
+ * the `tool_use_start` handler), so the reveal cannot depend on the model
+ * remembering a token, and a reply whose content happens to contain "[-1]" (an
+ * array literal, a temperature) cannot move the room either. No prompt teaches
+ * a marker, so this stripping is defense against a model that emits one
+ * regardless: an unspoken, unpersisted "[-1]" is the correct handling of a
+ * token that now means nothing.
  */
 function createControlMarkerHoldback(
   turn: ActiveAssistantTurn,
@@ -613,13 +630,6 @@ function createControlMarkerHoldback(
 ): (raw: string, opts?: { force?: boolean }) => void {
   let emitted = 0;
   return (raw, opts) => {
-    if (
-      opts?.force === true &&
-      !turn.minimizeRequested &&
-      raw.trimEnd().endsWith(MINIMIZE_ROOM_MARKER)
-    ) {
-      turn.minimizeRequested = true;
-    }
     let safeEnd = raw.length;
     if (opts?.force !== true) {
       for (
@@ -644,30 +654,30 @@ function createControlMarkerHoldback(
 // barge-in, the interruption merge note is appended to it (see
 // buildInterruptionMergeNote) so the model reconciles the interrupted request
 // with the new utterance.
+// Spoken once when a turn starts waiting on the user's decision. Fixed rather
+// than generated: this is a statement about the system's state, not about the
+// work, and it has to be true every time. Kept in the shape of the progress
+// phrases it displaces (short, neutral, no claim about tools).
+const APPROVAL_PENDING_PHRASE = "I need your okay for that one. Take a look.";
+
 const LIVE_VOICE_CONTROL_PROMPT_BASE =
-  "You are speaking in a local live voice session. Keep replies brief and conversational. You cannot display cards, forms, or any on-screen UI during the call — convey everything in speech. ";
-
-// MINIMIZE_ROOM_MARKER teaching, appended for the legs that can actually put
-// something on screen — the main leg and the escalated leg. The front-door
-// (fast) leg never receives it: that leg is toolless, so it has nothing to
-// show, and its decision rule promises that apart from a leading verdict
-// token every character is spoken verbatim — teaching it the marker would
-// contradict that rule and could only produce spurious minimizes.
-//
-// The teaching deliberately keeps the no-interactive-UI rule intact
-// (live-voice turns are non-interactive, JARVIS-1291): the marker does not
-// render UI — it asks the client to reveal the screen the call overlay
-// covers. The gate in createControlMarkerHoldback strips it from speech, and
-// completeTtsForTurn sends the minimize_room frame only after the reply's
-// TTS drains, so "end your reply with it" is the whole contract the model
-// needs.
+  "You are speaking in a local live voice session. Keep replies brief and conversational. Speech is the main channel: say the answer, and do not narrate a surface instead of answering. You can also put something on screen when it genuinely helps (a form, a list to pick from, a progress card for long work); the call overlay minimizes by itself once you finish speaking, so the user sees it without doing anything. Never tell the user you cannot show them something. ";
+
+// Appended for the legs that can actually put something on screen: the main
+// leg and the escalated leg. The front-door (fast) leg never receives it, for
+// the same reason it never received the marker this replaces: that leg is
+// toolless, so it has nothing to show.
 //
-// The narration guidance is load-bearing: without it, the base prompt's
-// convey-everything-in-speech rule reads to the model as "the user can never
-// see the screen", and it minimizes the room while telling the user it has
-// no way to show them anything ("check it from the app later").
-const LIVE_VOICE_MINIMIZE_MARKER_TEACHING =
-  "The call renders as a full-screen overlay covering the app. If this reply created or changed something on screen worth looking at (an app, a page, a document), you may end the reply with the marker [-1]: after you finish speaking, the overlay minimizes so the user can see the screen while the call continues. The user is in the app and sees what you made the moment the overlay minimizes, so when you end with the marker, speak as if you are showing it to them right now (for example, close with something like: take a look) — never say you cannot show it, that you cannot display it because this is a voice call, or that they should check it later. Use it at most once per reply, only when there is genuinely something new to show, never speak the marker aloud or mention it, and never emit any other bracketed marker. ";
+// **The model no longer asks for the minimize; it is told one is coming.**
+// Revealing the screen used to be a marker the model emitted at the end of a
+// reply, which made "did the user see it" depend on the model remembering a
+// token. It is now a consequence of showing a surface at all: the session
+// latches the minimize when a ui tool runs, and the room opens after the
+// reply's speech drains. What is left for the prompt is the part only the
+// model can get right, which is speaking as though the thing is already in
+// front of the user, because by the time it stops talking it is.
+const LIVE_VOICE_SCREEN_REVEAL_TEACHING =
+  "The call renders as a full-screen overlay covering the app. Whenever you put something on screen, the overlay minimizes by itself as soon as you finish speaking, and the user is looking at what you made. So speak as if you are showing it to them right now (for example, close with something like: take a look), and never say you cannot show it, that this is a voice call, or that they should check it later. Never emit bracketed markers of any kind. ";
 
 // System-level guidance appended to a barge-in turn's control prompt so the
 // model treats the new utterance as a continuation of the request it was cut
@@ -726,8 +736,8 @@ function buildLiveDeliveryNote(request: string, answer: string): string {
 }
 
 // Assemble a leg's model-facing control prompt: the base live-voice rules,
-// the [-1] minimize teaching (withheld from the front-door leg — see
-// LIVE_VOICE_MINIMIZE_MARKER_TEACHING), the shared no-setup-flows rule, plus
+// the screen-reveal teaching (withheld from the front-door leg, see
+// LIVE_VOICE_SCREEN_REVEAL_TEACHING), the shared no-setup-flows rule, plus
 // any pending barge-in merge context, completed-continuation context, and/or
 // the announcement instruction. A turn can carry several (a barge-in follow-up
 // that also has a continuation result waiting); the notes are model-only and
@@ -738,7 +748,7 @@ function buildVoiceControlPrompt(
 ): string {
   let prompt =
     LIVE_VOICE_CONTROL_PROMPT_BASE +
-    (leg.frontDoor === true ? "" : LIVE_VOICE_MINIMIZE_MARKER_TEACHING) +
+    (leg.frontDoor === true ? "" : LIVE_VOICE_SCREEN_REVEAL_TEACHING) +
     VOICE_NO_SETUP_FLOWS_RULE;
   if (turn.interruptedRequest) {
     prompt = `${prompt}\n\n${buildInterruptionMergeNote(turn.interruptedRequest)}`;
@@ -1920,6 +1930,9 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
         "barge_in",
         turn.turnId,
       );
+      // A cancelled turn's tools are abandoned, not finished, so nothing will
+      // arrive to clear the line it left behind.
+      this.publishActivity(turn, "");
       await this.sendFrame({ type: "turn_cancelled", turnId: turn.turnId });
       await this.cancelAssistantTurn("barge_in");
       // Keep the interrupted turn's work alive on a background subagent; the
@@ -2317,6 +2330,82 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     }, drainMs + this.continuationAnnounceSilenceMs);
   }
 
+  /**
+   * The line describing what this turn is doing right now: the newest tool
+   * still running, or nothing when none is.
+   *
+   * Newest-first because parallel ops are the interesting case. A turn that
+   * starts a search and a file read, then finishes the search, is still
+   * reading a file, and a surface that went blank there would claim the turn
+   * had gone idle while it plainly has not.
+   */
+  private currentActivityLabel(turn: ActiveAssistantTurn): string {
+    for (let i = turn.progress.ops.length - 1; i >= 0; i -= 1) {
+      const op = turn.progress.ops[i];
+      if (op !== undefined && op.completedAtMs === undefined) {
+        return activityLabelForTool(op.toolName);
+      }
+    }
+    return "";
+  }
+
+  /**
+   * Open the room because a decision is waiting behind it.
+   *
+   * The approval card renders in the app, and the room covers the app, so
+   * without this the turn simply goes quiet: nothing is spoken, nothing is
+   * visible, and the only cue is a call that stopped talking. Sent
+   * immediately rather than latched for the drain the way a shown surface is,
+   * because there is no drain coming. The turn is blocked on this decision,
+   * and the whole point is that the user can make it now.
+   *
+   * The latch is cleared as well, so a turn that also showed a surface does
+   * not send a second minimize once its speech ends; the room is already open.
+   */
+  private revealRoomForPendingApproval(turn: ActiveAssistantTurn): void {
+    if (turn.awaitingApproval) {
+      return;
+    }
+    turn.awaitingApproval = true;
+    turn.minimizeRequested = false;
+    void this.sendFrame(
+      { type: "minimize_room", turnId: turn.turnId },
+      () => !this.isClosed,
+    );
+    // Spoken, because opening the room is only a cue for someone looking at
+    // the screen, and the case this exists for is a phone the user has put
+    // down. One line, not narration: the turn is not working, it is waiting,
+    // and it says which.
+    this.enqueueFillerPhrase(turn, APPROVAL_PENDING_PHRASE);
+  }
+
+  /** Clear the wait once a decision lands, so the turn narrates normally again. */
+  private clearAwaitingApproval(turn: ActiveAssistantTurn): void {
+    turn.awaitingApproval = false;
+  }
+
+  /**
+   * Tell the client what the turn is doing, if it changed.
+   *
+   * De-duplicated for the same reason the Live Activity reporter de-duplicates
+   * phases: this frame reaches ActivityKit, whose update budget is finite and
+   * whose overflow is dropped silently, and a turn that runs four file reads in
+   * a row would otherwise spend that budget restating one line.
+   *
+   * Fire-and-forget. An activity label is a flourish, and nothing about the
+   * conversation may wait on one.
+   */
+  private publishActivity(turn: ActiveAssistantTurn, label: string): void {
+    if (turn.activityLabel === label) {
+      return;
+    }
+    turn.activityLabel = label;
+    void this.sendFrame(
+      { type: "activity", turnId: turn.turnId, label },
+      () => !this.isClosed,
+    );
+  }
+
   private clearActiveAssistantTurn(token: symbol): void {
     if (this.activeAssistantTurn?.token !== token) {
       return;
@@ -3409,6 +3498,8 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
       assistantCompleted: false,
       ttsDone: false,
       minimizeRequested: false,
+      activityLabel: "",
+      awaitingApproval: false,
       ttsAudioStarted: false,
       finalized: false,
       speculativePending: opts?.speculative === true,
@@ -3610,6 +3701,12 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
         voiceControlPrompt: buildVoiceControlPrompt(activeTurn, {
           ...(leg.frontDoor !== undefined ? { frontDoor: leg.frontDoor } : {}),
         }),
+        onApprovalPending: () => {
+          this.revealRoomForPendingApproval(activeTurn);
+        },
+        onApprovalsResolved: () => {
+          this.clearAwaitingApproval(activeTurn);
+        },
         content: leg.content,
         isInbound: true,
         launchedAtMs: activeTurn.launchedAtMs,
@@ -3835,6 +3932,7 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
             });
             current.progress.opsSinceNarration += 1;
             current.progress.stateEpoch += 1;
+            this.publishActivity(current, this.currentActivityLabel(current));
             log.debug({ turnId, toolName }, "Live voice turn started tool use");
             // Definitive tool use means the turn is guaranteed slow: speak
             // the floor-holding ack now instead of waiting out the
@@ -3888,6 +3986,28 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
               }
             }
             current.progress.stateEpoch += 1;
+            // Showing a surface implies revealing it: the room is a
+            // full-screen overlay, so a surface rendered behind it is a
+            // surface nobody sees.
+            //
+            // **Latched on the result, not the tool start.** A ui call can be
+            // rejected (no `surface_type`, an empty card, a client that never
+            // acks), and a reveal driven by the attempt would minimize the room
+            // to show nothing at all. Only a call that came back without an
+            // error actually put something on screen.
+            //
+            // A dismissal clears it again, so a turn that shows a surface and
+            // then takes it away does not reveal an empty screen. Last write
+            // wins, which is the right reading of "what did this turn leave up"
+            // without tracking surfaces individually.
+            if (event.isError !== true) {
+              if (revealsUiSurface(event.toolName)) {
+                current.minimizeRequested = true;
+              } else if (dismissesUiSurface(event.toolName)) {
+                current.minimizeRequested = false;
+              }
+            }
+            this.publishActivity(current, this.currentActivityLabel(current));
             this.maybeNarrateProgress(current, trigger);
           },
         },
@@ -4259,6 +4379,10 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
     return (
       this.isActiveAssistantTurn(turn.token) &&
       !turn.assistantCompleted &&
+      // Nothing is in flight while a decision is pending, so every phrase
+      // narration has would be a lie about who the call is waiting on. The
+      // turn says so once, when it starts waiting, and is quiet after that.
+      !turn.awaitingApproval &&
       this.turnAudioIdle(turn)
     );
   }
@@ -4569,6 +4693,12 @@ export class LiveVoiceSession implements LiveVoiceSessionContract {
             !this.isClosed,
         );
 
+        // The turn is over, so nothing is running. Ordinarily the line is
+        // already clear (the last tool_result cleared it); this is the net
+        // for a turn that ends with an op still open, which would otherwise
+        // leave the last tool it touched on screen through the next silence.
+        this.publishActivity(currentTurn, "");
+
         // Drain-scoped minimize: the latched marker is consumed here, after
         // the turn's speech has fully drained — never mid-speech, never for
         // a barged-in turn, at most once per turn.

package/src/live-voice/protocol.ts

@@ -18,6 +18,7 @@ const _LIVE_VOICE_SERVER_FRAME_TYPES = [
   "stt_partial",
   "stt_final",
   "thinking",
+  "activity",
   "assistant_text_delta",
   "tts_audio",
   "tts_done",
@@ -217,6 +218,26 @@ export interface LiveVoiceThinkingServerFrame extends LiveVoiceServerFrameBase {
   readonly turnId: string;
 }
 
+/**
+ * What the assistant is doing inside a turn, as one short user-facing line.
+ *
+ * Exists because a live-voice turn can go silent for a long time while it
+ * works, and the surfaces that show the session (the iOS Live Activity, and
+ * the room) can otherwise only say "Thinking...". The label is composed here
+ * rather than by each surface for the same reason phase wording is composed
+ * once: the Live Activity has two independent drivers (this socket and an APNs
+ * push the daemon dispatches), they must carry identical content, and the only
+ * way to guarantee that is for both to be handed the same string.
+ *
+ * An empty `label` means "no current activity", which is what a turn's end
+ * sends. Emitted only on change, never per tool result.
+ */
+export interface LiveVoiceActivityServerFrame extends LiveVoiceServerFrameBase {
+  readonly type: "activity";
+  readonly turnId: string;
+  readonly label: string;
+}
+
 export interface LiveVoiceAssistantTextDeltaServerFrame extends LiveVoiceServerFrameBase {
   readonly type: "assistant_text_delta";
   readonly text: string;
@@ -321,6 +342,7 @@ export type LiveVoiceServerFrame =
   | LiveVoiceSttPartialServerFrame
   | LiveVoiceSttFinalServerFrame
   | LiveVoiceThinkingServerFrame
+  | LiveVoiceActivityServerFrame
   | LiveVoiceAssistantTextDeltaServerFrame
   | LiveVoiceTtsAudioServerFrame
   | LiveVoiceTtsDoneServerFrame
@@ -341,6 +363,7 @@ export type LiveVoiceServerFramePayload =
   | WithoutSeq<LiveVoiceSttPartialServerFrame>
   | WithoutSeq<LiveVoiceSttFinalServerFrame>
   | WithoutSeq<LiveVoiceThinkingServerFrame>
+  | WithoutSeq<LiveVoiceActivityServerFrame>
   | WithoutSeq<LiveVoiceAssistantTextDeltaServerFrame>
   | WithoutSeq<LiveVoiceTtsAudioServerFrame>
   | WithoutSeq<LiveVoiceTtsDoneServerFrame>

package/src/messaging/providers/slack/__tests__/adapter-mention-rendering.test.ts

@@ -31,12 +31,13 @@ mock.module("../../../../contacts/contacts-write.js", () => ({
 }));
 
 import {
-  __resetSlackUserInfoCacheForTests,
+  __resetSlackMentionCachesForTests,
   slackProvider,
 } from "../adapter.js";
 
 const originalFetch = globalThis.fetch;
 let userInfoCalls: string[] = [];
+let channelInfoCalls: string[] = [];
 
 function installFetchStub() {
   globalThis.fetch = (async (
@@ -63,7 +64,49 @@ function fakeSlackResponse(url: string): Record<string, unknown> {
   const parsed = new URL(url);
   const method = parsed.pathname.split("/").at(-1);
 
+  if (method === "conversations.info") {
+    const channelId = parsed.searchParams.get("channel") ?? "";
+    channelInfoCalls.push(channelId);
+    if (channelId === "CPRODMODELS1") {
+      return {
+        ok: true,
+        channel: { id: "CPRODMODELS1", name: "prod-models" },
+      };
+    }
+    return { ok: false, error: "channel_not_found" };
+  }
+
   if (method === "conversations.history") {
+    if (parsed.searchParams.get("channel") === "C_CHANNEL_MENTIONS") {
+      return {
+        ok: true,
+        has_more: false,
+        messages: [
+          {
+            type: "message",
+            ts: "1700000009.001000",
+            user: "USENDER",
+            text: "post in <#CPRODMODELS1> and <#COTHER1|other-name> please",
+          },
+        ],
+      };
+    }
+
+    if (parsed.searchParams.get("channel") === "C_PRIVATE_MENTION") {
+      return {
+        ok: true,
+        has_more: false,
+        messages: [
+          {
+            type: "message",
+            ts: "1700000010.001100",
+            user: "USENDER",
+            text: "see <#CINVISIBLE1> for details",
+          },
+        ],
+      };
+    }
+
     if (parsed.searchParams.get("channel") === "C_USERINFO_FAIL") {
       return {
         ok: true,
@@ -318,8 +361,9 @@ function makeOAuthConnection(
 
 describe("Slack adapter mention rendering", () => {
   beforeEach(async () => {
-    __resetSlackUserInfoCacheForTests();
+    __resetSlackMentionCachesForTests();
     userInfoCalls = [];
+    channelInfoCalls = [];
     getSecureKeyAsyncMock.mockReset();
     getSecureKeyAsyncMock.mockImplementation(async (key: string) => {
       if (key === credentialKey("slack_channel", "bot_token")) {
@@ -516,6 +560,44 @@ describe("Slack adapter mention rendering", () => {
     });
   });
 
+  test("getHistory renders inline channel mentions without rebinding the message's own channel", async () => {
+    // A message read from channel A that mentions channels B and C: the
+    // message stays attributed to A while the inline mentions render B/C.
+    const messages = await slackProvider.getHistory(
+      undefined,
+      "C_CHANNEL_MENTIONS",
+    );
+
+    expect(messages).toHaveLength(1);
+    // Bare token resolves via conversations.info; pipe token uses its own
+    // embedded label with no lookup.
+    expect(messages[0].text).toBe(
+      "post in #prod-models and #other-name please",
+    );
+    expect(messages[0].conversationId).toBe("C_CHANNEL_MENTIONS");
+    expect(channelInfoCalls).toEqual(["CPRODMODELS1"]);
+  });
+
+  test("getHistory falls back to #unknown-channel for channels this auth cannot see, and caches the failure", async () => {
+    const first = await slackProvider.getHistory(
+      undefined,
+      "C_PRIVATE_MENTION",
+    );
+    const second = await slackProvider.getHistory(
+      undefined,
+      "C_PRIVATE_MENTION",
+    );
+
+    expect(first[0].text).toBe("see #unknown-channel for details");
+    expect(second[0].text).toBe("see #unknown-channel for details");
+    expect(first[0].text).not.toContain("CINVISIBLE1");
+    // channel_not_found is a definitive answer for this auth: one lookup,
+    // not one per history read.
+    expect(channelInfoCalls.filter((id) => id === "CINVISIBLE1")).toHaveLength(
+      1,
+    );
+  });
+
   test("getThreadReplies renders Slack user mentions for model-facing text without changing sender identity", async () => {
     const messages = await slackProvider.getThreadReplies!(
       undefined,