@vellumai/assistant 0.4.34 → 0.4.36

package/src/notifications/destination-resolver.ts

@@ -66,12 +66,19 @@ export function resolveDestinations(
       case "sms": {
         const guardianResult = findGuardianForChannel(channel);
         if (guardianResult && guardianResult.channel.externalChatId) {
+          const externalChatId = guardianResult.channel.externalChatId;
           result.set(channel as NotificationChannel, {
             channel: channel as NotificationChannel,
-            endpoint: guardianResult.channel.externalChatId ?? undefined,
+            endpoint: externalChatId,
             metadata: {
               externalUserId: guardianResult.channel.externalUserId,
             },
+            bindingContext: {
+              sourceChannel: channel as NotificationChannel,
+              externalChatId,
+              externalUserId:
+                guardianResult.channel.externalUserId ?? undefined,
+            },
           });
         }
         log.debug(
@@ -97,6 +104,12 @@ export function resolveDestinations(
             metadata: {
               externalUserId: guardianResult.channel.externalUserId,
             },
+            bindingContext: {
+              sourceChannel: "slack",
+              externalChatId: chatId,
+              externalUserId:
+                guardianResult.channel.externalUserId ?? undefined,
+            },
           });
         } else if (guardianResult && chatId) {
           log.warn(

package/src/notifications/emit-signal.ts

@@ -34,6 +34,7 @@ import type {
   AttentionHints,
   NotificationContextPayload,
   NotificationSignal,
+  NotificationSourceChannel,
   RoutingIntent,
 } from "./signal.js";
 import type {
@@ -151,8 +152,8 @@ function getConnectedChannels(): NotificationChannel[] {
 export interface EmitSignalParams<TEventName extends string = string> {
   /** Free-form event name, e.g. 'reminder.fired', 'schedule.complete'. */
   sourceEventName: TEventName;
-  /** Source channel that produced the event. */
-  sourceChannel: string;
+  /** Source channel that produced the event — must be a registered channel. */
+  sourceChannel: NotificationSourceChannel;
   /** Session or conversation ID from the source context. */
   sourceSessionId: string;
   /** Attention hints for the decision engine. */

package/src/notifications/signal.ts

@@ -6,6 +6,110 @@
 
 import type { GuardianQuestionPayload } from "./guardian-question-mode.js";
 
+// ── Source channel registry ────────────────────────────────────────────
+
+export const NOTIFICATION_SOURCE_CHANNELS = [
+  { id: "assistant_tool", description: "Assistant skill/tool invocation" },
+  { id: "vellum", description: "Vellum native client (macOS/iOS)" },
+  { id: "voice", description: "Voice call pipeline" },
+  { id: "telegram", description: "Telegram channel" },
+  { id: "sms", description: "SMS channel" },
+  { id: "slack", description: "Slack channel" },
+  { id: "scheduler", description: "Scheduled task runner (reminders, cron)" },
+  { id: "watcher", description: "File/event watcher subsystem" },
+] as const;
+
+export type NotificationSourceChannel =
+  (typeof NOTIFICATION_SOURCE_CHANNELS)[number]["id"];
+
+export function isNotificationSourceChannel(
+  value: unknown,
+): value is NotificationSourceChannel {
+  return (
+    typeof value === "string" &&
+    NOTIFICATION_SOURCE_CHANNELS.some((c) => c.id === value)
+  );
+}
+
+// ── Source event name registry ─────────────────────────────────────────
+
+export const NOTIFICATION_SOURCE_EVENT_NAMES = [
+  {
+    id: "user.send_notification",
+    description: "User-initiated notification via assistant tool",
+  },
+  { id: "reminder.fired", description: "Scheduled reminder triggered" },
+  { id: "schedule.complete", description: "Scheduled task finished running" },
+  {
+    id: "guardian.question",
+    description: "Guardian approval question requiring response",
+  },
+  { id: "ingress.access_request", description: "Non-member requesting access" },
+  {
+    id: "ingress.access_request.callback_handoff",
+    description: "Caller requested callback while unreachable",
+  },
+  {
+    id: "ingress.escalation",
+    description: "Incoming message escalated for attention",
+  },
+  {
+    id: "ingress.trusted_contact.guardian_decision",
+    description: "Guardian decided on trusted contact request",
+  },
+  {
+    id: "ingress.trusted_contact.denied",
+    description: "Trusted contact request denied",
+  },
+  {
+    id: "ingress.trusted_contact.verification_sent",
+    description: "Verification sent to trusted contact",
+  },
+  {
+    id: "ingress.trusted_contact.activated",
+    description: "Trusted contact activated",
+  },
+  {
+    id: "watcher.notification",
+    description: "Watcher detected a notable event",
+  },
+  {
+    id: "watcher.escalation",
+    description: "Watcher event requiring immediate attention",
+  },
+  {
+    id: "tool_confirmation.required_action",
+    description: "Tool requires user confirmation before executing",
+  },
+  { id: "activity.complete", description: "Background activity finished" },
+  {
+    id: "quick_chat.response_ready",
+    description: "Quick chat response ready for review",
+  },
+  {
+    id: "voice.response_ready",
+    description: "Voice response ready for playback",
+  },
+  {
+    id: "ride_shotgun.invitation",
+    description: "Invitation to ride shotgun on a session",
+  },
+] as const;
+
+export type NotificationSourceEventName =
+  (typeof NOTIFICATION_SOURCE_EVENT_NAMES)[number]["id"];
+
+export function isNotificationSourceEventName(
+  value: unknown,
+): value is NotificationSourceEventName {
+  return (
+    typeof value === "string" &&
+    NOTIFICATION_SOURCE_EVENT_NAMES.some((e) => e.id === value)
+  );
+}
+
+// ── Attention hints & routing ──────────────────────────────────────────
+
 export interface AttentionHints {
   requiresAction: boolean;
   urgency: "low" | "medium" | "high";
@@ -28,7 +132,7 @@ export type NotificationContextPayload<TEventName extends string = string> =
 export interface NotificationSignal<TEventName extends string = string> {
   signalId: string;
   createdAt: number; // epoch ms
-  sourceChannel: string; // free-form: 'vellum', 'telegram', 'voice', 'scheduler', etc.
+  sourceChannel: NotificationSourceChannel; // see NOTIFICATION_SOURCE_CHANNELS registry
   sourceSessionId: string;
   sourceEventName: TEventName; // free-form: 'reminder_fired', 'schedule_complete', 'guardian_question', etc.
   contextPayload: NotificationContextPayload<TEventName>;

package/src/notifications/types.ts

@@ -51,6 +51,22 @@ export interface ChannelDestination {
   channel: NotificationChannel;
   endpoint?: string;
   metadata?: Record<string, unknown>;
+  /** Stable binding data for channel-scoped conversation continuation. */
+  bindingContext?: DestinationBindingContext;
+}
+
+/**
+ * Binding data that identifies a specific external chat for a channel.
+ * Used by conversation pairing to look up or create channel-scoped
+ * conversations keyed by (sourceChannel, externalChatId).
+ */
+export interface DestinationBindingContext {
+  /** The channel this binding belongs to (e.g. "telegram", "sms", "slack"). */
+  sourceChannel: NotificationChannel;
+  /** The channel-specific chat/thread identifier (e.g. Telegram chat ID, phone number). */
+  externalChatId: string;
+  /** Optional external user identifier within the chat. */
+  externalUserId?: string;
 }
 
 /**

package/src/permissions/checker.ts

@@ -40,6 +40,7 @@ import { isWorkspaceScopedInvocation } from "./workspace-policy.js";
 // risk logic is input-deterministic.
 const RISK_CACHE_MAX = 256;
 const riskCache = new Map<string, RiskLevel>();
+let riskCacheInvalidationHookRegistered = false;
 
 function riskCacheKey(
   toolName: string,
@@ -63,9 +64,13 @@ export function clearRiskCache(): void {
   riskCache.clear();
 }
 
-// Invalidate risk cache whenever trust rules change so that risk decisions
-// referencing config-dependent checks (e.g. skill source paths) stay fresh.
-onRulesChanged(clearRiskCache);
+function ensureRiskCacheInvalidationHook(): void {
+  if (riskCacheInvalidationHookRegistered) return;
+  // Register lazily to avoid an ESM initialization cycle between checker and
+  // trust-store when a higher-level module imports both during startup.
+  riskCacheInvalidationHookRegistered = true;
+  onRulesChanged(clearRiskCache);
+}
 
 // Low-risk shell programs that are read-only / informational
 const LOW_RISK_PROGRAMS = new Set([
@@ -462,6 +467,7 @@ export async function classifyRisk(
   signal?: AbortSignal,
 ): Promise<RiskLevel> {
   signal?.throwIfAborted();
+  ensureRiskCacheInvalidationHook();
 
   // Check cache first (skip when preParsed is provided since caller already
   // parsed and we'd just be duplicating the key computation cost).
@@ -806,6 +812,26 @@ export async function check(
     }
   }
 
+  // Any unrecognized mode (including raw "legacy" that somehow bypassed loader
+  // migration) is treated as workspace mode — fail-closed relative to the old
+  // risk-only fallthrough that would auto-allow low-risk operations everywhere.
+  if (
+    permissionsMode !== "strict" &&
+    permissionsMode !== "workspace" &&
+    !matchedRule &&
+    risk !== RiskLevel.High
+  ) {
+    if (toolName === "bash" && !getConfig().sandbox.enabled) {
+      // Fall through to risk-based policy below
+    } else if (isWorkspaceScopedInvocation(toolName, input, workingDir)) {
+      return {
+        decision: "allow",
+        reason:
+          "Workspace mode (normalized): workspace-scoped operation auto-allowed",
+      };
+    }
+  }
+
   // Auto-allow low-risk bundled skill tools even without explicit trust rules.
   // These are first-party tools with a vetted risk declaration — applying the
   // same policy as the per-tool default allow rules for browser tools, but

package/src/permissions/prompter.ts

@@ -19,12 +19,14 @@ interface PendingPrompt {
   }) => void;
   reject: (reason: Error) => void;
   timer: ReturnType<typeof setTimeout>;
+  toolUseId?: string;
 }
 
 export type ConfirmationStateCallback = (
   requestId: string,
   state: "pending" | "approved" | "denied" | "timed_out" | "resolved_stale",
   source: "button" | "inline_nl" | "auto_deny" | "timeout" | "system",
+  toolUseId?: string,
 ) => void;
 
 export class PermissionPrompter {
@@ -62,6 +64,7 @@ export class PermissionPrompter {
     persistentDecisionsAllowed?: boolean,
     signal?: AbortSignal,
     temporaryOptionsAvailable?: Array<"allow_10m" | "allow_thread">,
+    toolUseId?: string,
   ): Promise<{
     decision: UserDecision;
     selectedPattern?: string;
@@ -80,11 +83,11 @@ export class PermissionPrompter {
           { requestId, toolName },
           "Permission prompt timed out, defaulting to deny",
         );
-        this.onStateChanged?.(requestId, "timed_out", "timeout");
+        this.onStateChanged?.(requestId, "timed_out", "timeout", toolUseId);
         resolve({ decision: "deny" });
       }, timeoutMs);
 
-      this.pending.set(requestId, { resolve, reject, timer });
+      this.pending.set(requestId, { resolve, reject, timer, toolUseId });
 
       if (signal) {
         const onAbort = () => {
@@ -120,7 +123,7 @@ export class PermissionPrompter {
         temporaryOptionsAvailable,
       });
 
-      this.onStateChanged?.(requestId, "pending", "system");
+      this.onStateChanged?.(requestId, "pending", "system", toolUseId);
     });
   }
 
@@ -128,6 +131,11 @@ export class PermissionPrompter {
     return this.pending.has(requestId);
   }
 
+  /** Returns the toolUseId associated with a pending request, if any. */
+  getToolUseId(requestId: string): string | undefined {
+    return this.pending.get(requestId)?.toolUseId;
+  }
+
   resolveConfirmation(
     requestId: string,
     decision: UserDecision,

package/src/runtime/access-request-helper.ts

@@ -26,6 +26,7 @@ import {
   updateCanonicalGuardianDelivery,
 } from "../memory/canonical-guardian-store.js";
 import { emitNotificationSignal } from "../notifications/emit-signal.js";
+import type { NotificationSourceChannel } from "../notifications/signal.js";
 import type { NotificationDeliveryResult } from "../notifications/types.js";
 import { getLogger } from "../util/logger.js";
 import { ensureVellumGuardianBinding } from "./guardian-vellum-migration.js";
@@ -216,7 +217,7 @@ export function notifyGuardianOfAccessRequest(
   let vellumDeliveryId: string | null = null;
   void emitNotificationSignal({
     sourceEventName: "ingress.access_request",
-    sourceChannel,
+    sourceChannel: sourceChannel as NotificationSourceChannel,
     sourceSessionId: `access-req-${sourceChannel}-${actorExternalId}`,
     attentionHints: {
       requiresAction: true,

package/src/runtime/auth/route-policy.ts

@@ -166,9 +166,10 @@ const ACTOR_ENDPOINTS: Array<{ endpoint: string; scopes: Scope[] }> = [
   { endpoint: "home-base-ui", scopes: ["settings.read"] },
   { endpoint: "contacts", scopes: ["settings.read"] },
   { endpoint: "contacts:POST", scopes: ["settings.write"] },
+  { endpoint: "contacts:DELETE", scopes: ["settings.write"] },
   { endpoint: "contacts/merge", scopes: ["settings.write"] },
   { endpoint: "contacts:GET", scopes: ["settings.read"] },
-  { endpoint: "contacts/channels", scopes: ["settings.write"] },
+  { endpoint: "contact-channels", scopes: ["settings.write"] },
   { endpoint: "contacts/invites", scopes: ["settings.read"] },
   { endpoint: "contacts/invites:POST", scopes: ["settings.write"] },
   { endpoint: "contacts/invites/redeem", scopes: ["settings.write"] },
@@ -263,6 +264,11 @@ const ACTOR_ENDPOINTS: Array<{ endpoint: string; scopes: Scope[] }> = [
   { endpoint: "apps/shared:DELETE", scopes: ["settings.write"] },
   { endpoint: "apps/shared/metadata", scopes: ["settings.read"] },
 
+  // Usage / cost telemetry
+  { endpoint: "usage/totals", scopes: ["settings.read"] },
+  { endpoint: "usage/daily", scopes: ["settings.read"] },
+  { endpoint: "usage/breakdown", scopes: ["settings.read"] },
+
   // Debug
   { endpoint: "debug", scopes: ["settings.read"] },
 

package/src/runtime/channel-invite-transport.ts

@@ -2,15 +2,14 @@
  * Channel invite adapter abstraction.
  *
  * Defines an adapter interface for building shareable invite links,
- * extracting inbound invite tokens, and generating guardian instructions
+ * extracting inbound invite tokens, and resolving channel handles
  * from channel-specific payloads. Each channel (Telegram, voice, etc.)
  * registers an adapter that knows how to handle invite flows for that
  * channel.
  *
- * All methods are optional: a channel that only provides
- * `buildGuardianInstruction` (e.g. SMS) is a valid adapter. The adapter
- * layer is intentionally thin — redemption logic lives in
- * `invite-redemption-service.ts`.
+ * All methods are optional — the adapter layer is intentionally thin.
+ * Redemption logic lives in `invite-redemption-service.ts` and invite
+ * instruction generation lives in `invite-instruction-generator.ts`.
  */
 
 import type { ChannelId } from "../channels/types.js";
@@ -26,13 +25,6 @@ export interface InviteShareLink {
   displayText: string;
 }
 
-export interface GuardianInstruction {
-  /** Human-readable instruction text for the guardian. */
-  instruction: string;
-  /** Channel-specific handle to reach the assistant (e.g. "@botName", "+15551234567", "hello@domain.agentmail.to"). */
-  channelHandle?: string;
-}
-
 export interface ChannelInviteAdapter {
   /** The channel this adapter handles. */
   channel: ChannelId;
@@ -57,16 +49,6 @@ export interface ChannelInviteAdapter {
     sourceMetadata?: Record<string, unknown>;
   }): string | undefined;
 
-  /**
-   * Build guardian instruction for this channel. Returns structured data
-   * with the instruction text and an optional channel-specific handle.
-   * Optional — falls back to generic instruction if not implemented.
-   */
-  buildGuardianInstruction?(params: {
-    inviteCode: string;
-    contactName?: string;
-  }): GuardianInstruction;
-
   /**
    * Resolve the channel-specific handle to reach the assistant (e.g.
    * "@botName", "+15551234567", "hello@domain.agentmail.to").
@@ -74,17 +56,14 @@ export interface ChannelInviteAdapter {
    * credentials not yet configured).
    */
   resolveChannelHandle?(): string | undefined;
-}
-
-// ---------------------------------------------------------------------------
-// Backward-compatible type aliases
-// ---------------------------------------------------------------------------
 
-/** @deprecated Use `ChannelInviteAdapter` instead. */
-export type ChannelInviteTransport = ChannelInviteAdapter;
-
-/** @deprecated Use `InviteShareLink` instead. */
-export type InviteSharePayload = InviteShareLink;
+  /**
+   * Async variant of `resolveChannelHandle` for adapters that need to
+   * perform I/O (e.g. querying a provider API for the assigned address).
+   * When both are present, `resolveAdapterHandle()` prefers this method.
+   */
+  resolveChannelHandleAsync?(): Promise<string | undefined>;
+}
 
 // ---------------------------------------------------------------------------
 // Registry
@@ -124,7 +103,32 @@ export class InviteAdapterRegistry {
 }
 
 // ---------------------------------------------------------------------------
-// Singleton registry + backward-compatible free functions
+// Handle resolution helper
+// ---------------------------------------------------------------------------
+
+/**
+ * Resolve the channel handle for an adapter, preferring the async path
+ * when available and falling back to the sync path. Returns `undefined`
+ * when the adapter has no handle resolution method or the handle cannot
+ * be determined.
+ */
+export async function resolveAdapterHandle(
+  adapter: ChannelInviteAdapter,
+): Promise<string | undefined> {
+  try {
+    if (adapter.resolveChannelHandleAsync) {
+      return await adapter.resolveChannelHandleAsync();
+    }
+    return adapter.resolveChannelHandle?.();
+  } catch {
+    // Handle resolution is optional metadata — degrade gracefully so
+    // callers (e.g. readiness endpoints) don't fail on transient errors.
+    return undefined;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Singleton registry
 // ---------------------------------------------------------------------------
 
 import { emailInviteAdapter } from "./channel-invite-transports/email.js";
@@ -132,6 +136,7 @@ import { slackInviteAdapter } from "./channel-invite-transports/slack.js";
 import { smsInviteAdapter } from "./channel-invite-transports/sms.js";
 import { telegramInviteAdapter } from "./channel-invite-transports/telegram.js";
 import { voiceInviteAdapter } from "./channel-invite-transports/voice.js";
+import { whatsappInviteAdapter } from "./channel-invite-transports/whatsapp.js";
 
 /** Create a registry instance with built-in adapters registered. */
 export function createInviteAdapterRegistry(): InviteAdapterRegistry {
@@ -141,42 +146,14 @@ export function createInviteAdapterRegistry(): InviteAdapterRegistry {
   registry.register(smsInviteAdapter);
   registry.register(telegramInviteAdapter);
   registry.register(voiceInviteAdapter);
+  registry.register(whatsappInviteAdapter);
   return registry;
 }
 
-/**
- * Module-level singleton registry, created eagerly so callers that
- * import the free functions continue to work without changes.
- */
+/** Module-level singleton registry, created eagerly at import time. */
 const defaultRegistry = createInviteAdapterRegistry();
 
 /** Return the module-level singleton registry. */
 export function getInviteAdapterRegistry(): InviteAdapterRegistry {
   return defaultRegistry;
 }
-
-/**
- * Register a channel invite adapter on the default registry.
- * @deprecated Prefer `getInviteAdapterRegistry().register(adapter)`.
- */
-export function registerTransport(transport: ChannelInviteAdapter): void {
-  defaultRegistry.register(transport);
-}
-
-/**
- * Look up the registered adapter for a channel on the default registry.
- * @deprecated Prefer `getInviteAdapterRegistry().get(channel)`.
- */
-export function getTransport(
-  channel: ChannelId,
-): ChannelInviteAdapter | undefined {
-  return defaultRegistry.get(channel);
-}
-
-/**
- * Reset the default registry. Intended for tests only.
- * @internal
- */
-export function _resetRegistry(): void {
-  defaultRegistry._reset();
-}

package/src/runtime/channel-invite-transports/email.ts

@@ -1,28 +1,19 @@
 /**
  * Email channel invite adapter.
  *
- * Provides guardian instruction text for email-based invites. Email invites
- * use the universal 6-digit code path for redemption, so this adapter only
- * implements `buildGuardianInstruction` — no `buildShareLink` or
- * `extractInboundToken` needed.
+ * Resolves the assistant's email address for use in invite instructions.
+ * Uses the EmailService's cached primary inbox lookup so the real address
+ * is returned when an inbox is configured. Falls back to `undefined` when
+ * no inbox exists, which causes the invite instruction generator to emit
+ * generic "on Email" wording instead of a misleading stub address.
+ *
+ * Email invites use the universal 6-digit code path for redemption, so
+ * this adapter only implements `resolveChannelHandleAsync` — no
+ * `buildShareLink` or `extractInboundToken` needed.
  */
 
-import type {
-  ChannelInviteAdapter,
-  GuardianInstruction,
-} from "../channel-invite-transport.js";
-
-// ---------------------------------------------------------------------------
-// Email address resolution
-// ---------------------------------------------------------------------------
-
-// TODO: resolve from AgentMail provider (async — needs caching or pre-resolution)
-// The real implementation requires async inbox lookup via
-// `getActiveEmailProvider().health()` which doesn't fit the sync adapter
-// interface.
-function resolveAssistantEmailAddress(): string | undefined {
-  return undefined;
-}
+import { getEmailService } from "../../email/service.js";
+import type { ChannelInviteAdapter } from "../channel-invite-transport.js";
 
 // ---------------------------------------------------------------------------
 // Adapter implementation
@@ -31,24 +22,7 @@ function resolveAssistantEmailAddress(): string | undefined {
 export const emailInviteAdapter: ChannelInviteAdapter = {
   channel: "email",
 
-  buildGuardianInstruction(params: {
-    inviteCode: string;
-    contactName?: string;
-  }): GuardianInstruction {
-    const address = resolveAssistantEmailAddress();
-    const contactLabel = params.contactName || "the contact";
-    if (!address) {
-      return {
-        instruction: `Tell ${contactLabel} to email the assistant and include the code ${params.inviteCode} in the message.`,
-      };
-    }
-    return {
-      instruction: `Tell ${contactLabel} to email ${address} and include the code ${params.inviteCode} in the message.`,
-      channelHandle: address,
-    };
-  },
-
-  resolveChannelHandle(): string | undefined {
-    return resolveAssistantEmailAddress();
+  async resolveChannelHandleAsync(): Promise<string | undefined> {
+    return getEmailService().getPrimaryInboxAddress();
   },
 };

package/src/runtime/channel-invite-transports/slack.ts

@@ -1,19 +1,15 @@
 /**
  * Slack channel invite adapter.
  *
- * Provides guardian instruction text that includes the assistant's Slack
- * bot @username and workspace name when available. Slack invites use the
- * universal 6-digit code path for redemption, so this adapter only
- * implements `buildGuardianInstruction` — no `buildShareLink` or
- * `extractInboundToken` needed.
+ * Resolves the assistant's Slack bot @username for use in invite
+ * instructions. Slack invites use the universal 6-digit code path for
+ * redemption, so this adapter only implements `resolveChannelHandle` —
+ * no `buildShareLink` or `extractInboundToken` needed.
  */
 
 import type { ChannelId } from "../../channels/types.js";
 import { getCredentialMetadata } from "../../tools/credentials/metadata-store.js";
-import type {
-  ChannelInviteAdapter,
-  GuardianInstruction,
-} from "../channel-invite-transport.js";
+import type { ChannelInviteAdapter } from "../channel-invite-transport.js";
 
 // ---------------------------------------------------------------------------
 // Slack bot info resolution
@@ -54,31 +50,6 @@ function resolveSlackBotInfo(): SlackBotInfo | undefined {
 export const slackInviteAdapter: ChannelInviteAdapter = {
   channel: "slack" as ChannelId,
 
-  buildGuardianInstruction(params: {
-    inviteCode: string;
-    contactName?: string;
-  }): GuardianInstruction {
-    const botInfo = resolveSlackBotInfo();
-    const contactLabel = params.contactName || "the contact";
-
-    if (!botInfo) {
-      return {
-        instruction: `Tell ${contactLabel} to message the assistant on Slack and provide the code ${params.inviteCode}.`,
-      };
-    }
-
-    let instruction = `Tell ${contactLabel} to message @${botInfo.botUsername} on Slack and provide the code ${params.inviteCode}`;
-    if (botInfo.teamName) {
-      instruction += ` (workspace: ${botInfo.teamName})`;
-    }
-    instruction += ".";
-
-    return {
-      instruction,
-      channelHandle: `@${botInfo.botUsername}`,
-    };
-  },
-
   resolveChannelHandle(): string | undefined {
     const botInfo = resolveSlackBotInfo();
     if (!botInfo) return undefined;