@vellumai/assistant 0.10.12 → 0.11.0-staging.2

package/src/calls/voice-session-bridge.ts

@@ -8,6 +8,12 @@
 
 import { v7 as uuidv7 } from "uuid";
 
+import type {
+  AssistantEvent,
+  AssistantTextDeltaEvent,
+  GenerationCancelledEvent,
+  MessageCompleteEvent,
+} from "../api/index.js";
 import { consumeGrantForInvocation } from "../approvals/approval-primitive.js";
 import type {
   ChannelId,
@@ -20,7 +26,6 @@ import { ABORT_WATCHDOG_MS } from "../daemon/abort-watchdog.js";
 import { CONVERSATION_BUSY_MESSAGE } from "../daemon/conversation-messaging.js";
 import { resolveChannelCapabilities } from "../daemon/conversation-runtime-assembly.js";
 import { getOrCreateConversation } from "../daemon/conversation-store.js";
-import type { ServerMessage } from "../daemon/message-protocol.js";
 import type { TrustContext } from "../daemon/trust-context-types.js";
 import {
   deleteMessageById,
@@ -43,6 +48,7 @@ import {
   CALL_VERIFICATION_COMPLETE_MARKER,
   ESCALATE_VERDICT_TOKEN,
   HOLD_VERDICT_TOKEN,
+  MINIMIZE_ROOM_MARKER,
   stripInternalSpeechMarkers,
 } from "./voice-control-protocol.js";
 import {
@@ -216,15 +222,8 @@ export interface VoiceToolResultEvent {
  * standard channel path.
  */
 export interface VoiceRunEventSink {
-  onTextDelta(
-    msg: Extract<ServerMessage, { type: "assistant_text_delta" }>,
-  ): void;
-  onMessageComplete(
-    msg: Extract<
-      ServerMessage,
-      { type: "message_complete" } | { type: "generation_cancelled" }
-    >,
-  ): void;
+  onTextDelta(msg: AssistantTextDeltaEvent): void;
+  onMessageComplete(msg: MessageCompleteEvent | GenerationCancelledEvent): void;
   onError(message: string): void;
   onToolUse(
     toolName: string,
@@ -235,19 +234,17 @@ export interface VoiceRunEventSink {
 }
 
 export interface VoiceTurnCallbacks {
-  assistant_text_delta?: (
-    msg: Extract<ServerMessage, { type: "assistant_text_delta" }>,
-  ) => void;
+  assistant_text_delta?: (msg: AssistantTextDeltaEvent) => void;
   message_complete?: (
-    msg: Extract<
-      ServerMessage,
-      { type: "message_complete" } | { type: "generation_cancelled" }
-    >,
+    msg: MessageCompleteEvent | GenerationCancelledEvent,
   ) => void;
   persisted_user_message_id?: (messageId: string) => void;
   persisted_assistant_message_id?: (messageId: string) => void;
   /** Fired when the agent run starts a definitive tool use this turn. */
-  tool_use_start?: (toolName: string, detail?: { toolUseId?: string }) => void;
+  tool_use_start?: (
+    toolName: string,
+    detail?: { toolUseId?: string; input?: Record<string, unknown> },
+  ) => void;
   /** Fired when a tool invocation finishes. */
   tool_result?: (event: VoiceToolResultEvent) => void;
 }
@@ -314,6 +311,14 @@ export interface VoiceTurnOptions {
    * Only meaningful with `routingLeg: "escalated"`.
    */
   spokenEscalationBridge?: string;
+  /**
+   * Marks this turn's `content` as an internal instruction rather than user
+   * speech: it persists `hidden` so `/messages` filters it after a reload,
+   * its echo is suppressed, and prompt-as-user-speech consumers (title
+   * generation) skip it. Set by callers whose synthetic prompt text is not a
+   * fixed sentinel.
+   */
+  hiddenSyntheticPrompt?: boolean;
   /**
    * Unified front-door: this leg was dispatched speculatively at a silence
    * boundary, so its decision rule includes the hold branch (leading token
@@ -466,9 +471,9 @@ function buildVoiceCallControlPrompt(opts: {
     `12. ${VOICE_NO_SETUP_FLOWS_RULE}`,
   );
 
-  // Triage-and-escalate routing rules (gated by the voice-mode flag). The
-  // front-door leg decides and may hand off; the escalated leg continues the
-  // answer after a holding phrase was already spoken.
+  // Triage-and-escalate routing rules. The front-door leg decides and may
+  // hand off; the escalated leg continues the answer after a holding phrase
+  // was already spoken.
   if (opts.routingLeg === "front-door") {
     lines.push(`13. ${frontDoorRuleWithDigest(opts.unifiedVerdict === true)}`);
   } else if (opts.routingLeg === "escalated") {
@@ -481,9 +486,85 @@ function buildVoiceCallControlPrompt(opts: {
 }
 
 // ---------------------------------------------------------------------------
-// Front-door transcript hygiene
+// Transcript hygiene
 // ---------------------------------------------------------------------------
 
+/** The concatenated text of a row's text blocks. */
+function joinedTextOfBlocks(blocks: ContentBlock[]): string {
+  return blocks
+    .map((block) => (block.type === "text" ? block.text : ""))
+    .join("");
+}
+
+/**
+ * Strip internal speech markers from every text block, dropping text blocks
+ * the strip leaves empty; non-text blocks pass through untouched. Shared by
+ * the front-door stray-token rewrite and the main-leg minimize-marker
+ * rewrite.
+ */
+function stripMarkersFromBlocks(blocks: ContentBlock[]): ContentBlock[] {
+  const kept: ContentBlock[] = [];
+  for (const block of blocks) {
+    if (block.type !== "text") {
+      kept.push(block);
+      continue;
+    }
+    const cleaned = stripInternalSpeechMarkers(block.text);
+    if (cleaned.trim().length > 0) {
+      kept.push({ ...block, text: cleaned });
+    }
+  }
+  return kept;
+}
+
+/**
+ * Remove the terminal MINIMIZE_ROOM_MARKER from the end of a row's text,
+ * walking text blocks from the last one backward so a marker split across
+ * block boundaries (e.g. `"Done [-"` + `"1]"`) is removed whole — the
+ * per-block strip in {@link stripMarkersFromBlocks} only sees fragments and
+ * would leave both halves in place. Callers must have established that the
+ * row's joined text ends with the marker after trimming trailing whitespace.
+ */
+function stripTerminalMinimizeMarker(blocks: ContentBlock[]): ContentBlock[] {
+  const result = blocks.map((block) => ({ ...block }));
+  const joined = joinedTextOfBlocks(result);
+  const cutAt = joined.trimEnd().length - MINIMIZE_ROOM_MARKER.length;
+  let blockEnd = joined.length;
+  for (let i = result.length - 1; i >= 0 && blockEnd > cutAt; i--) {
+    const block = result[i]!;
+    if (block.type !== "text") {
+      continue;
+    }
+    const blockStart = blockEnd - block.text.length;
+    block.text = block.text.slice(0, Math.max(0, cutAt - blockStart));
+    blockEnd = blockStart;
+  }
+  return result;
+}
+
+/**
+ * Trim whitespace stranded at a rewritten row's outer edges by a stripped
+ * edge marker (e.g. "Done, take a look [-1]"), leaving inter-block spacing
+ * untouched.
+ */
+function trimOuterTextEdges(blocks: ContentBlock[]): ContentBlock[] {
+  const result = blocks.map((block) => ({ ...block }));
+  for (const block of result) {
+    if (block.type === "text") {
+      block.text = block.text.trimStart();
+      break;
+    }
+  }
+  for (let i = result.length - 1; i >= 0; i--) {
+    const block = result[i]!;
+    if (block.type === "text") {
+      block.text = block.text.trimEnd();
+      break;
+    }
+  }
+  return result;
+}
+
 /**
  * Reduce a front-door leg's persisted content to what was actually spoken
  * under the verdict-first protocol.
@@ -500,9 +581,7 @@ function buildVoiceCallControlPrompt(opts: {
 export function cutFrontDoorContentAtVerdict(
   blocks: ContentBlock[],
 ): { blocks: ContentBlock[]; spokenText: string } | null {
-  const joinedText = blocks
-    .map((block) => (block.type === "text" ? block.text : ""))
-    .join("");
+  const joinedText = joinedTextOfBlocks(blocks);
   if (joinedText.trimStart().startsWith(ESCALATE_VERDICT_TOKEN)) {
     const spokenText = spokenBridgeText(joinedText);
     return {
@@ -516,21 +595,8 @@ export function cutFrontDoorContentAtVerdict(
   ) {
     return null;
   }
-  const kept: ContentBlock[] = [];
-  for (const block of blocks) {
-    if (block.type !== "text") {
-      kept.push(block);
-      continue;
-    }
-    const cleaned = stripInternalSpeechMarkers(block.text);
-    if (cleaned.trim().length > 0) {
-      kept.push({ ...block, text: cleaned });
-    }
-  }
-  const spokenText = kept
-    .map((block) => (block.type === "text" ? block.text : ""))
-    .join("")
-    .trim();
+  const kept = stripMarkersFromBlocks(blocks);
+  const spokenText = joinedTextOfBlocks(kept).trim();
   return { blocks: kept, spokenText };
 }
 
@@ -589,7 +655,7 @@ export async function startVoiceTurn(
     },
     onToolUse: (toolName, input, toolUseId) => {
       log.debug({ toolName, input }, "Voice turn tool_use event");
-      opts.callbacks?.tool_use_start?.(toolName, { toolUseId });
+      opts.callbacks?.tool_use_start?.(toolName, { toolUseId, input });
     },
     onToolResult: (event) => {
       opts.callbacks?.tool_result?.(event);
@@ -625,11 +691,13 @@ export async function startVoiceTurn(
         ? "(verification completed — transitioning into conversation)"
         : opts.content;
 
-  // Opener / verification / escalation-continuation prompts are internal
-  // scaffolding: they persist a row so the model wakes, but they are not user
-  // speech and must not render as a live user bubble. Their echo is suppressed
-  // below (parity with `isEchoSuppressedUserMessage` on the text path).
+  // Opener / verification / escalation-continuation prompts, plus any turn a
+  // caller declares hidden, are internal scaffolding: they persist a row so the
+  // model wakes, but they are not user speech and must not render as a live
+  // user bubble. Their echo is suppressed below (parity with
+  // `isEchoSuppressedUserMessage` on the text path).
   const isSyntheticVoicePrompt =
+    opts.hiddenSyntheticPrompt === true ||
     opts.content === CALL_OPENING_MARKER ||
     opts.content === CALL_VERIFICATION_COMPLETE_MARKER ||
     opts.content === ESCALATION_CONTINUATION_CONTENT;
@@ -641,8 +709,10 @@ export async function startVoiceTurn(
   // `/messages` filters it out after a refetch/reload, and flag the turn as a
   // hidden prompt so prompt-as-user-speech consumers (e.g. title generation)
   // skip it. The escalated model still sees the row in context — `hidden` only
-  // affects client display.
+  // affects client display. A caller whose prompt text is not a fixed sentinel
+  // opts into the same treatment with `hiddenSyntheticPrompt`.
   const isHiddenSyntheticPrompt =
+    opts.hiddenSyntheticPrompt === true ||
     opts.content === ESCALATION_CONTINUATION_CONTENT;
 
   // Build the call-control protocol prompt so the model knows how to emit
@@ -1034,7 +1104,7 @@ export async function startVoiceTurn(
   // Hook into conversation to intercept confirmation_request and secret_request events.
   // Voice auto-denies/auto-allows/auto-resolves these since there's no interactive UI.
   let lastError: string | null = null;
-  conversation.updateClient(async (msg: ServerMessage) => {
+  conversation.updateClient(async (msg: AssistantEvent) => {
     if (msg.type === "confirmation_request") {
       // Broadcast the request BEFORE resolving it: resolution synchronously
       // broadcasts `interaction_resolved` (handleConfirmationResponse →
@@ -1178,6 +1248,14 @@ export async function startVoiceTurn(
    *   never the verdict token or the text streamed past the cap (issue
    *   #37850). A row with no spoken bridge (canned-fallback case — that
    *   bridge is audio-only) is deleted.
+   * - Any leg whose row ENDS with the `[-1]` minimize marker (swallowed
+   *   before TTS on the live path) has its text blocks rewritten through
+   *   `stripInternalSpeechMarkers` so the marker never renders in the chat
+   *   transcript. This covers front-door answers too: that leg is never
+   *   taught the marker, but it can parrot one from visible conversation
+   *   history, and the parroted marker is never spoken and never minimizes
+   *   the room. Deliberately scoped to that marker: rows without it
+   *   persist byte-identical.
    *
    * After a rewrite, in-memory history is reloaded from the clean DB before
    * the escalated leg — blocked on this turn's teardown — snapshots it, so
@@ -1198,9 +1276,6 @@ export async function startVoiceTurn(
       }
       return;
     }
-    if (!discarded && opts.routingLeg !== "front-door") {
-      return;
-    }
     try {
       let action = "none";
       if (discarded) {
@@ -1208,8 +1283,13 @@ export async function startVoiceTurn(
         action = "delete_discarded";
       } else {
         const row = getMessageById(reservedAssistantRowId, opts.conversationId);
-        const cut = row ? cutFrontDoorContentAtVerdict(row.content) : null;
-        if (cut) {
+        const cut =
+          row && opts.routingLeg === "front-door"
+            ? cutFrontDoorContentAtVerdict(row.content)
+            : null;
+        if (!row) {
+          action = "row_missing";
+        } else if (cut) {
           if (cut.spokenText.length > 0) {
             updateMessageContent(
               reservedAssistantRowId,
@@ -1220,20 +1300,53 @@ export async function startVoiceTurn(
             deleteMessageById(reservedAssistantRowId);
             action = "delete_empty";
           }
-        } else if (!row) {
-          action = "row_missing";
+        } else if (
+          // Terminal position only — mirrors the live latch in
+          // createControlMarkerHoldback: a reply whose CONTENT contains
+          // "[-1]" mid-text never minimized the room, so its transcript
+          // keeps that content untouched too. Front-door answer rows (no
+          // verdict token to cut) take this branch as well.
+          joinedTextOfBlocks(row.content)
+            .trimEnd()
+            .endsWith(MINIMIZE_ROOM_MARKER)
+        ) {
+          // Terminal marker first (boundary-aware — it may span text blocks),
+          // then the per-block strip for any interior complete markers.
+          const cleaned = trimOuterTextEdges(
+            stripMarkersFromBlocks(stripTerminalMinimizeMarker(row.content)),
+          );
+          // A marker-only reply (the model said nothing beyond "[-1]") strips
+          // to nothing at all; keeping the row would render a blank assistant
+          // bubble, so delete it like the front-door empty case. Any surviving
+          // block — including non-text blocks like tool_use — keeps the row.
+          if (cleaned.length === 0) {
+            deleteMessageById(reservedAssistantRowId);
+            action = "delete_empty";
+          } else {
+            updateMessageContent(
+              reservedAssistantRowId,
+              JSON.stringify(cleaned),
+            );
+            action = "strip_minimize_marker";
+          }
         }
       }
-      log.info(
-        {
-          turnId,
-          messageId: reservedAssistantRowId,
-          routingLeg: opts.routingLeg ?? null,
-          discarded,
-          action,
-        },
-        "Voice leg transcript hygiene",
-      );
+      // Main legs run the pass on every voice turn; keep the no-op case
+      // out of the logs.
+      const isMainLegNoOp =
+        action === "none" && !discarded && opts.routingLeg !== "front-door";
+      if (!isMainLegNoOp) {
+        log.info(
+          {
+            turnId,
+            messageId: reservedAssistantRowId,
+            routingLeg: opts.routingLeg ?? null,
+            discarded,
+            action,
+          },
+          "Voice leg transcript hygiene",
+        );
+      }
       if (action !== "none" && action !== "row_missing") {
         await conversation.loadFromDb();
         publishConversationMessagesChanged(opts.conversationId);
@@ -1283,7 +1396,7 @@ export async function startVoiceTurn(
         frontDoorToolsSuppressed = true;
       }
       await conversation.runAgentLoop(persistedContent, messageId, {
-        onEvent: (msg: ServerMessage) => {
+        onEvent: (msg: AssistantEvent) => {
           if (msg.type === "assistant_turn_start") {
             reservedAssistantRowId = msg.messageId;
           } else if (msg.type === "error") {

package/src/calls/voice-triage-escalate.ts

@@ -23,8 +23,7 @@
  *
  * This module owns the routing policy in one place: the profile key, the
  * leg-specific prompt rules, the leading-token classifier, and the bridge
- * cap/fallback policy. The gate itself is the `voice-mode` flag, read by the
- * LiveVoiceSession that drives the routing.
+ * cap/fallback policy. LiveVoiceSession drives the routing.
  */
 
 import {
@@ -296,6 +295,6 @@ export function escalatedContinuationRule(spokenBridge?: string): string {
     'Do NOT greet again, do NOT say things like "as I was saying", and do NOT repeat, paraphrase, or re-announce that holding phrase —',
     'opening with another "Let me check", "One moment", or any restatement of what you are about to do sounds broken, because the caller just heard that.',
     "Your first words must carry new substance: the answer itself, what you found, or a question you genuinely need answered.",
-    `Never output ${ESCALATE_VERDICT_TOKEN} or any other verdict token — you are the model that finishes the answer.`,
+    `Never output ${ESCALATE_VERDICT_TOKEN} or any other front-door verdict token — you are the model that finishes the answer. (The [-1] room-minimize marker from your call instructions is not a verdict token and stays allowed.)`,
   ].join(" ");
 }

package/src/channels/config.ts

@@ -73,6 +73,14 @@ const CHANNEL_POLICIES = {
       conversationStrategy: "continue_existing_conversation",
     },
   },
+  discord: {
+    notification: {
+      // Discord has no outbound transport, so enabling delivery would route
+      // notifications at a callback no transport owns.
+      deliveryEnabled: false,
+      conversationStrategy: "continue_existing_conversation",
+    },
+  },
 } as const satisfies Record<ChannelId, ChannelNotificationPolicy>;
 
 export type ChannelPolicies = typeof CHANNEL_POLICIES;

package/src/channels/types.ts

@@ -150,6 +150,7 @@ export const INTERFACE_IDS = [
   "email",
   "chrome-extension",
   "a2a",
+  "discord",
   // Turns injected by workspace custom routes (webhook receivers, cron jobs,
   // device/service callbacks). Non-interactive — permission prompts route
   // through the guardian system, not an interactive client — and non-host-proxy.

package/src/cli/commands/config.ts

@@ -30,9 +30,27 @@ function flattenConfig(
   return result;
 }
 
-/** Matches config paths like `services.image-generation.mode`, `services.web-search.mode`, etc. */
+/** Matches config paths like `services.google-oauth.mode` (mode-based services). */
 const SERVICE_MODE_PATH_RE = /^services\.[^.]+\.mode$/;
 
+/**
+ * Services configured by provider alone: their schemas strip a raw `mode`
+ * write, so the CLI rejects it with the provider-based replacement instead
+ * of printing success on a no-op.
+ */
+const REMOVED_MODE_PATHS: Record<string, string> = {
+  "services.web-search.mode":
+    "services.web-search.mode does not exist; web search is configured by provider alone. For managed search run `config set services.web-search.provider vellum`.",
+  "services.image-generation.mode":
+    "services.image-generation.mode does not exist; image generation is configured by provider alone. For managed image generation run `config set services.image-generation.provider vellum`.",
+};
+
+/** Provider paths whose "vellum" value requires a platform connection. */
+const VELLUM_PROVIDER_PATHS = new Set([
+  "services.web-search.provider",
+  "services.image-generation.provider",
+]);
+
 /**
  * Fetch the full raw config from the assistant via IPC.
  * On transport / connection error, prints a helpful message and exits.
@@ -69,13 +87,10 @@ export function registerConfigCommand(program: Command): void {
           // Web-search has no mode field: the schema strips it, so a write
           // here would print success while changing nothing. Reject it with
           // the provider-based replacement instead.
-          if (key === "services.web-search.mode") {
+          const removedModePath = REMOVED_MODE_PATHS[key];
+          if (removedModePath) {
             const { writeOutput } = await import("../output.js");
-            writeOutput(cmd, {
-              ok: false,
-              error:
-                "services.web-search.mode does not exist; web search is configured by provider alone. For managed search run `config set services.web-search.provider vellum`.",
-            });
+            writeOutput(cmd, { ok: false, error: removedModePath });
             process.exitCode = 1;
             return;
           }
@@ -85,7 +100,7 @@ export function registerConfigCommand(program: Command): void {
           // web search.
           const requiresPlatform =
             (SERVICE_MODE_PATH_RE.test(key) && parsed === "managed") ||
-            (key === "services.web-search.provider" && parsed === "vellum");
+            (VELLUM_PROVIDER_PATHS.has(key) && parsed === "vellum");
           if (requiresPlatform) {
             const { requirePlatformConnection } =
               await import("./oauth/shared.js");
@@ -98,21 +113,31 @@ export function registerConfigCommand(program: Command): void {
           // Direct-replacement set semantics (preserves null, replaces objects).
           // See conversation-query-routes.ts:handleSetConfig for why this is a
           // separate route from config_patch.
-          const result = await cliIpcCall("config_set", {
-            body: { path: key, value: parsed },
-          });
+          const result = await cliIpcCall<{ ok: boolean; warning?: string }>(
+            "config_set",
+            { body: { path: key, value: parsed } },
+          );
           if (!result.ok) {
             exitFromIpcResult(result, cmd);
             return;
           }
           log.info(`Set ${key} = ${JSON.stringify(parsed)}`);
+          // A write the daemon accepted but that another namespace overrides
+          // is reported alongside the success, so a no-op set never reads as
+          // an effective one.
+          const warning = result.result?.warning;
+          if (warning) {
+            log.warn(`Warning: ${warning}`);
+          }
         },
       );
 
       subcommand(config, "get").action(
         async (key: string, _opts: unknown, cmd: Command) => {
           const raw = await fetchRawConfig(cmd);
-          if (!raw) return;
+          if (!raw) {
+            return;
+          }
           const value = getNestedValue(raw, key);
           if (value === undefined) {
             log.info(`(not set)`);
@@ -123,6 +148,15 @@ export function registerConfigCommand(program: Command): void {
                 : String(value),
             );
           }
+          // A `memory.v2` substrate tunable whose `memory.substrate` twin is
+          // set has a second reader — print which key the runtime consults so
+          // the value above cannot be mistaken for the effective one.
+          const { describeShadowedConfigGet, findSubstrateShadowing } =
+            await import("../../config/substrate-twin-shadowing.js");
+          const shadowing = findSubstrateShadowing(raw, key);
+          if (shadowing) {
+            log.warn(describeShadowedConfigGet(shadowing, key));
+          }
         },
       );
 
@@ -143,7 +177,9 @@ export function registerConfigCommand(program: Command): void {
       subcommand(config, "list").action(
         async (opts: { search?: string }, cmd: Command) => {
           const raw = await fetchRawConfig(cmd);
-          if (!raw) return;
+          if (!raw) {
+            return;
+          }
           if (Object.keys(raw).length === 0) {
             log.info("No configuration set");
             return;

package/src/cli/commands/memory/index.help.ts

@@ -15,7 +15,8 @@ export const memoryHelp: CliCommandHelp = {
     "Manage memory items and maintain the assistant memory subsystem",
   helpText: `
 The 'nodes' subgroup provides content-based list, delete, and update over
-memory v2 graph nodes — address facts by text, not UUID (requires memory v2).
+memory graph nodes — address facts by text, not UUID (requires concept-page
+memory: memory.v3.live or memory.v2.enabled).
 
 The 'items' subgroup exposes full CRUD over individual memory items
 (remembered facts) — list, get, create, update, delete.
@@ -46,7 +47,8 @@ memory v2 subsystem. Unlike 'memory items', which addresses nodes by UUID, these
 commands address nodes by content text — matching the way an operator refers to
 a remembered fact without first looking up its ID.
 
-All subcommands require memory v2 to be enabled and the assistant to be running.
+All subcommands require concept-page memory (memory.v3.live or
+memory.v2.enabled) and the assistant to be running.
 
 Examples:
   $ assistant memory nodes stats

package/src/cli/commands/memory/memory-retrospective.ts

@@ -135,6 +135,11 @@ function renderOutcome(outcome: MemoryRetrospectiveOutcome): void {
     case "no_new_messages":
       log.info("No new messages to review since the last retrospective.");
       break;
+    case "source_dormant":
+      log.info(
+        "Source conversation is dormant beyond the sweep lookback; skipping.",
+      );
+      break;
     case "source_processing":
       log.info(
         "Source conversation is mid-turn; skipping (will retry next trigger).",

package/src/cli/commands/webhooks.help.ts

@@ -13,8 +13,9 @@ Resolves a stable callback URL that external services (Telegram, Twilio,
 email providers, OAuth) should use to reach this assistant.
 
 On platform-managed assistants, this registers a callback route with the
-platform gateway. On self-hosted assistants, it uses the configured
-ingress.publicBaseUrl.
+platform gateway. Otherwise it uses the configured ingress.publicBaseUrl,
+falling back to the platform gateway when no ingress is configured and the
+assistant is connected to the platform.
 
 The webhook path is derived from the type: underscores become path
 separators, prefixed with webhooks/.
@@ -49,8 +50,12 @@ Examples:
       helpText: `
 Resolves a callback URL for the given webhook type. On platform-managed
 assistants (IS_PLATFORM=true), registers a callback route with the platform
-gateway and returns the stable external URL. On self-hosted assistants,
-reads ingress.publicBaseUrl from config and appends the webhook path.
+gateway and returns the stable external URL. Otherwise it reads
+ingress.publicBaseUrl from config and appends the webhook path. That URL is
+either your own tunnel or the Velay tunnel URL the gateway publishes. If no
+ingress is configured and the assistant is connected to the platform
+(via 'assistant platform connect'), it registers a callback route with the
+platform gateway instead of failing.
 
 Arguments:
   type   The webhook type to register. The path is derived automatically:

package/src/cli/lib/bundled-marketplace.json

@@ -474,6 +474,18 @@
       "homepage": "https://github.com/vellum-ai/battleship",
       "license": "MIT",
       "icon": "⚓"
+    },
+    {
+      "name": "octolens",
+      "source": {
+        "source": "github",
+        "repo": "vellum-ai/octolens",
+        "ref": "d9117f5c6b97b3bff75dec1a04bedc32571c6538"
+      },
+      "description": "Social listening plugin for Octolens. Monitor brand mentions, competitor activity, and industry conversations across 13+ platforms. Query mentions, run analytics, manage keywords and feeds via REST API tools, or connect the Octolens MCP server for natural-language workflows.",
+      "category": "growth",
+      "homepage": "https://github.com/vellum-ai/octolens",
+      "license": "MIT"
     }
   ]
 }