@vellumai/vellum-gateway 0.8.3 → 0.8.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/vellum-gateway",
-  "version": "0.8.3",
+  "version": "0.8.4",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/__tests__/ipc-slack-thread-routes.test.ts

@@ -0,0 +1,157 @@
+import {
+  afterAll,
+  afterEach,
+  beforeAll,
+  beforeEach,
+  describe,
+  expect,
+  test,
+} from "bun:test";
+import { randomBytes } from "node:crypto";
+import { createConnection, type Socket } from "node:net";
+
+import {
+  getGatewayDb,
+  initGatewayDb,
+  resetGatewayDb,
+} from "../db/connection.js";
+import { SlackStore } from "../db/slack-store.js";
+import { slackActiveThreads } from "../db/schema.js";
+import { GatewayIpcServer } from "../ipc/server.js";
+import { slackThreadRoutes } from "../ipc/slack-thread-handlers.js";
+
+const CHANNEL_ID = "CFAKE00001";
+const OTHER_CHANNEL_ID = "COTHER0001";
+const THREAD_TS = "1700000000.000000";
+const OTHER_THREAD_TS = "1700000001.000000";
+
+beforeAll(async () => {
+  await initGatewayDb();
+});
+
+beforeEach(() => {
+  getGatewayDb().delete(slackActiveThreads).run();
+});
+
+afterAll(() => {
+  resetGatewayDb();
+});
+
+function connectClient(path: string): Promise<Socket> {
+  return new Promise((resolve, reject) => {
+    const client = createConnection(path, () => resolve(client));
+    client.on("error", reject);
+  });
+}
+
+function sendRequest(
+  client: Socket,
+  method: string,
+  params?: Record<string, unknown>,
+): Promise<{ id: string; result?: unknown; error?: string }> {
+  return new Promise((resolve, reject) => {
+    const id = randomBytes(4).toString("hex");
+    let buffer = "";
+
+    const onData = (chunk: Buffer) => {
+      buffer += chunk.toString();
+      const newlineIdx = buffer.indexOf("\n");
+      if (newlineIdx !== -1) {
+        const line = buffer.slice(0, newlineIdx).trim();
+        buffer = buffer.slice(newlineIdx + 1);
+        client.off("data", onData);
+        try {
+          resolve(JSON.parse(line));
+        } catch (err) {
+          reject(err);
+        }
+      }
+    };
+
+    client.on("data", onData);
+    client.write(JSON.stringify({ id, method, params }) + "\n");
+  });
+}
+
+function activeThreadRows(): Array<{ threadTs: string; channelId: string }> {
+  return new SlackStore(getGatewayDb()).listActiveThreadsWithChannel();
+}
+
+function trackThread(): void {
+  new SlackStore(getGatewayDb()).trackThread(THREAD_TS, CHANNEL_ID, 60_000);
+}
+
+describe("IPC Slack thread routes", () => {
+  let server: InstanceType<typeof GatewayIpcServer>;
+  let client: Socket;
+
+  afterEach(() => {
+    client?.destroy();
+    server?.stop();
+  });
+
+  async function startServerAndConnect(): Promise<void> {
+    server = new GatewayIpcServer([...slackThreadRoutes]);
+    server.start();
+    await new Promise((resolve) => setTimeout(resolve, 50));
+    client = await connectClient(server.getSocketPath());
+  }
+
+  test("detach_slack_active_thread removes a matching active thread", async () => {
+    trackThread();
+
+    await startServerAndConnect();
+    const res = await sendRequest(client, "detach_slack_active_thread", {
+      channelId: CHANNEL_ID,
+      threadTs: THREAD_TS,
+    });
+
+    expect(res.error).toBeUndefined();
+    expect(res.result).toEqual({
+      detached: true,
+      channelId: CHANNEL_ID,
+      threadTs: THREAD_TS,
+    });
+    expect(activeThreadRows()).toEqual([]);
+  });
+
+  test("detach_slack_active_thread is idempotent for an unknown thread", async () => {
+    trackThread();
+
+    await startServerAndConnect();
+    const res = await sendRequest(client, "detach_slack_active_thread", {
+      channelId: CHANNEL_ID,
+      threadTs: OTHER_THREAD_TS,
+    });
+
+    expect(res.error).toBeUndefined();
+    expect(res.result).toEqual({
+      detached: false,
+      channelId: CHANNEL_ID,
+      threadTs: OTHER_THREAD_TS,
+    });
+    expect(activeThreadRows()).toEqual([
+      { threadTs: THREAD_TS, channelId: CHANNEL_ID },
+    ]);
+  });
+
+  test("detach_slack_active_thread does not remove channel mismatches", async () => {
+    trackThread();
+
+    await startServerAndConnect();
+    const res = await sendRequest(client, "detach_slack_active_thread", {
+      channelId: OTHER_CHANNEL_ID,
+      threadTs: THREAD_TS,
+    });
+
+    expect(res.error).toBeUndefined();
+    expect(res.result).toEqual({
+      detached: false,
+      channelId: OTHER_CHANNEL_ID,
+      threadTs: THREAD_TS,
+    });
+    expect(activeThreadRows()).toEqual([
+      { threadTs: THREAD_TS, channelId: CHANNEL_ID },
+    ]);
+  });
+});

