@vellumai/assistant 0.8.4 → 0.8.6

package/src/providers/retry.ts

@@ -34,6 +34,7 @@ const USAGE_ATTRIBUTION_HEADER_NAMES = {
   inferenceProfileSource: "X-Vellum-Inference-Profile-Source",
   resolvedProvider: "X-Vellum-Resolved-Provider",
   resolvedModel: "X-Vellum-Resolved-Model",
+  resolvedMixArm: "X-Vellum-Resolved-Mix-Arm",
 } as const;
 
 /** Providers that support the `effort` config (extended thinking / reasoning). */
@@ -47,9 +48,18 @@ const EFFORT_SUPPORTED_PROVIDERS = new Set([
 /**
  * Providers that consume the `thinking` config. Anthropic uses it directly on
  * the wire; OpenRouter either forwards it to its Anthropic-compatible path or
- * translates it into the unified `reasoning` parameter on OpenAI-compat calls.
+ * translates it into the unified `reasoning` parameter on OpenAI-compat calls;
+ * Gemini reads `thinking.level` to populate `thinkingConfig.thinkingLevel`.
  */
-const THINKING_AWARE_PROVIDERS = new Set(["anthropic", "openrouter"]);
+const THINKING_AWARE_PROVIDERS = new Set(["anthropic", "openrouter", "gemini"]);
+
+/**
+ * Providers that consume Gemini-only thinking extras (`level`,
+ * `streamThinking`). For other thinking-aware providers, we scrub these from
+ * the normalized wire payload because Anthropic's SDK rejects unknown keys
+ * inside the `thinking` object with "Extra inputs are not permitted".
+ */
+const THINKING_EXTRA_FIELDS_AWARE_PROVIDERS = new Set(["gemini"]);
 
 /**
  * Providers that consume the `verbosity` config. Currently OpenAI (mapped to
@@ -186,19 +196,23 @@ function normalizeSendMessageOptions(
   delete nextConfig.usageAttributionHeaders;
   delete nextConfig.usageTracking;
 
-  // `overrideProfile` is a routing/resolution-time concern (consumed by the
-  // resolver below and `CallSiteRoutingProvider`'s provider selection); it is
-  // not a wire-format field. Strip unconditionally so it never leaks into
-  // provider request bodies even when callers set it without a `callSite`.
+  // `overrideProfile` and `selectionSeed` are routing/resolution-time concerns
+  // (consumed by the resolver below and `CallSiteRoutingProvider`'s provider
+  // selection); neither is a wire-format field. Strip unconditionally so they
+  // never leak into provider request bodies even when callers set them without
+  // a `callSite`.
   delete nextConfig.overrideProfile;
+  delete nextConfig.selectionSeed;
 
   if (config.callSite !== undefined) {
     const resolved = resolveCallSiteConfig(config.callSite, getConfig().llm, {
       overrideProfile: config.overrideProfile,
+      selectionSeed: config.selectionSeed,
     });
     const attribution = resolveUsageAttribution({
       callSite: config.callSite,
       overrideProfile: config.overrideProfile,
+      selectionSeed: config.selectionSeed,
     });
 
     const explicitModel =
@@ -216,6 +230,7 @@ function normalizeSendMessageOptions(
         profileSource: attribution.profileSource,
         resolvedProvider: attribution.resolvedProvider,
         resolvedModel: attribution.resolvedModel,
+        resolvedMixArm: attribution.resolvedMixArm,
       });
       if (Object.keys(usageAttributionHeaders).length > 0) {
         nextConfig.usageAttributionHeaders = usageAttributionHeaders;
@@ -289,7 +304,8 @@ function normalizeSendMessageOptions(
   }
 
   // thinking is Anthropic-specific on the wire; OpenRouter reads it as a
-  // signal for its unified reasoning parameter. Strip it for other providers.
+  // signal for its unified reasoning parameter; Gemini reads `level` from it.
+  // Strip it for other providers.
   if (
     !THINKING_AWARE_PROVIDERS.has(providerName) &&
     nextConfig.thinking !== undefined
@@ -297,6 +313,27 @@ function normalizeSendMessageOptions(
     delete nextConfig.thinking;
   }
 
+  // Strip Gemini-only extras (`level`, `streamThinking`) from the wire
+  // `thinking` object for providers that don't read them. Anthropic in
+  // particular rejects unknown keys inside `thinking` with "Extra inputs are
+  // not permitted"; the OpenRouter Anthropic-compat path hits the same SDK.
+  if (
+    nextConfig.thinking !== undefined &&
+    !THINKING_EXTRA_FIELDS_AWARE_PROVIDERS.has(providerName) &&
+    typeof nextConfig.thinking === "object" &&
+    nextConfig.thinking !== null
+  ) {
+    const wire = nextConfig.thinking as Record<string, unknown>;
+    if (wire.level !== undefined || wire.streamThinking !== undefined) {
+      const scrubbed: Record<string, unknown> = {};
+      for (const [key, value] of Object.entries(wire)) {
+        if (key === "level" || key === "streamThinking") continue;
+        scrubbed[key] = value;
+      }
+      nextConfig.thinking = scrubbed;
+    }
+  }
+
   // Anthropic (and OpenRouter fronting Anthropic) rejects requests that
   // combine extended thinking with forced tool use (`tool_choice.type` of
   // `"tool"` or `"any"`).  Strip thinking when both are present so the
@@ -415,6 +452,7 @@ function buildUsageAttributionHeaders(input: {
   profileSource: string;
   resolvedProvider: string;
   resolvedModel: string;
+  resolvedMixArm: string | null;
 }): Record<string, string> {
   const headers: Record<string, string> = {};
   addSanitizedHeader(
@@ -444,6 +482,11 @@ function buildUsageAttributionHeaders(input: {
     USAGE_ATTRIBUTION_HEADER_NAMES.resolvedModel,
     input.resolvedModel,
   );
+  addSanitizedHeader(
+    headers,
+    USAGE_ATTRIBUTION_HEADER_NAMES.resolvedMixArm,
+    input.resolvedMixArm,
+  );
   return headers;
 }
 

package/src/providers/search-provider-catalog.ts

@@ -42,8 +42,17 @@ export interface SearchProviderCatalogEntry {
    * privacy notices). Defaults to {@link displayName} when omitted.
    */
   readonly displayNameLong?: string;
-  /** Authentication style. `managed` providers are routed through the
-   *  inference provider; `byok` providers require a user-supplied key. */
+  /**
+   * Authentication style for the search provider choice.
+   *
+   * `managed` means the choice does not require a user-supplied search API key.
+   * For `inference-provider-native`, the daemon uses the inference API's native
+   * hosted web-search tool only when the selected inference provider/model
+   * supports it. Managed non-native inference providers keep the app-executed
+   * `web_search` tool, which can route through the platform search proxy.
+   *
+   * `byok` providers require a user-supplied key in Your Own mode.
+   */
   readonly kind: SearchProviderKind;
   /** Placeholder shown in the API-key input. BYOK providers only. */
   readonly apiKeyPrefix?: string;
@@ -99,19 +108,18 @@ export const SEARCH_PROVIDER_CATALOG: readonly SearchProviderCatalogEntry[] = [
 ];
 
 /** Provider ids accepted by the web-search config schema. */
-export const SEARCH_PROVIDER_IDS: readonly string[] = SEARCH_PROVIDER_CATALOG.map(
-  (p) => p.id,
-);
+export const SEARCH_PROVIDER_IDS: readonly string[] =
+  SEARCH_PROVIDER_CATALOG.map((p) => p.id);
 
 /** Catalog entries that store an API key under their bare provider name. */
 export const BYOK_SEARCH_PROVIDERS: readonly SearchProviderCatalogEntry[] =
   SEARCH_PROVIDER_CATALOG.filter((p) => p.kind === "byok");
 
 /** BYOK provider ids, ordered by `fallbackOrder` (ascending). */
-export const SEARCH_PROVIDER_FALLBACK_ORDER: readonly string[] = BYOK_SEARCH_PROVIDERS
-  .slice()
-  .sort((a, b) => (a.fallbackOrder ?? 0) - (b.fallbackOrder ?? 0))
-  .map((p) => p.id);
+export const SEARCH_PROVIDER_FALLBACK_ORDER: readonly string[] =
+  BYOK_SEARCH_PROVIDERS.slice()
+    .sort((a, b) => (a.fallbackOrder ?? 0) - (b.fallbackOrder ?? 0))
+    .map((p) => p.id);
 
 /** Look up a single catalog entry by id. Returns `undefined` if unknown. */
 export function getSearchProvider(

package/src/providers/thinking-config.ts

@@ -1,20 +1,45 @@
+import { THINKING_LEVELS, type ThinkingLevel } from "../config/schemas/llm.js";
+
 type ThinkingConfigRecord = Record<string, unknown>;
 
+const THINKING_LEVEL_SET: ReadonlySet<string> = new Set(THINKING_LEVELS);
+
 function isRecord(value: unknown): value is ThinkingConfigRecord {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
+function pickGeminiExtras(thinking: ThinkingConfigRecord): {
+  level?: ThinkingLevel;
+  streamThinking?: boolean;
+} {
+  const extras: { level?: ThinkingLevel; streamThinking?: boolean } = {};
+  if (
+    typeof thinking.level === "string" &&
+    THINKING_LEVEL_SET.has(thinking.level)
+  ) {
+    extras.level = thinking.level as ThinkingLevel;
+  }
+  if (typeof thinking.streamThinking === "boolean") {
+    extras.streamThinking = thinking.streamThinking;
+  }
+  return extras;
+}
+
 export function normalizeThinkingConfigForWire(
   thinking: unknown,
 ): ThinkingConfigRecord | undefined {
   if (!isRecord(thinking)) return undefined;
 
+  // Already in wire shape — preserve as-is so re-normalization is idempotent
+  // and Gemini-only fields stay attached for the Gemini provider to read.
   if (typeof thinking.type === "string") {
     return thinking;
   }
 
+  const extras = pickGeminiExtras(thinking);
+
   if (thinking.enabled === true) {
-    return { type: "adaptive" };
+    return { type: "adaptive", ...extras };
   }
 
   if (thinking.enabled === false) {

package/src/providers/types.ts

@@ -182,6 +182,15 @@ export interface SendMessageConfig {
    * silently fall through.
    */
   overrideProfile?: string;
+  /**
+   * Per-conversation seed for deterministic `mix`-profile expansion. The agent
+   * loop sets this to the conversation id so every resolver call this send
+   * triggers — provider/transport selection, wire-param normalization, usage
+   * attribution — picks the same mix constituent, stable across the
+   * conversation's turns and retries. A resolution/routing-time concern only;
+   * stripped before any provider wire request.
+   */
+  selectionSeed?: string;
   /**
    * Internal per-request HTTP headers for managed-proxy usage attribution.
    * Provider clients may pass these through SDK request options only when the

package/src/providers/usage-tracking.ts

@@ -2,6 +2,7 @@ import { recordUsageEvent } from "../memory/llm-usage-store.js";
 import { resolveUsageAttribution } from "../usage/attribution.js";
 import {
   buildPricingUsageFromResponse,
+  extractRawUsage,
   resolveStructuredPricing,
 } from "../usage/pricing.js";
 import { getLogger } from "../util/logger.js";
@@ -76,6 +77,7 @@ export class UsageTrackingProvider implements Provider {
           outputTokens: pricingUsage.outputTokens,
           cacheCreationInputTokens: pricingUsage.cacheCreationInputTokens,
           cacheReadInputTokens: pricingUsage.cacheReadInputTokens,
+          rawUsage: extractRawUsage(response.rawResponse),
           conversationId: null,
           runId: null,
           requestId: null,

package/src/runtime/AGENTS.md

@@ -161,10 +161,10 @@ All `/v1/*` endpoints share a per-client-IP sliding-window rate limiter (`middle
 
 When the limit is exceeded, the limiter returns 429 and logs a structured warning (module: `rate-limiter`) with the denied endpoint and a breakdown of which endpoints consumed the budget in the current window. This makes it easy to identify whether the cause is rapid conversation switching, polling, or unexpected request volume.
 
-Logs are written to `~/.vellum/workspace/data/logs/vellum.log` by default. If `logFile.dir` is configured, logs rotate daily as `assistant-YYYY-MM-DD.log` in that directory. To watch rate limit events in real time:
+Logs rotate daily into `$VELLUM_WORKSPACE_DIR/data/logs/assistant-YYYY-MM-DD.log` (or into the directory configured via `logFile.dir`). To watch rate limit events in real time:
 
 ```bash
-tail -f ~/.vellum/workspace/data/logs/vellum.log | grep rate-limit
+tail -f "$VELLUM_WORKSPACE_DIR/data/logs/assistant-$(date -u +%Y-%m-%d).log" | grep rate-limit
 ```
 
 The provider-level rate limiter (`providers/ratelimit.ts`) also logs warnings (module: `rate-limit`) when request rate or token budget limits are enforced.

package/src/runtime/__tests__/agent-wake.test.ts

@@ -29,6 +29,7 @@ import type { DiskPressureStatus } from "../../daemon/disk-pressure-guard.js";
 mock.module("../../memory/conversation-crud.js", () => ({
   getConversationOverrideProfile: () => undefined,
   getConversation: () => ({ archivedAt: null }),
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 
 const mockGetOrCreateConversationCalls: Array<{

package/src/runtime/__tests__/background-job-runner.test.ts

@@ -40,6 +40,7 @@ mock.module("../../memory/conversation-crud.js", () => ({
     addMessageCalls.push({ conversationId, role, content });
     return { id: `msg-${addMessageCalls.length}` };
   },
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 
 let processMessageImpl: (

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

@@ -217,6 +217,7 @@ export function notifyGuardianOfAccessRequest(
     sourceEventName: "ingress.access_request",
     sourceChannel: sourceChannel as NotificationSourceChannel,
     sourceContextId: `access-req-${sourceChannel}-${actorExternalId}`,
+    requiresConversation: true,
     ...(sameChannelOnly ? { routingIntent: "single_channel" as const } : {}),
     attentionHints: {
       requiresAction: true,

package/src/runtime/agent-wake.ts

@@ -640,6 +640,7 @@ export async function wakeAgentForOpportunity(
           JSON.stringify(record.rawResponse),
           undefined,
           record.provider,
+          "mainAgent",
         );
       } catch (err) {
         log.warn(

package/src/runtime/assistant-event-hub.ts

@@ -247,6 +247,10 @@ export class AssistantEventHub {
    * Publish an event to all matching subscribers.
    *
    * Matching rules:
+   * - if `excludeClientId` is set, the subscriber with that clientId is
+   *   skipped regardless of every other rule (self-echo suppression — the
+   *   client that originated the mutation does not receive its own
+   *   invalidation back through the hub).
    * - if `targetClientId` is set, deliver only to the subscriber with that
    *   clientId, bypassing the conversation-id filter entirely (the web-origin
    *   event's conversationId differs from the macOS client's subscribed
@@ -255,6 +259,11 @@ export class AssistantEventHub {
    *   `event.conversationId` must equal it
    * - if `targetCapability` is set, only subscribers whose capabilities include
    *   it receive the event; untargeted events go to all
+   * - if `targetInterfaceId` is set, only client subscribers whose
+   *   `interfaceId` matches receive the event; process subscribers and
+   *   non-matching clients are skipped. Used to narrow legacy
+   *   broadcasts (e.g. `conversation_list_invalidated`) to a specific
+   *   client surface during a migration window.
    *
    * Fanout is isolated: a throwing or rejecting subscriber does not abort
    * delivery to remaining subscribers.
@@ -264,6 +273,15 @@ export class AssistantEventHub {
     options?: {
       targetCapability?: HostProxyCapability;
       targetClientId?: string;
+      targetInterfaceId?: InterfaceId;
+      /**
+       * Skip the subscriber with this `clientId`. Used for self-echo
+       * suppression on `sync_changed`: the route handler echoes the
+       * originating tab's `X-Vellum-Client-Id` back on the event, and the
+       * hub uses it here to avoid re-delivering the invalidation to the
+       * tab that already mutated its own optimistic state.
+       */
+      excludeClientId?: string;
     },
   ): Promise<void> {
     if (event.conversationId) {
@@ -276,12 +294,33 @@ export class AssistantEventHub {
 
     const targetCapability = options?.targetCapability;
     const targetClientId = options?.targetClientId;
+    const targetInterfaceId = options?.targetInterfaceId;
+    const excludeClientId = options?.excludeClientId;
     const snapshot = Array.from(this.subscribers);
     const errors: unknown[] = [];
 
     for (const entry of snapshot) {
       if (!entry.active) continue;
 
+      // Self-echo suppression: the originating client never receives the
+      // event back. Checked before every other rule so it composes with
+      // both targeted and untargeted broadcasts.
+      if (
+        excludeClientId != null &&
+        entry.type === "client" &&
+        entry.clientId === excludeClientId
+      ) {
+        continue;
+      }
+
+      // Interface targeting: skip any subscriber that is not a client of
+      // the requested interface. Composes with `targetClientId` and
+      // `targetCapability` below.
+      if (targetInterfaceId != null) {
+        if (entry.type !== "client" || entry.interfaceId !== targetInterfaceId)
+          continue;
+      }
+
       if (targetClientId != null) {
         // Targeted: bypass conversation filter, deliver only to the named client.
         if (entry.type !== "client" || entry.clientId !== targetClientId)
@@ -519,10 +558,11 @@ let _hubChain = Promise.resolve();
 export function broadcastMessage(
   msg: ServerMessage,
   conversationId?: string,
-  options?: { targetClientId?: string },
+  options?: { targetClientId?: string; targetInterfaceId?: InterfaceId },
 ): void {
   const resolvedConversationId = conversationId ?? extractConversationId(msg);
   const targetClientId = options?.targetClientId;
+  const targetInterfaceId = options?.targetInterfaceId;
 
   // Confirmation-request side effects: canonical guardian request creation.
   // The home-feed `activity.failed` notification side-effect lives in the
@@ -539,16 +579,45 @@ export function broadcastMessage(
       : resolvedConversationId;
   const event = buildAssistantEvent(msg, scopedConversationId);
   const targetCapability = capabilityForMessageType(msg.type);
+  // Self-echo suppression: a `sync_changed` carrying an `originClientId`
+  // means a specific client just mutated the resource. The hub must not
+  // re-deliver the invalidation to that client — it already updated its
+  // optimistic state locally and a redundant invalidation would clobber it
+  // with a flash of stale-then-fresh data. Assistant-internal emits (agent
+  // loop, FS watcher, cron) leave `originClientId` unset and the event
+  // fans out to every subscriber as before.
+  const excludeClientId =
+    msg.type === "sync_changed" &&
+    typeof msg.originClientId === "string" &&
+    msg.originClientId.length > 0
+      ? msg.originClientId
+      : undefined;
   const publishOptions =
-    targetCapability != null || targetClientId != null
-      ? { targetCapability, targetClientId }
+    targetCapability != null ||
+    targetClientId != null ||
+    targetInterfaceId != null ||
+    excludeClientId != null
+      ? {
+          targetCapability,
+          targetClientId,
+          targetInterfaceId,
+          excludeClientId,
+        }
       : undefined;
   _hubChain = _hubChain
     .then(() => assistantEventHub.publish(event, publishOptions))
     .then(() => {
-      // When a conversation title changes, also broadcast an unscoped
-      // `conversation_list_invalidated` so every connected client's sidebar
-      // refreshes — not just the client viewing this conversation.
+      // When a conversation title changes, also publish a
+      // `conversation_list_invalidated` so the macOS sidebar refreshes
+      // its row ordering for the renamed conversation. Web consumes the
+      // paired `sync_changed` with `conversation:<id>:metadata` tag
+      // emitted by `publishConversationTitleChanged` and patches the
+      // single row in place, so the broadcast is scoped to macOS only.
+      //
+      // TODO(electron-cutover): remove this emission once macOS migrates
+      // to the Electron client and consumes `sync_changed` directly. At
+      // that point `conversation_list_invalidated` has no remaining
+      // consumers and the message type can be retired.
       if (msg.type === "conversation_title_updated") {
         return assistantEventHub
           .publish(
@@ -556,6 +625,7 @@ export function broadcastMessage(
               type: "conversation_list_invalidated",
               reason: "renamed",
             }),
+            { targetInterfaceId: "macos" },
           )
           .catch((err: unknown) => {
             log.warn(

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

@@ -209,6 +209,7 @@ const ACTOR_ENDPOINTS: Array<{ endpoint: string; scopes: Scope[] }> = [
   { endpoint: "identity/intro", scopes: ["settings.read"] },
   { endpoint: "home/state", scopes: ["settings.read"] },
   { endpoint: "home/feed", scopes: ["settings.read"] },
+  { endpoint: "home/feed/query", scopes: ["settings.read"] },
   { endpoint: "home/feed:PATCH", scopes: ["settings.write"] },
   { endpoint: "home/feed/actions", scopes: ["settings.write"] },
   { endpoint: "brain-graph", scopes: ["settings.read"] },
@@ -417,6 +418,7 @@ const ACTOR_ENDPOINTS: Array<{ endpoint: string; scopes: Scope[] }> = [
 
   // LLM call site catalog
   { endpoint: "config/llm/call-sites:GET", scopes: ["settings.read"] },
+  { endpoint: "config/llm/profiles:GET", scopes: ["settings.read"] },
 
   // Conversation management
   { endpoint: "conversations:DELETE", scopes: ["chat.write"] },
@@ -440,6 +442,8 @@ const ACTOR_ENDPOINTS: Array<{ endpoint: string; scopes: Scope[] }> = [
   // Message content
   { endpoint: "messages/content", scopes: ["chat.read"] },
   { endpoint: "messages/llm-context", scopes: ["chat.read"] },
+  { endpoint: "conversations/llm-context", scopes: ["chat.read"] },
+  { endpoint: "conversations/compaction", scopes: ["chat.read"] },
   { endpoint: "llm-request-logs/payload", scopes: ["chat.read"] },
   { endpoint: "messages/tts", scopes: ["chat.read"] },
   { endpoint: "tts/synthesize", scopes: ["chat.read"] },
@@ -458,6 +462,11 @@ const ACTOR_ENDPOINTS: Array<{ endpoint: string; scopes: Scope[] }> = [
   { endpoint: "skills:DELETE", scopes: ["settings.write"] },
   { endpoint: "skills:PATCH", scopes: ["settings.write"] },
 
+  // Plugins (read-only for now — install / uninstall stay CLI-side)
+  { endpoint: "plugins:GET", scopes: ["settings.read"] },
+  { endpoint: "plugins/search:GET", scopes: ["settings.read"] },
+  { endpoint: "plugins:DELETE", scopes: ["settings.write"] },
+
   // Memory items
   { endpoint: "memory-items:GET", scopes: ["settings.read"] },
   { endpoint: "memory-items:POST", scopes: ["settings.write"] },
@@ -471,6 +480,20 @@ const ACTOR_ENDPOINTS: Array<{ endpoint: string; scopes: Scope[] }> = [
   { endpoint: "memory/v2/concept-frequency:POST", scopes: ["settings.read"] },
   { endpoint: "memory/v2/ema-scores:POST", scopes: ["settings.read"] },
   { endpoint: "memory/v2/simulate-router:POST", scopes: ["settings.read"] },
+  {
+    endpoint: "memory/v2/compare-retrievers:POST",
+    scopes: ["settings.read"],
+  },
+  {
+    endpoint: "memory/v2/router-prompt-template:GET",
+    scopes: ["settings.read"],
+  },
+  { endpoint: "memory/v2/now-text:GET", scopes: ["settings.read"] },
+  { endpoint: "memory/v3/validate:POST", scopes: ["settings.read"] },
+  { endpoint: "memory/v3/tree:POST", scopes: ["settings.read"] },
+  { endpoint: "memory/v3/simulate:POST", scopes: ["settings.read"] },
+  { endpoint: "memory/v3/shadow-diff:POST", scopes: ["settings.read"] },
+  { endpoint: "memory/v3/seed-edges:POST", scopes: ["settings.write"] },
 
   // Trust rule listing
   { endpoint: "trust-rules/manage:GET", scopes: ["settings.read"] },
@@ -665,6 +688,12 @@ registerPolicy("channels/inbound", {
   allowedPrincipalTypes: ["svc_gateway"],
 });
 
+// Background wake control-plane calls from the platform.
+registerPolicy("background-wake", {
+  requiredScopes: ["internal.write"],
+  allowedPrincipalTypes: ["svc_gateway"],
+});
+
 // Internal forwarding endpoints: gateway-only
 const INTERNAL_ENDPOINTS = [
   "internal/twilio/voice-webhook",
@@ -843,6 +872,12 @@ registerPolicy("notifications/events", {
   allowedPrincipalTypes: ["local"],
 });
 
+// Edit an already-sent notification: local-only (CLI / IPC callers)
+registerPolicy("notifications/edit", {
+  requiredScopes: ["settings.write"],
+  allowedPrincipalTypes: ["local"],
+});
+
 // Defer operations: local-only (CLI / IPC callers)
 registerPolicy("defer/create", {
   requiredScopes: ["settings.write"],
@@ -887,6 +922,12 @@ registerPolicy("browser/execute", {
   allowedPrincipalTypes: ["local"],
 });
 
+// Browser tabs operations (list/select/new/close): local-only (CLI / IPC callers)
+registerPolicy("browser/tabs", {
+  requiredScopes: ["settings.write"],
+  allowedPrincipalTypes: ["local"],
+});
+
 // Background tools: local-only (CLI / IPC callers)
 registerPolicy("background-tools", {
   requiredScopes: ["settings.read"],
@@ -922,6 +963,11 @@ registerPolicy("domain/status", {
   allowedPrincipalTypes: ["local"],
 });
 
+registerPolicy("domain/verification-status", {
+  requiredScopes: ["settings.read"],
+  allowedPrincipalTypes: ["local"],
+});
+
 // Email management (IPC-local)
 registerPolicy("email/register", {
   requiredScopes: ["settings.write"],

package/src/runtime/btw-sidechain.ts

@@ -40,9 +40,6 @@ export interface RunBtwSidechainParams {
   signal?: AbortSignal;
   timeoutMs?: number;
   onEvent?: (event: ProviderEvent) => void;
-  userPersona?: string | null;
-  channelPersona?: string | null;
-  userSlug?: string | null;
 }
 
 export interface RunBtwSidechainResult {
@@ -79,9 +76,6 @@ export async function runBtwSidechain(
       : buildSystemPrompt({
           excludeBootstrap: true,
           excludeCustomPrefix: true,
-          userPersona: params.userPersona,
-          channelPersona: params.channelPersona,
-          userSlug: params.userSlug,
         }));
 
   const { signal: timeoutSignal, cleanup } = createTimeout(

package/src/runtime/channel-readiness-service.ts

@@ -282,6 +282,74 @@ const slackProbe: ChannelProbe = {
       ),
     ];
   },
+  async runRemoteChecks(): Promise<ReadinessCheckResult[]> {
+    const botToken = await getSecureKeyAsync(
+      credentialKey("slack_channel", "bot_token"),
+    );
+    if (!botToken) {
+      return [
+        check(
+          "auth_test",
+          false,
+          "Slack auth.test ok",
+          "Skipped: no bot_token stored",
+        ),
+      ];
+    }
+    try {
+      const res = await fetch("https://slack.com/api/auth.test", {
+        method: "POST",
+        headers: { Authorization: `Bearer ${botToken}` },
+      });
+      const data = (await res.json()) as {
+        ok: boolean;
+        error?: string;
+        team_id?: string;
+        team?: string;
+        user?: string;
+      };
+      if (!data.ok) {
+        return [
+          check(
+            "auth_test",
+            false,
+            "Slack auth.test ok",
+            `Slack auth.test rejected bot_token: ${data.error ?? "unknown error"}`,
+          ),
+        ];
+      }
+      const raw = loadRawConfig();
+      const storedTeamId = getNestedValue(raw, "slack.teamId");
+      const teamMatches =
+        typeof storedTeamId !== "string" ||
+        storedTeamId.length === 0 ||
+        storedTeamId === data.team_id;
+      return [
+        check(
+          "auth_test",
+          true,
+          `Slack auth.test ok (workspace ${data.team ?? data.team_id ?? "unknown"}, bot ${data.user ?? "unknown"})`,
+          "Slack auth.test ok",
+        ),
+        check(
+          "workspace_match",
+          teamMatches,
+          "Stored workspace matches bot token",
+          `Stored workspace ${storedTeamId} does not match bot token's workspace ${data.team_id ?? "unknown"} — run 'assistant channels slack reconnect' to refresh metadata`,
+        ),
+      ];
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return [
+        check(
+          "auth_test",
+          false,
+          "Slack auth.test ok",
+          `Failed to reach Slack auth.test: ${message}`,
+        ),
+      ];
+    }
+  },
 };
 
 // ── Service ─────────────────────────────────────────────────────────────────