@vellumai/assistant 0.12.2-staging.2 → 0.12.2-staging.4

package/src/__tests__/mcp-list-plugin-servers.test.ts

@@ -8,38 +8,35 @@
  *
  * 1. A workspace entry of the same id wins. Getting precedence backwards
  *    would let a plugin redirect a server the user configured by hand.
- * 2. A plugin server is never health-checked. `McpClient.connect` resolves
- *    `mcp:<serverId>:headers` and `mcp:<serverId>:tokens` from the
- *    credential store, and a plugin controls both its server key and its
- *    URL, so probing one would send a workspace credential to an endpoint
- *    the plugin chose whenever an id happens to match a stored key.
+ * 2. A plugin server is never health-checked as a side effect of listing.
+ *    OAuth status is read from the plugin and endpoint-scoped credential
+ *    identity, while workspace static headers remain isolated.
  */
 
 import { mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { beforeEach, describe, expect, jest, mock, test } from "bun:test";
 
-const mockConnect = jest.fn();
-const mockDisconnect = jest.fn();
-/** Server ids the route actually constructed an MCP client for. */
-const connectedServerIds: string[] = [];
+const getServerState = jest.fn();
+const hasMcpOAuthTokens = jest.fn(async (target: any) => {
+  if (target.source === "plugin" && target.url === "not a url") {
+    throw new TypeError("invalid URL");
+  }
+  return true;
+});
 
 mock.module("../mcp/client.js", () => ({
   McpClient: class {
-    constructor(serverId: string) {
-      connectedServerIds.push(serverId);
-    }
-    get isConnected() {
-      return true;
+    constructor() {
+      throw new Error("list route must not construct an MCP client");
     }
-    get lastError() {
-      return null;
-    }
-    connect = mockConnect;
-    disconnect = mockDisconnect;
   },
 }));
 
+mock.module("../mcp/manager.js", () => ({
+  getMcpServerManager: () => ({ getServerState }),
+}));
+
 mock.module("../mcp/mcp-auth-orchestrator.js", () => ({
   orchestrateMcpOAuthConnect: async () => ({
     auth_url: "",
@@ -52,9 +49,7 @@ mock.module("../mcp/mcp-auth-state.js", () => ({
 }));
 
 mock.module("../mcp/mcp-oauth-provider.js", () => ({
-  // Stand in for a credential store that holds tokens for every id, which
-  // is the condition under which a leak would be observable.
-  hasMcpOAuthTokens: async () => true,
+  hasMcpOAuthTokens,
   deleteMcpOAuthCredentials: async () => ({ ok: true, failedKeys: [] }),
 }));
 
@@ -108,6 +103,19 @@ function writePlugin(name: string, mcpJson: unknown): void {
   writeFileSync(join(dir, "mcp.json"), JSON.stringify(mcpJson));
 }
 
+function writeStandardPlugin(name: string, mcpJson: unknown): void {
+  const dir = join(getWorkspacePluginsDir(), name);
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(
+    join(dir, "plugin.json"),
+    JSON.stringify({
+      $schema: "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
+      name,
+    }),
+  );
+  writeFileSync(join(dir, "mcp.json"), JSON.stringify(mcpJson));
+}
+
 function unabyssManifest(): unknown {
   return {
     mcpServers: {
@@ -123,9 +131,8 @@ async function listServers(): Promise<ListedServer[]> {
 
 describe("internal_mcp_list, plugin-declared servers", () => {
   beforeEach(() => {
-    mockConnect.mockReset();
-    mockDisconnect.mockReset();
-    connectedServerIds.length = 0;
+    getServerState.mockReset();
+    hasMcpOAuthTokens.mockClear();
     rmSync(getWorkspacePluginsDir(), { recursive: true, force: true });
     mkdirSync(getWorkspacePluginsDir(), { recursive: true });
   });
@@ -138,6 +145,14 @@ describe("internal_mcp_list, plugin-declared servers", () => {
     expect(ids).toContain("unabyss");
   });
 
+  test("a standard-only plugin keeps its server identity", async () => {
+    writeStandardPlugin("unabyss", unabyssManifest());
+
+    const plugin = (await listServers()).find((s) => s.id === "unabyss")!;
+    expect(plugin.source).toBe("plugin");
+    expect(plugin.pluginName).toBe("unabyss");
+  });
+
   test("plugin servers are labelled with their origin, workspace servers are not", async () => {
     writePlugin("unabyss", unabyssManifest());
 
@@ -171,20 +186,36 @@ describe("internal_mcp_list, plugin-declared servers", () => {
     const servers = await listServers();
 
     expect(servers.find((s) => s.id === "unabyss")!.status).toEqual("declared");
-    // The credential mocks above return a token and an Authorization header
-    // for every id. Constructing a client for the plugin server is what
-    // would ship them to the plugin-declared URL.
-    expect(connectedServerIds).toContain("from-workspace");
-    expect(connectedServerIds).not.toContain("unabyss");
+    expect(getServerState).toHaveBeenCalledWith("from-workspace", "workspace");
+    expect(getServerState).toHaveBeenCalledWith("unabyss", "plugin");
   });
 
-  test("plugin servers report no assistant-owned auth even when the store has some", async () => {
+  test("plugin status uses only state recorded for the plugin source", async () => {
+    writePlugin("unabyss", unabyssManifest());
+    getServerState.mockImplementation(
+      (serverId: string, source: "workspace" | "plugin") =>
+        serverId === "unabyss" && source === "plugin" ? "connected" : undefined,
+    );
+
+    const plugin = (await listServers()).find((s) => s.id === "unabyss")!;
+    expect(plugin.status).toBe("connected");
+  });
+
+  test("plugin servers report endpoint-scoped OAuth without static auth", async () => {
     writePlugin("unabyss", unabyssManifest());
 
     const plugin = (await listServers()).find((s) => s.id === "unabyss")!;
-    expect(plugin.hasOAuth).toBe(false);
+    expect(plugin.hasOAuth).toBe(true);
     expect(plugin.hasStaticAuth).toBe(false);
     expect(plugin.authType).toEqual("none");
+    expect(hasMcpOAuthTokens).toHaveBeenCalledWith(
+      expect.objectContaining({
+        source: "plugin",
+        pluginName: "unabyss",
+        serverKey: "unabyss",
+        url: "https://mcp.unabyss.com",
+      }),
+    );
   });
 
   test("workspace servers keep reporting their auth state", async () => {
@@ -225,6 +256,20 @@ describe("internal_mcp_list, plugin-declared servers", () => {
     expect(ids).toContain("from-workspace");
   });
 
+  test("an invalid plugin transport URL does not break the listing", async () => {
+    writePlugin("bad-url", {
+      mcpServers: {
+        remote: { type: "streamable-http", url: "not a url" },
+      },
+    });
+
+    const servers = await listServers();
+    expect(servers.find((s) => s.id === "bad-url__remote")?.hasOAuth).toBe(
+      false,
+    );
+    expect(servers.some((s) => s.id === "from-workspace")).toBe(true);
+  });
+
   test("no plugins installed leaves the listing unchanged", async () => {
     const servers = await listServers();
     expect(servers.every((s) => s.source === "workspace")).toBe(true);

package/src/__tests__/mcp-tool-annotations-risk.test.ts

@@ -32,10 +32,12 @@ const { RiskLevel } = await import("../permissions/types.js");
 type ServerSource = "workspace" | "plugin";
 
 function serverConfig(source: ServerSource) {
-  return {
+  const base = {
     transport: { type: "stdio" as const, command: "echo", args: [] },
-    source,
   };
+  return source === "workspace"
+    ? { ...base, source }
+    : { ...base, source, pluginName: "plugin", serverKey: "server" };
 }
 
 interface RiskAnnotations {

package/src/__tests__/skills.test.ts

@@ -1054,6 +1054,16 @@ describe("ingress-dependent setup skills declare public-ingress intentionally",
     expect(includes ?? []).not.toContain("public-ingress");
   });
 
+  test("telegram-setup documents the private-chat limitation", () => {
+    const content = readFileSync(
+      join(FIRST_PARTY_SKILLS_DIR, "telegram-setup", "SKILL.md"),
+      "utf-8",
+    );
+    expect(content).toMatch(/private-chat only/i);
+    expect(content).toMatch(/group, supergroup, and channel/i);
+    expect(content).toMatch(/button taps/i);
+  });
+
   test("twilio-setup includes public-ingress", () => {
     const includes = readSkillIncludes(FIRST_PARTY_SKILLS_DIR, "twilio-setup");
     expect(includes).toBeDefined();

package/src/__tests__/user-plugin-loader.test.ts

@@ -93,6 +93,27 @@ describe("user plugin loader", () => {
     expect(initHooks).toHaveLength(1);
   });
 
+  test("loads a plugin via a standard plugin.json manifest", async () => {
+    const pluginDir = join(PLUGINS_DIR, "standard-plugin");
+    mkdirSync(join(pluginDir, "hooks"), { recursive: true });
+    writeFileSync(
+      join(pluginDir, "plugin.json"),
+      JSON.stringify({
+        $schema: "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
+        name: "standard-plugin",
+        version: "1.0.0",
+      }),
+    );
+    writeFileSync(
+      join(pluginDir, "hooks", "init.ts"),
+      "export default async function init(_ctx: unknown): Promise<void> {}\n",
+    );
+
+    await loadUserPlugins();
+
+    expect(await getUserHooksFor("init")).toHaveLength(1);
+  });
+
   test("per-plugin failure is isolated: other plugins still load", async () => {
     // Plugin A has a malformed package.json; the loader must isolate the
     // failure and still load the healthy sibling.

package/src/acp/session-snapshot.ts

@@ -0,0 +1,260 @@
+import { desc, eq } from "drizzle-orm";
+
+import { getDb } from "../persistence/db-connection.js";
+import { acpSessionHistory } from "../persistence/schema/index.js";
+import { getLogger } from "../util/logger.js";
+import { acpAuthMarkerStillCurrent } from "./acp-auth-marker-store.js";
+import { getAcpSessionManager } from "./index.js";
+import type { AcpSessionManager } from "./session-manager.js";
+import type { AcpSessionState } from "./types.js";
+
+const log = getLogger("acp:session-snapshot");
+
+export interface AcpSessionSnapshot {
+  id: string;
+  agentId: string;
+  acpSessionId: string;
+  parentConversationId: string;
+  status: string;
+  startedAt: number;
+  completedAt?: number | null;
+  error?: string | null;
+  stopReason?: string | null;
+  task?: string;
+  parentToolUseId?: string;
+  authErrorCode?: string;
+  authErrorCredential?: string;
+  model?: string;
+  availableModels?: AcpSessionState["availableModels"];
+  modelRevisionEpoch?: string;
+  modelRevision?: number;
+  usedTokens?: number;
+  contextSize?: number;
+  costAmount?: number;
+  costCurrency?: string;
+  inputTokens?: number;
+  outputTokens?: number;
+  eventLog?: unknown[];
+  source: "live" | "history";
+  resumable: boolean;
+  cwd?: string | null;
+}
+
+export interface AcpSessionSnapshotPage {
+  sessions: AcpSessionSnapshot[];
+  sawEveryHistoryRow: boolean;
+}
+
+interface SnapshotOptions {
+  includeEventLog?: boolean;
+}
+
+function fromLiveState(
+  state: AcpSessionState,
+  manager: AcpSessionManager,
+  opts: SnapshotOptions,
+): AcpSessionSnapshot {
+  return {
+    id: state.id,
+    agentId: state.agentId,
+    acpSessionId: state.acpSessionId,
+    parentConversationId: state.parentConversationId,
+    status: state.status,
+    startedAt: state.startedAt,
+    completedAt: state.completedAt ?? null,
+    error: state.error ?? null,
+    stopReason: state.stopReason ?? null,
+    task: state.task,
+    parentToolUseId: state.parentToolUseId,
+    authErrorCode: state.authErrorCode,
+    authErrorCredential: state.authErrorCredential,
+    model: state.model,
+    availableModels: state.availableModels,
+    modelRevisionEpoch: state.modelRevisionEpoch,
+    modelRevision: state.modelRevision,
+    usedTokens: state.latestUsage?.usedTokens,
+    contextSize: state.latestUsage?.contextSize,
+    costAmount: state.latestUsage?.costAmount,
+    costCurrency: state.latestUsage?.costCurrency,
+    inputTokens: state.latestUsage?.inputTokens,
+    outputTokens: state.latestUsage?.outputTokens,
+    eventLog: opts.includeEventLog
+      ? manager.getBufferedUpdates(state.id)
+      : undefined,
+    source: "live",
+    resumable: false,
+  };
+}
+
+function isResumableHistoryRow(
+  row: typeof acpSessionHistory.$inferSelect,
+): boolean {
+  return Boolean(row.cwd && row.acpSessionId);
+}
+
+export function snapshotHistoryRow(
+  row: typeof acpSessionHistory.$inferSelect,
+  opts: SnapshotOptions = { includeEventLog: true },
+): AcpSessionSnapshot {
+  let eventLog: unknown[] | undefined;
+  if (opts.includeEventLog !== false) {
+    eventLog = [];
+    try {
+      const parsed = JSON.parse(row.eventLogJson) as unknown;
+      if (Array.isArray(parsed)) {
+        eventLog = parsed;
+      }
+    } catch (err) {
+      log.warn(
+        { id: row.id, err },
+        "Failed to parse event_log_json for ACP session history row",
+      );
+    }
+  }
+
+  return {
+    id: row.id,
+    agentId: row.agentId,
+    acpSessionId: row.acpSessionId,
+    parentConversationId: row.parentConversationId,
+    status: row.status,
+    startedAt: row.startedAt,
+    completedAt: row.completedAt,
+    error: row.error,
+    stopReason: row.stopReason,
+    task: row.task ?? undefined,
+    parentToolUseId: row.parentToolUseId ?? undefined,
+    authErrorCode: row.authErrorCode ?? undefined,
+    authErrorCredential: row.authErrorCredential ?? undefined,
+    usedTokens: row.usedTokens ?? undefined,
+    contextSize: row.contextSize ?? undefined,
+    costAmount: row.costAmount ?? undefined,
+    costCurrency: row.costCurrency ?? undefined,
+    inputTokens: row.inputTokens ?? undefined,
+    outputTokens: row.outputTokens ?? undefined,
+    eventLog,
+    source: "history",
+    resumable: isResumableHistoryRow(row),
+    cwd: row.cwd,
+  };
+}
+
+/**
+ * Blank `authErrorCode` on any session whose marker no longer describes the
+ * credential its agent would resolve.
+ *
+ * This comparison is what retires a Connect card: the marker no longer
+ * describing the credential in use. Applied after merging rather than inside
+ * the query, so live sessions and history rows are judged by the same rule.
+ *
+ * Resolved per agent and memoised across the batch, because precedence is per
+ * agent and each resolution costs a vault read.
+ */
+export async function withCurrentAuthMarkers<
+  T extends {
+    agentId: string;
+    authErrorCode?: string;
+    authErrorCredential?: string;
+  },
+>(
+  sessions: readonly T[],
+  resolvedFor: (agentId: string) => Promise<string | undefined>,
+): Promise<T[]> {
+  if (!sessions.some((session) => session.authErrorCode !== undefined)) {
+    return [...sessions];
+  }
+  const resolvedByAgent = new Map<string, string | undefined>();
+  const resolve = async (agentId: string) => {
+    if (!resolvedByAgent.has(agentId)) {
+      resolvedByAgent.set(agentId, await resolvedFor(agentId));
+    }
+    return resolvedByAgent.get(agentId);
+  };
+  const judged: T[] = [];
+  for (const session of sessions) {
+    if (session.authErrorCode === undefined) {
+      judged.push(session);
+      continue;
+    }
+    const current = acpAuthMarkerStillCurrent(
+      session.authErrorCredential,
+      await resolve(session.agentId),
+    );
+    judged.push(
+      current ? session : { ...session, authErrorCode: undefined },
+    );
+  }
+  return judged;
+}
+
+export function getAcpSessionSnapshot(
+  acpSessionId: string,
+  opts: SnapshotOptions = {},
+): AcpSessionSnapshot | undefined {
+  const manager = getAcpSessionManager();
+  const snapshotOptions = {
+    includeEventLog: opts.includeEventLog ?? true,
+  };
+  const live = (manager.getStatus() as AcpSessionState[]).find(
+    (state) => state.id === acpSessionId,
+  );
+  if (live) {
+    return fromLiveState(live, manager, snapshotOptions);
+  }
+
+  const row = getDb()
+    .select()
+    .from(acpSessionHistory)
+    .where(eq(acpSessionHistory.id, acpSessionId))
+    .get();
+  return row ? snapshotHistoryRow(row, snapshotOptions) : undefined;
+}
+
+export function listAcpSessionSnapshots(opts: {
+  limit: number;
+  conversationId?: string;
+  includeEventLog?: boolean;
+}): AcpSessionSnapshotPage {
+  const manager = getAcpSessionManager();
+  const inMemory = manager.getStatus() as AcpSessionState[];
+  const snapshotOptions = {
+    includeEventLog: opts.includeEventLog ?? true,
+  };
+
+  const merged = new Map<string, AcpSessionSnapshot>();
+  for (const state of inMemory) {
+    if (
+      opts.conversationId &&
+      state.parentConversationId !== opts.conversationId
+    ) {
+      continue;
+    }
+    merged.set(state.id, fromLiveState(state, manager, snapshotOptions));
+  }
+
+  const db = getDb();
+  const baseQuery = db.select().from(acpSessionHistory);
+  const filtered = opts.conversationId
+    ? baseQuery.where(
+        eq(acpSessionHistory.parentConversationId, opts.conversationId),
+      )
+    : baseQuery;
+  const historyLimit = opts.limit + merged.size;
+  const historyRows = filtered
+    .orderBy(desc(acpSessionHistory.startedAt))
+    .limit(historyLimit)
+    .all();
+
+  for (const row of historyRows) {
+    if (!merged.has(row.id)) {
+      merged.set(row.id, snapshotHistoryRow(row, snapshotOptions));
+    }
+  }
+
+  return {
+    sessions: Array.from(merged.values()).sort(
+      (a, b) => b.startedAt - a.startedAt,
+    ),
+    sawEveryHistoryRow: historyRows.length < historyLimit,
+  };
+}

package/src/apps/app-store.ts

@@ -43,6 +43,7 @@ import type { EditEngineResult } from "../tools/shared/filesystem/edit-engine.js
 import { applyEdit } from "../tools/shared/filesystem/edit-engine.js";
 import { getLogger } from "../util/logger.js";
 import { getDataDir, getWorkspacePluginsDir } from "../util/platform.js";
+import { hasPluginManifest } from "../util/plugin-manifest.js";
 
 const log = getLogger("app-store");
 
@@ -787,8 +788,8 @@ function listAppsForPlugin(
  * `<workspace>/plugins/<name>/apps/`.
  *
  * Plugin discovery mirrors the plugin loader's `scanPlugins`: a plugin is an
- * entry that resolves to a directory (following symlinks) and carries a
- * `package.json` manifest. Stray directories without a manifest are ignored,
+ * entry that resolves to a directory (following symlinks) and carries a root
+ * plugin manifest. Stray directories without a manifest are ignored,
  * and disabled plugins (those with a `.disabled` sentinel) contribute nothing,
  * matching how their other surfaces (tools, hooks, routes) are gated.
  */
@@ -813,7 +814,7 @@ export function listPluginApps(): EnumeratedApp[] {
     } catch {
       continue;
     }
-    if (!existsSync(join(pluginDir, "package.json"))) {
+    if (!hasPluginManifest(pluginDir)) {
       continue;
     }
     if (isPluginDisabled(name)) {
@@ -874,7 +875,7 @@ function isSafeIdSegment(segment: string): boolean {
  * (`plugins~<name>~<app>`, resolved by direct path build). Returns null when
  * the app does not exist, when the id is not a safe path segment, or when a
  * plugin id fails the same installed-plugin gates as discovery (directory,
- * `package.json` manifest, not disabled).
+ * root manifest, not disabled).
  */
 export function resolveAppSource(id: string): ResolvedAppSource | null {
   if (id.startsWith(PLUGIN_APP_ID_PREFIX)) {
@@ -900,7 +901,7 @@ export function resolveAppSource(id: string): ResolvedAppSource | null {
     } catch {
       return null;
     }
-    if (!existsSync(join(pluginDir, "package.json"))) {
+    if (!hasPluginManifest(pluginDir)) {
       return null;
     }
     if (isPluginDisabled(pluginName)) {

package/src/browser/operations.ts

@@ -32,7 +32,8 @@ import {
 } from "../tools/browser/browser-execution.js";
 import { browserManager } from "../tools/browser/browser-manager.js";
 import { normalizeBrowserMode } from "../tools/browser/browser-mode.js";
-import type { ToolContext, ToolExecutionResult } from "../tools/types.js";
+import type { ToolExecutionResult } from "../tools/types.js";
+import type { BrowserOperationContext as ToolContext } from "./types.js";
 import type { BrowserOperation } from "./types.js";
 
 // ── Dispatch handlers ────────────────────────────────────────────────

package/src/browser/types.ts

@@ -1,3 +1,10 @@
+import type { ScopedCdpClient } from "../tools/browser/cdp-client/types.js";
+import type { ToolContext } from "../tools/types.js";
+
+export interface BrowserOperationContext extends ToolContext {
+  cdpClient?: ScopedCdpClient;
+}
+
 /**
  * Canonical browser operation identifiers and typed metadata.
  *

package/src/browser/virtual-desktop-target.ts

@@ -0,0 +1,34 @@
+import { getConfig } from "../config/loader.js";
+import { isVirtualDesktopEnabled } from "../desktop/virtual-desktop-feature.js";
+import { browserManager } from "../tools/browser/browser-manager.js";
+import { normalizeBrowserMode } from "../tools/browser/browser-mode.js";
+import { getPinnedTab } from "../tools/browser/pinned-tabs.js";
+import type { ToolContext } from "../tools/types.js";
+
+export function shouldUseVirtualDesktopBrowser(
+  desktop: boolean | undefined,
+  input: Record<string, unknown>,
+  context: ToolContext,
+): boolean {
+  if (desktop !== undefined) {
+    return desktop;
+  }
+  const mode = normalizeBrowserMode(input.browser_mode);
+  if (
+    "error" in mode ||
+    mode.mode !== "auto" ||
+    input.target_client_id ||
+    input.use_active_tab ||
+    context.transportInterface !== "web" ||
+    context.clientOs === "macos" ||
+    context.clientOs === "windows" ||
+    context.clientOs === "linux" ||
+    context.trustClass !== "guardian" ||
+    !context.sourceActorPrincipalId ||
+    browserManager.getPreferredBackendKind(context.conversationId) !== null ||
+    getPinnedTab(context.conversationId)
+  ) {
+    return false;
+  }
+  return isVirtualDesktopEnabled(getConfig());
+}

package/src/calls/__tests__/progress-narration.test.ts

@@ -185,6 +185,29 @@ describe("createVoiceProgressNarrator", () => {
     expect(Date.now() - startedAt).toBeLessThan(1000);
   });
 
+  test("an update that runs out of budget aborts as a narration timeout, not a session abort", async () => {
+    // The budget lapsing means this beat goes unspoken; it does not mean the
+    // call ended. Sharing `voice_session_aborted` made a narrator whose budget
+    // sat below the model's roundtrip read in the logs as a session dying once
+    // per update, which is what hid a turn that had gone silent for minutes.
+    let seen: AbortSignal | undefined;
+    const narrator = createVoiceProgressNarrator({
+      config: VoiceProgressConfigSchema.parse({ generationTimeoutMs: 20 }),
+      getProvider: async () =>
+        stubProvider((_messages, options) => {
+          seen = options?.signal;
+          return new Promise<ProviderResponse>(() => {});
+        }),
+    });
+
+    expect(await narrator.generateProgressText(progressInput)).toBeNull();
+    expect(seen?.aborted).toBe(true);
+    expect(seen?.reason).toMatchObject({
+      kind: "voice_progress_narration_timeout",
+      source: "voice-progress-narration",
+    });
+  });
+
   test("a caller abort settles promptly", async () => {
     const narrator = createVoiceProgressNarrator({
       config: VoiceProgressConfigSchema.parse({

package/src/calls/__tests__/voice-control-protocol.test.ts

@@ -154,11 +154,18 @@ describe("session control markers", () => {
     expect(isIncompleteControlMarkerTail("[MUTE:30]")).toBe(false);
     expect(isIncompleteControlMarkerTail("[UPDATES:FEW")).toBe(true);
     expect(isIncompleteControlMarkerTail("[UPDATES:FEWER]")).toBe(false);
+    expect(isIncompleteControlMarkerTail("[LOOK:SCR")).toBe(true);
+    expect(
+      stripInternalSpeechMarkers("Taking a look. [LOOK:SCREEN]").trim(),
+    ).toBe("Taking a look.");
   });
 
   test.each([
     ["Okay, talk soon. [END_CALL]", { action: "end" }],
     ["Muted. [MUTE]", { action: "mute" }],
+    ["Taking a look. [LOOK:SCREEN]", { action: "look_screen" }],
+    ["Show me. [LOOK:CAMERA]", { action: "look_camera" }],
+    ["Okay, I'll stop looking. [LOOK:STOP]", { action: "look_stop" }],
     [
       "I'll check in less. [UPDATES:FEWER]",
       { action: "updates", cadence: "fewer" },