package/src/__tests__/slack-display-name.test.ts

@@ -1,5 +1,9 @@
 import { describe, test, expect, mock, beforeEach } from "bun:test";
 import type { GatewayConfig } from "../config.js";
+import type {
+  RuntimeInboundPayload,
+  RuntimeInboundResponse,
+} from "../runtime/client.js";
 
 type FetchFn = (
   input: string | URL | Request,
@@ -8,20 +12,46 @@ type FetchFn = (
 let fetchMock: ReturnType<typeof mock<FetchFn>> = mock(
   async () => new Response(),
 );
+let runtimePayloads: RuntimeInboundPayload[] = [];
+const forwardToRuntimeMock = mock(
+  async (
+    _config: GatewayConfig,
+    payload: RuntimeInboundPayload,
+  ): Promise<RuntimeInboundResponse> => {
+    runtimePayloads.push(payload);
+    return { accepted: true, duplicate: false, eventId: "runtime-event-1" };
+  },
+);
 
 mock.module("../fetch.js", () => ({
   fetchImpl: (...args: Parameters<FetchFn>) => fetchMock(...args),
 }));
 
+mock.module("../runtime/client.js", () => ({
+  CircuitBreakerOpenError: class CircuitBreakerOpenError extends Error {
+    readonly retryAfterSecs: number;
+
+    constructor(retryAfterSecs: number) {
+      super("Circuit breaker is open");
+      this.retryAfterSecs = retryAfterSecs;
+    }
+  },
+  forwardToRuntime: (...args: Parameters<typeof forwardToRuntimeMock>) =>
+    forwardToRuntimeMock(...args),
+}));
+
 const {
   normalizeSlackAppMention,
   resolveSlackChannel,
   resolveSlackUser,
+  resolveSlackUserSync,
   clearChannelInfoCache,
+  clearInFlightFetches,
   clearUserInfoCache,
   getChannelInfoCacheSize,
   getUserInfoCacheSize,
 } = await import("../slack/normalize.js");
+const { handleInbound } = await import("../handlers/handle-inbound.js");
 import type { SlackAppMentionEvent } from "../slack/normalize.js";
 
 function makeConfig(overrides: Partial<GatewayConfig> = {}): GatewayConfig {
@@ -67,6 +97,9 @@ function makeEvent(
 beforeEach(() => {
   clearUserInfoCache();
   clearChannelInfoCache();
+  clearInFlightFetches();
+  runtimePayloads = [];
+  forwardToRuntimeMock.mockClear();
 });
 
 describe("resolveSlackUser", () => {
@@ -78,6 +111,9 @@ describe("resolveSlackUser", () => {
           user: {
             name: "jdoe",
             real_name: "Jane Doe",
+            tz: "America/New_York",
+            tz_label: "Eastern Daylight Time",
+            tz_offset: -14400,
             profile: { display_name: "Jane D", real_name: "Jane Doe" },
           },
         }),
@@ -89,6 +125,9 @@ describe("resolveSlackUser", () => {
     expect(info).not.toBeUndefined();
     expect(info!.displayName).toBe("Jane D");
     expect(info!.username).toBe("jdoe");
+    expect(info!.timezone).toBe("America/New_York");
+    expect(info!.timezoneLabel).toBe("Eastern Daylight Time");
+    expect(info!.timezoneOffsetSeconds).toBe(-14400);
   });
 
   test("falls back to real_name when display_name is empty", async () => {
@@ -151,6 +190,100 @@ describe("resolveSlackUser", () => {
     expect(callCount).toBe(1);
     expect(getUserInfoCacheSize()).toBe(1);
   });
+
+  test("scopes cached user info by bot token", async () => {
+    let callCount = 0;
+    fetchMock = mock(async (_input, init) => {
+      callCount++;
+      const auth = new Headers(init?.headers).get("authorization");
+      const user =
+        auth === "Bearer xoxb-team-a"
+          ? {
+              name: "alice",
+              tz: "America/New_York",
+              tz_label: "Eastern Daylight Time",
+              tz_offset: -14400,
+              profile: { display_name: "Alice" },
+            }
+          : {
+              name: "bob",
+              tz: "America/Los_Angeles",
+              tz_label: "Pacific Daylight Time",
+              tz_offset: -25200,
+              profile: { display_name: "Bob" },
+            };
+      return new Response(JSON.stringify({ ok: true, user }), {
+        status: 200,
+        headers: { "content-type": "application/json" },
+      });
+    });
+
+    const [teamAInfo, teamBInfo] = await Promise.all([
+      resolveSlackUser("U_SHARED", "xoxb-team-a"),
+      resolveSlackUser("U_SHARED", "xoxb-team-b"),
+    ]);
+
+    expect(teamAInfo!.displayName).toBe("Alice");
+    expect(teamAInfo!.timezone).toBe("America/New_York");
+    expect(teamBInfo!.displayName).toBe("Bob");
+    expect(teamBInfo!.timezone).toBe("America/Los_Angeles");
+    expect(callCount).toBe(2);
+    expect(getUserInfoCacheSize()).toBe(2);
+
+    await resolveSlackUser("U_SHARED", "xoxb-team-a");
+    await resolveSlackUser("U_SHARED", "xoxb-team-b");
+    expect(callCount).toBe(2);
+  });
+
+  test("sync cache lookup uses the bot token scope", async () => {
+    let callCount = 0;
+    fetchMock = mock(async (_input, init) => {
+      callCount++;
+      const auth = new Headers(init?.headers).get("authorization");
+      const user =
+        auth === "Bearer xoxb-team-a"
+          ? {
+              name: "alice",
+              tz: "America/Denver",
+              tz_label: "Mountain Daylight Time",
+              tz_offset: -21600,
+              profile: { display_name: "Alice" },
+            }
+          : {
+              name: "bob",
+              tz: "Europe/London",
+              tz_label: "British Summer Time",
+              tz_offset: 3600,
+              profile: { display_name: "Bob" },
+            };
+      return new Response(JSON.stringify({ ok: true, user }), {
+        status: 200,
+        headers: { "content-type": "application/json" },
+      });
+    });
+
+    await resolveSlackUser("U_SHARED_SYNC", "xoxb-team-a");
+
+    const teamACached = resolveSlackUserSync("U_SHARED_SYNC", "xoxb-team-a");
+    expect(teamACached!.displayName).toBe("Alice");
+    expect(teamACached!.timezone).toBe("America/Denver");
+
+    const teamBMiss = resolveSlackUserSync("U_SHARED_SYNC", "xoxb-team-b");
+    expect(teamBMiss).toBeUndefined();
+
+    const teamBResolved = await resolveSlackUser(
+      "U_SHARED_SYNC",
+      "xoxb-team-b",
+    );
+    expect(teamBResolved!.displayName).toBe("Bob");
+    expect(teamBResolved!.timezone).toBe("Europe/London");
+
+    const teamBCached = resolveSlackUserSync("U_SHARED_SYNC", "xoxb-team-b");
+    expect(teamBCached!.displayName).toBe("Bob");
+    expect(teamBCached!.timezone).toBe("Europe/London");
+    expect(callCount).toBe(2);
+    expect(getUserInfoCacheSize()).toBe(2);
+  });
 });
 
 describe("resolveSlackChannel", () => {
@@ -217,6 +350,36 @@ describe("resolveSlackChannel", () => {
     expect(callCount).toBe(1);
     expect(getChannelInfoCacheSize()).toBe(1);
   });
+
+  test("scopes cached channel names by bot token", async () => {
+    let callCount = 0;
+    fetchMock = mock(async (_input, init) => {
+      callCount++;
+      const auth = new Headers(init?.headers).get("authorization");
+      const channel =
+        auth === "Bearer xoxb-team-a"
+          ? { id: "C_SHARED", name: "team-a-channel" }
+          : { id: "C_SHARED", name: "team-b-channel" };
+      return new Response(JSON.stringify({ ok: true, channel }), {
+        status: 200,
+        headers: { "content-type": "application/json" },
+      });
+    });
+
+    const [teamAInfo, teamBInfo] = await Promise.all([
+      resolveSlackChannel("C_SHARED", "xoxb-team-a"),
+      resolveSlackChannel("C_SHARED", "xoxb-team-b"),
+    ]);
+
+    expect(teamAInfo!.name).toBe("team-a-channel");
+    expect(teamBInfo!.name).toBe("team-b-channel");
+    expect(callCount).toBe(2);
+    expect(getChannelInfoCacheSize()).toBe(2);
+
+    await resolveSlackChannel("C_SHARED", "xoxb-team-a");
+    await resolveSlackChannel("C_SHARED", "xoxb-team-b");
+    expect(callCount).toBe(2);
+  });
 });
 
 describe("normalizeSlackAppMention with display name", () => {
@@ -273,6 +436,9 @@ describe("normalizeSlackAppMention with display name", () => {
           user: {
             name: "testuser",
             real_name: "Test User",
+            tz: "America/Denver",
+            tz_label: "Mountain Daylight Time",
+            tz_offset: -21600,
             profile: { display_name: "Test U" },
           },
         }),
@@ -296,6 +462,58 @@ describe("normalizeSlackAppMention with display name", () => {
     expect(result).not.toBeNull();
     expect(result!.event.actor.displayName).toBe("Test U");
     expect(result!.event.actor.username).toBe("testuser");
+    expect(result!.event.actor.timezone).toBe("America/Denver");
+    expect(result!.event.actor.timezoneLabel).toBe("Mountain Daylight Time");
+    expect(result!.event.actor.timezoneOffsetSeconds).toBe(-21600);
+  });
+
+  test("forwards cached Slack timezone fields in runtime source metadata", async () => {
+    fetchMock = mock(async () => {
+      return new Response(
+        JSON.stringify({
+          ok: true,
+          user: {
+            name: "testuser",
+            real_name: "Test User",
+            tz: "America/Los_Angeles",
+            tz_label: "Pacific Daylight Time",
+            tz_offset: -25200,
+            profile: { display_name: "Test U" },
+          },
+        }),
+        { status: 200, headers: { "content-type": "application/json" } },
+      );
+    });
+
+    const config = makeConfig();
+    const event = makeEvent({ user: "U_WITH_TZ" });
+    await resolveSlackUser("U_WITH_TZ", "xoxb-test");
+
+    const result = normalizeSlackAppMention(
+      event,
+      "evt-tz-forward",
+      config,
+      undefined,
+      "xoxb-test",
+    );
+    expect(result).not.toBeNull();
+
+    await handleInbound(config, result!.event, {
+      routingOverride: result!.routing,
+    });
+
+    expect(forwardToRuntimeMock).toHaveBeenCalledTimes(1);
+    const forwardedPayload = runtimePayloads[0];
+    expect(forwardedPayload).toBeDefined();
+    expect(forwardedPayload!.sourceMetadata!.timezone).toBe(
+      "America/Los_Angeles",
+    );
+    expect(forwardedPayload!.sourceMetadata!.timezoneLabel).toBe(
+      "Pacific Daylight Time",
+    );
+    expect(forwardedPayload!.sourceMetadata!.timezoneOffsetSeconds).toBe(
+      -25200,
+    );
   });
 
   test("renders cache-warmed mention labels in model-facing content", async () => {

package/src/__tests__/slack-socket-mode-thread-tracking.test.ts

@@ -4,6 +4,7 @@ import { drizzle } from "drizzle-orm/bun-sqlite";
 import type { GatewayConfig } from "../config.js";
 import { SlackStore } from "../db/slack-store.js";
 import * as schema from "../db/schema.js";
+import type { RuntimeInboundPayload } from "../runtime/client.js";
 import type { NormalizedSlackEvent } from "../slack/normalize.js";
 
 type FetchFn = (
@@ -27,14 +28,42 @@ function makeSlackUserResponse(): Response {
 let fetchMock: ReturnType<typeof mock<FetchFn>> = mock(async () =>
   makeSlackUserResponse(),
 );
+const runtimePayloads: RuntimeInboundPayload[] = [];
 
 mock.module("../fetch.js", () => ({
   fetchImpl: (...args: Parameters<FetchFn>) => fetchMock(...args),
 }));
 
+mock.module("../runtime/client.js", () => ({
+  CircuitBreakerOpenError: class CircuitBreakerOpenError extends Error {
+    readonly retryAfterSecs: number;
+
+    constructor(retryAfterSecs: number) {
+      super("Circuit breaker is open");
+      this.name = "CircuitBreakerOpenError";
+      this.retryAfterSecs = retryAfterSecs;
+    }
+  },
+  forwardToRuntime: mock(
+    async (_config: GatewayConfig, payload: RuntimeInboundPayload) => {
+      runtimePayloads.push(payload);
+      return {
+        accepted: true,
+        duplicate: false,
+        eventId: "runtime-event-1",
+      };
+    },
+  ),
+}));
+
+mock.module("../verification/text-verification.js", () => ({
+  tryTextVerificationIntercept: mock(async () => ({ intercepted: false })),
+}));
+
 const { SlackSocketModeClient } = await import("../slack/socket-mode.js");
 const { clearChannelInfoCache, clearUserInfoCache, resolveSlackUser } =
   await import("../slack/normalize.js");
+const { handleInbound } = await import("../handlers/handle-inbound.js");
 import type { SlackSocketModeConfig } from "../slack/socket-mode.js";
 
 type SocketModeHarness = {
@@ -149,6 +178,7 @@ function flushAsyncEventEmission(): Promise<void> {
 }
 
 beforeEach(() => {
+  runtimePayloads.length = 0;
   clearUserInfoCache();
   clearChannelInfoCache();
   fetchMock = mock(async () => makeSlackUserResponse());
@@ -706,21 +736,85 @@ describe("SlackSocketModeClient thread tracking", () => {
     }
   });
 
+  test("emits a plain app mention without resolving the event channel name", async () => {
+    const { rawDb, store } = createSlackStore();
+    const config = makeConfig();
+    const emitted: NormalizedSlackEvent[] = [];
+    const client = createHarness(store, (event) => emitted.push(event));
+    const ws = makeOpenSocket();
+    const conversationInfoChannels: string[] = [];
+
+    fetchMock = mock(async (input) => {
+      const url = new URL(String(input));
+      if (url.pathname.endsWith("/conversations.info")) {
+        const channelId = url.searchParams.get("channel");
+        if (channelId) {
+          conversationInfoChannels.push(channelId);
+        }
+        return new Response(
+          JSON.stringify({
+            ok: true,
+            channel: { id: channelId, name: "support-triage" },
+          }),
+          { status: 200, headers: { "content-type": "application/json" } },
+        );
+      }
+      return makeSlackUserResponse();
+    });
+
+    try {
+      client.handleMessage(
+        JSON.stringify({
+          envelope_id: "env-channel-name",
+          type: "events_api",
+          payload: {
+            event_id: "Ev-channel-name",
+            event: {
+              type: "app_mention",
+              user: "U-actor",
+              text: "<@UBOT> please summarize this",
+              ts: "1700000000.000950",
+              channel: "C-thread",
+            },
+          },
+        }),
+        ws,
+      );
+      await flushAsyncEventEmission();
+
+      expect(emitted).toHaveLength(1);
+      expect(emitted[0].event.source.channelName).toBeUndefined();
+      expect(conversationInfoChannels).toEqual([]);
+
+      await handleInbound(config, emitted[0].event, {
+        routingOverride: emitted[0].routing,
+      });
+
+      expect(runtimePayloads).toHaveLength(1);
+      expect(runtimePayloads[0].sourceMetadata?.channelName).toBeUndefined();
+    } finally {
+      rawDb.close();
+    }
+  });
+
   test("keeps embedded Slack channel labels without conversations.info lookup", async () => {
     const { rawDb, store } = createSlackStore();
     const emitted: NormalizedSlackEvent[] = [];
     const client = createHarness(store, (event) => emitted.push(event));
     const ws = makeOpenSocket();
-    let conversationInfoCalls = 0;
+    const conversationInfoChannels: string[] = [];
 
     fetchMock = mock(async (input) => {
       const url = new URL(String(input));
       if (url.pathname.endsWith("/conversations.info")) {
-        conversationInfoCalls++;
+        const channelId = url.searchParams.get("channel");
+        if (channelId) {
+          conversationInfoChannels.push(channelId);
+        }
         return new Response(
           JSON.stringify({
             ok: true,
-            channel: { id: "CFEEDBACK", name: "private-name" },
+            channel: { id: channelId, name: "private-name" },
           }),
           { status: 200, headers: { "content-type": "application/json" } },
         );
@@ -752,7 +846,7 @@ describe("SlackSocketModeClient thread tracking", () => {
       expect(emitted[0].event.message.content).toBe(
         "@Example User continue in #visible-name",
       );
-      expect(conversationInfoCalls).toBe(0);
+      expect(conversationInfoChannels).toEqual([]);
     } finally {
       rawDb.close();
     }

package/src/channels/inbound-event.ts

@@ -40,6 +40,9 @@ interface InboundEventBase<C extends InboundChannelId> {
     lastName?: string;
     languageCode?: string;
     isBot?: boolean;
+    timezone?: string;
+    timezoneLabel?: string;
+    timezoneOffsetSeconds?: number;
   };
   source: {
     updateId: string;
@@ -51,6 +54,7 @@ interface InboundEventBase<C extends InboundChannelId> {
      * `In-Reply-To`, etc.) can reuse the field later.
      */
     threadId?: string;
+    channelName?: string;
   };
   raw: Record<string, unknown>;
 }

package/src/db/slack-store.ts

@@ -67,6 +67,16 @@ export class SlackStore {
     return row !== undefined;
   }
 
+  detachThread(threadTs: string, channelId: string): boolean {
+    const raw = (this.db as unknown as { $client: Database }).$client;
+    const changes = raw
+      .prepare(
+        "DELETE FROM slack_active_threads WHERE thread_ts = ? AND channel_id = ?",
+      )
+      .run(threadTs, channelId).changes;
+    return changes > 0;
+  }
+
   /**
    * Returns all unexpired active threads with a known channel for reconnect
    * catch-up. Rows with a NULL `channel_id` (legacy rows from before the

package/src/feature-flag-registry.json

@@ -9,6 +9,14 @@
       "description": "Automatically trigger conversation analysis on the same cadence as memory extraction (batch threshold, idle debounce, end-of-conversation). The analysis agent has full tool access and writes back to memory and skills without user approval.",
       "defaultEnabled": false
     },
+    {
+      "id": "memory-retrospective-fork",
+      "scope": "assistant",
+      "key": "memory-retrospective-fork",
+      "label": "Fork-based memory retrospective",
+      "description": "Fork the source conversation through its latest message for memory retrospectives, instead of rendering the slice into a transcript and waking an empty background conversation. Lets the retrospective hit the provider prompt cache and read compaction summary + tail messages natively.",
+      "defaultEnabled": false
+    },
     {
       "id": "user-hosted-enabled",
       "scope": "client",
@@ -43,7 +51,7 @@
     },
     {
       "id": "settings-developer-nav",
-      "scope": "client",
+      "scope": "assistant",
       "key": "settings-developer-nav",
       "label": "Settings Developer Nav",
       "description": "Control Developer nav visibility in macOS settings",
@@ -89,6 +97,14 @@
       "description": "Surface credential grant and audit inspection endpoints for reviewing active grants and access logs",
       "defaultEnabled": false
     },
+    {
+      "id": "chatgpt-subscription-auth",
+      "scope": "assistant",
+      "key": "chatgpt-subscription-auth",
+      "label": "ChatGPT Subscription Auth",
+      "description": "Enable ChatGPT subscription OAuth as a provider auth type for OpenAI models, using the Codex device-code flow.",
+      "defaultEnabled": false
+    },
     {
       "id": "deploy-to-vercel",
       "scope": "assistant",
@@ -275,7 +291,7 @@
     },
     {
       "id": "account-deletion",
-      "scope": "client",
+      "scope": "assistant",
       "key": "account-deletion",
       "label": "Account Deletion",
       "description": "Surfaces the user-initiated account deletion flow in client settings.",
@@ -299,7 +315,7 @@
     },
     {
       "id": "pro-plan-adjust",
-      "scope": "assistant",
+      "scope": "client",
       "key": "pro-plan-adjust",
       "label": "Pro Plan Adjust",
       "description": "Show the rich Plan card (current plan, features, Manage/Upgrade CTA) at the top of the macOS Settings \u2192 Billing tab.",
@@ -328,6 +344,86 @@
       "label": "Velvet Theme",
       "description": "Show the Velvet theme option in the macOS appearance settings. Velvet is a dark-mode variant with red/pink accent colors.",
       "defaultEnabled": false
+    },
+    {
+      "id": "query-complexity-routing",
+      "scope": "assistant",
+      "key": "query-complexity-routing",
+      "label": "Query Complexity Routing",
+      "description": "Automatically route user messages to the most appropriate inference profile based on query complexity. Simple queries use the speed profile, complex queries escalate to the quality profile. The user is notified of each switch and can opt out by pinning a profile on the conversation.",
+      "defaultEnabled": false
+    },
+    {
+      "id": "queue-steering",
+      "scope": "assistant",
+      "key": "queue-steering",
+      "label": "Queue Steering",
+      "description": "Enable the 'Push to agent' button on queued messages, allowing users to steer the assistant to a specific queued message by aborting the current generation and promoting the message to the head of the queue.",
+      "defaultEnabled": false
+    },
+    {
+      "id": "chat-pull-to-refresh-enabled",
+      "scope": "client",
+      "key": "chat-pull-to-refresh-enabled",
+      "label": "Chat Pull to Refresh",
+      "description": "Enable pull-to-refresh gesture in the chat view.",
+      "defaultEnabled": false
+    },
+    {
+      "id": "doctor",
+      "scope": "client",
+      "key": "doctor",
+      "label": "Doctor",
+      "description": "Enable the Doctor diagnostic tab in Debug settings.",
+      "defaultEnabled": false
+    },
+    {
+      "id": "home-page",
+      "scope": "client",
+      "key": "home-page",
+      "label": "Home Page",
+      "description": "Enable the Home page as the default landing view.",
+      "defaultEnabled": false
+    },
+    {
+      "id": "platform-notifications",
+      "scope": "client",
+      "key": "platform-notifications",
+      "label": "Platform Notifications",
+      "description": "Enable the Notifications tab in settings.",
+      "defaultEnabled": false
+    },
+    {
+      "id": "rollback-enabled",
+      "scope": "assistant",
+      "key": "rollback-enabled",
+      "label": "Rollback Enabled",
+      "description": "Show older versions in the version picker, allowing rollback to previous releases.",
+      "defaultEnabled": false
+    },
+    {
+      "id": "self-hosted-assistant",
+      "scope": "client",
+      "key": "self-hosted-assistant",
+      "label": "Self-Hosted Assistant",
+      "description": "Enable self-hosted assistant configuration.",
+      "defaultEnabled": false
+    },
+    {
+      "id": "settings-sleep-policy",
+      "scope": "assistant",
+      "key": "settings-sleep-policy",
+      "label": "Settings Sleep Policy",
+      "description": "Enable sleep policy settings.",
+      "defaultEnabled": false
+    },
+    {
+      "id": "velvet",
+      "scope": "client",
+      "key": "velvet",
+      "label": "Velvet",
+      "description": "Enable the Velvet design theme.",
+      "defaultEnabled": false
     }
   ]
 }

package/src/handlers/handle-inbound.ts

@@ -15,7 +15,6 @@ import type { RuntimeInboundResponse } from "../runtime/client.js";
 import type { GatewayInboundEvent } from "../types.js";
 import { tryTextVerificationIntercept } from "../verification/text-verification.js";
 
-
 const log = getLogger("handle-inbound");
 
 export type InboundResult = {
@@ -119,6 +118,7 @@ export async function handleInbound(
     options?.transportMetadata?.hints,
   );
   const transportUxBrief = options?.transportMetadata?.uxBrief?.trim();
+  const sourceChannelName = event.source.channelName?.trim();
 
   try {
     const response = await forwardToRuntime(
@@ -144,8 +144,12 @@ export async function handleInbound(
           messageId: event.source.messageId,
           chatType: event.source.chatType,
           ...(event.source.threadId ? { threadId: event.source.threadId } : {}),
+          ...(sourceChannelName ? { channelName: sourceChannelName } : {}),
           languageCode: event.actor.languageCode,
           isBot: event.actor.isBot,
+          timezone: event.actor.timezone,
+          timezoneLabel: event.actor.timezoneLabel,
+          timezoneOffsetSeconds: event.actor.timezoneOffsetSeconds,
           ...(transportHints.length > 0 ? { hints: transportHints } : {}),
           ...(transportUxBrief ? { uxBrief: transportUxBrief } : {}),
           ...(options?.sourceMetadata ?? {}),
@@ -176,9 +180,7 @@ export async function handleInbound(
     // writes to both assistant DB and gateway DB. Fire-and-forget so
     // IPC failures here cannot leak as unhandled rejections.
     if (!response.denied) {
-      void touchContactChannelStats(event, response.duplicate).catch(
-        () => {},
-      );
+      void touchContactChannelStats(event, response.duplicate).catch(() => {});
     }
 
     return { forwarded: true, rejected: false, runtimeResponse: response };

package/src/index.ts

@@ -176,6 +176,7 @@ import {
 import { GatewayIpcServer } from "./ipc/server.js";
 import { contactRoutes } from "./ipc/contact-handlers.js";
 import { featureFlagRoutes } from "./ipc/feature-flag-handlers.js";
+import { slackThreadRoutes } from "./ipc/slack-thread-handlers.js";
 import { thresholdRoutes } from "./ipc/threshold-handlers.js";
 
 import { riskClassificationRoutes } from "./ipc/risk-classification-handlers.js";
@@ -2205,6 +2206,7 @@ async function main() {
   const ipcServer = new GatewayIpcServer([
     ...featureFlagRoutes,
     ...contactRoutes,
+    ...slackThreadRoutes,
     ...thresholdRoutes,
     ...riskClassificationRoutes,
     ...createVelayRoutes(velayTunnelClient),

package/src/ipc/slack-thread-handlers.ts

@@ -0,0 +1,39 @@
+/**
+ * IPC route definitions for Slack active-thread listener control.
+ *
+ * The gateway owns Slack Socket Mode listener state, so assistant-side
+ * controls call here instead of writing gateway storage directly.
+ */
+
+import { z } from "zod";
+
+import { SlackStore } from "../db/slack-store.js";
+import type { IpcRoute } from "./server.js";
+
+let store: SlackStore | null = null;
+
+function getStore(): SlackStore {
+  if (!store) {
+    store = new SlackStore();
+  }
+  return store;
+}
+
+const DetachSlackActiveThreadParamsSchema = z.object({
+  channelId: z.string().trim().min(1),
+  threadTs: z.string().trim().min(1),
+});
+
+export const slackThreadRoutes: IpcRoute[] = [
+  {
+    method: "detach_slack_active_thread",
+    schema: DetachSlackActiveThreadParamsSchema,
+    handler: (params?: Record<string, unknown>) => {
+      const { channelId, threadTs } = DetachSlackActiveThreadParamsSchema.parse(
+        params ?? {},
+      );
+      const detached = getStore().detachThread(threadTs, channelId);
+      return { detached, channelId, threadTs };
+    },
+  },
+];

package/src/slack/normalize.ts

@@ -1,4 +1,5 @@
 import { renderSlackTextForModel } from "@vellumai/slack-text";
+import { createHash } from "node:crypto";
 import type { GatewayConfig } from "../config.js";
 import { fetchImpl } from "../fetch.js";
 import { resolveAssistant, isRejection } from "../routing/resolve-assistant.js";
@@ -11,8 +12,20 @@ import type { GatewayInboundEvent } from "../types.js";
 interface SlackUserInfo {
   displayName: string;
   username: string;
+  timezone?: string;
+  timezoneLabel?: string;
+  timezoneOffsetSeconds?: number;
 }
 
+export type SlackUserActorFields = Pick<
+  SlackUserInfo,
+  | "displayName"
+  | "username"
+  | "timezone"
+  | "timezoneLabel"
+  | "timezoneOffsetSeconds"
+>;
+
 interface SlackChannelInfo {
   name: string;
 }
@@ -48,6 +61,16 @@ const inFlightChannelFetches = new Map<
   Promise<SlackChannelInfo | undefined>
 >();
 
+function slackUserCacheKey(userId: string, botToken: string): string {
+  const authScope = createHash("sha256").update(botToken).digest("hex");
+  return `${authScope}:${userId}`;
+}
+
+function slackChannelCacheKey(channelId: string, botToken: string): string {
+  const authScope = createHash("sha256").update(botToken).digest("hex");
+  return `${authScope}:${channelId}`;
+}
+
 function evictExpired<T>(cache: Map<string, CacheEntry<T>>): void {
   const now = Date.now();
   for (const [key, entry] of cache) {
@@ -106,11 +129,12 @@ export async function resolveSlackUser(
   userId: string,
   botToken: string,
 ): Promise<SlackUserInfo | undefined> {
-  const cached = cacheGet(userInfoCache, userId);
+  const cacheKey = slackUserCacheKey(userId, botToken);
+  const cached = cacheGet(userInfoCache, cacheKey);
   if (cached) return cached;
 
   // If another caller is already fetching this user, reuse that promise
-  const existing = inFlightUserFetches.get(userId);
+  const existing = inFlightUserFetches.get(cacheKey);
   if (existing) return existing;
 
   const fetchPromise = (async (): Promise<SlackUserInfo | undefined> => {
@@ -129,6 +153,9 @@ export async function resolveSlackUser(
         user?: {
           name?: string;
           real_name?: string;
+          tz?: string;
+          tz_label?: string;
+          tz_offset?: number;
           profile?: { display_name?: string; real_name?: string };
         };
       };
@@ -141,11 +168,27 @@ export async function resolveSlackUser(
         data.user.name ||
         userId;
       const username = data.user.name || userId;
-
-      const info: SlackUserInfo = { displayName, username };
+      const timezone =
+        typeof data.user.tz === "string" ? data.user.tz : undefined;
+      const timezoneLabel =
+        typeof data.user.tz_label === "string" ? data.user.tz_label : undefined;
+      const timezoneOffsetSeconds =
+        typeof data.user.tz_offset === "number"
+          ? data.user.tz_offset
+          : undefined;
+
+      const info: SlackUserInfo = {
+        displayName,
+        username,
+        ...(timezone !== undefined ? { timezone } : {}),
+        ...(timezoneLabel !== undefined ? { timezoneLabel } : {}),
+        ...(timezoneOffsetSeconds !== undefined
+          ? { timezoneOffsetSeconds }
+          : {}),
+      };
       cacheSet(
         userInfoCache,
-        userId,
+        cacheKey,
         info,
         USER_CACHE_TTL_MS,
         USER_CACHE_MAX_SIZE,
@@ -156,11 +199,11 @@ export async function resolveSlackUser(
     }
   })();
 
-  inFlightUserFetches.set(userId, fetchPromise);
+  inFlightUserFetches.set(cacheKey, fetchPromise);
   try {
     return await fetchPromise;
   } finally {
-    inFlightUserFetches.delete(userId);
+    inFlightUserFetches.delete(cacheKey);
   }
 }
 
@@ -175,10 +218,11 @@ export async function resolveSlackChannel(
   channelId: string,
   botToken: string,
 ): Promise<SlackChannelInfo | undefined> {
-  const cached = cacheGet(channelInfoCache, channelId);
+  const cacheKey = slackChannelCacheKey(channelId, botToken);
+  const cached = cacheGet(channelInfoCache, cacheKey);
   if (cached) return cached;
 
-  const existing = inFlightChannelFetches.get(channelId);
+  const existing = inFlightChannelFetches.get(cacheKey);
   if (existing) return existing;
 
   const fetchPromise = (async (): Promise<SlackChannelInfo | undefined> => {
@@ -207,7 +251,7 @@ export async function resolveSlackChannel(
       const info: SlackChannelInfo = { name };
       cacheSet(
         channelInfoCache,
-        channelId,
+        cacheKey,
         info,
         CHANNEL_CACHE_TTL_MS,
         CHANNEL_CACHE_MAX_SIZE,
@@ -218,11 +262,11 @@ export async function resolveSlackChannel(
     }
   })();
 
-  inFlightChannelFetches.set(channelId, fetchPromise);
+  inFlightChannelFetches.set(cacheKey, fetchPromise);
   try {
     return await fetchPromise;
   } finally {
-    inFlightChannelFetches.delete(channelId);
+    inFlightChannelFetches.delete(cacheKey);
   }
 }
 
@@ -235,8 +279,9 @@ export function resolveSlackUserSync(
   userId: string,
   botToken: string,
 ): SlackUserInfo | undefined {
-  const cached = cacheGet(userInfoCache, userId);
-  if (!cached && !inFlightUserFetches.has(userId)) {
+  const cacheKey = slackUserCacheKey(userId, botToken);
+  const cached = cacheGet(userInfoCache, cacheKey);
+  if (!cached && !inFlightUserFetches.has(cacheKey)) {
     // Fire-and-forget: warm the cache for next time
     resolveSlackUser(userId, botToken).catch(() => {});
   }
@@ -395,6 +440,22 @@ function renderSlackInboundText(
   });
 }
 
+export function slackUserActorFields(
+  userInfo: SlackUserInfo,
+): SlackUserActorFields {
+  return {
+    displayName: userInfo.displayName,
+    username: userInfo.username,
+    ...(userInfo.timezone !== undefined ? { timezone: userInfo.timezone } : {}),
+    ...(userInfo.timezoneLabel !== undefined
+      ? { timezoneLabel: userInfo.timezoneLabel }
+      : {}),
+    ...(userInfo.timezoneOffsetSeconds !== undefined
+      ? { timezoneOffsetSeconds: userInfo.timezoneOffsetSeconds }
+      : {}),
+  };
+}
+
 function extractSlackAttachments(files: SlackFile[] | undefined): Array<{
   type: "image" | "document";
   fileId: string;
@@ -505,10 +566,7 @@ export function normalizeSlackDirectMessage(
       },
       actor: {
         actorExternalId: event.user,
-        ...(userInfo && {
-          displayName: userInfo.displayName,
-          username: userInfo.username,
-        }),
+        ...(userInfo ? slackUserActorFields(userInfo) : {}),
       },
       source: {
         updateId: eventId,
@@ -573,10 +631,7 @@ export function normalizeSlackChannelMessage(
       },
       actor: {
         actorExternalId: event.user,
-        ...(userInfo && {
-          displayName: userInfo.displayName,
-          username: userInfo.username,
-        }),
+        ...(userInfo ? slackUserActorFields(userInfo) : {}),
       },
       source: {
         updateId: eventId,
@@ -638,10 +693,7 @@ export function normalizeSlackAppMention(
       },
       actor: {
         actorExternalId: event.user,
-        ...(userInfo && {
-          displayName: userInfo.displayName,
-          username: userInfo.username,
-        }),
+        ...(userInfo ? slackUserActorFields(userInfo) : {}),
       },
       source: {
         updateId: eventId,

package/src/slack/socket-mode.ts

@@ -25,6 +25,7 @@ import {
   normalizeSlackReactionRemoved,
   resolveSlackChannel,
   resolveSlackUser,
+  slackUserActorFields,
   type SlackAppMentionEvent,
   type SlackDirectMessageEvent,
   type SlackChannelMessageEvent,
@@ -1018,8 +1019,7 @@ export class SlackSocketModeClient {
         ),
       ]);
       if (userInfo) {
-        actor.displayName = userInfo.displayName;
-        actor.username = userInfo.username;
+        Object.assign(actor, slackUserActorFields(userInfo));
       }
     }