@vellumai/assistant 0.8.3 → 0.8.5

package/src/__tests__/openai-provider.test.ts

@@ -56,6 +56,7 @@ let lastCreateParams: Record<string, unknown> | null = null;
 let lastCreateOptions: Record<string, unknown> | null = null;
 let lastConstructorOptions: Record<string, unknown> | null = null;
 let shouldThrow: Error | null = null;
+const DEFAULT_SDK_TIMEOUT_MS = 1_860_000;
 
 function userMsg(text: string): Message {
   return { role: "user", content: [{ type: "text", text }] };
@@ -102,6 +103,7 @@ mock.module("openai", () => ({
 
 // Import after mocking
 import { FireworksProvider } from "../providers/fireworks/client.js";
+import { MinimaxProvider } from "../providers/minimax/client.js";
 import { OllamaProvider } from "../providers/ollama/client.js";
 import { OpenAIChatCompletionsProvider } from "../providers/openai/chat-completions-provider.js";
 import { OpenAIProvider } from "../providers/openai/client.js";
@@ -307,6 +309,7 @@ describe("OpenAIProvider", () => {
     expect(lastConstructorOptions).toEqual({
       apiKey: "sk-local",
       baseURL: "http://127.0.0.1:11434/v1",
+      timeout: DEFAULT_SDK_TIMEOUT_MS,
     });
   });
 
@@ -319,6 +322,7 @@ describe("OpenAIProvider", () => {
       expect(lastConstructorOptions).toEqual({
         apiKey: "ollama",
         baseURL: "http://127.0.0.1:11434/v1",
+        timeout: DEFAULT_SDK_TIMEOUT_MS,
       });
     } finally {
       if (previousBaseUrl !== undefined) {
@@ -338,6 +342,7 @@ describe("OpenAIProvider", () => {
       expect(lastConstructorOptions).toEqual({
         apiKey: "ollama",
         baseURL: "http://127.0.0.1:11434/v1",
+        timeout: DEFAULT_SDK_TIMEOUT_MS,
       });
     } finally {
       if (previousBaseUrl !== undefined) {
@@ -1280,6 +1285,7 @@ describe("custom baseURL initialization", () => {
     expect(lastConstructorOptions).toEqual({
       apiKey: "ast-key-123",
       baseURL: "https://platform.example.com/v1/runtime-proxy/openai",
+      timeout: DEFAULT_SDK_TIMEOUT_MS,
     });
   });
 
@@ -1289,6 +1295,19 @@ describe("custom baseURL initialization", () => {
     expect(lastConstructorOptions).toEqual({
       apiKey: "sk-user-key",
       baseURL: undefined,
+      timeout: DEFAULT_SDK_TIMEOUT_MS,
+    });
+  });
+
+  test("OpenAIProvider passes configured stream timeout plus buffer to SDK", () => {
+    new OpenAIProvider("sk-user-key", "gpt-4o", {
+      streamTimeoutMs: 300_000,
+    });
+
+    expect(lastConstructorOptions).toEqual({
+      apiKey: "sk-user-key",
+      baseURL: undefined,
+      timeout: 360_000,
     });
   });
 
@@ -1305,6 +1324,7 @@ describe("custom baseURL initialization", () => {
     expect(lastConstructorOptions).toEqual({
       apiKey: "ast-key-123",
       baseURL: "https://platform.example.com/v1/runtime-proxy/fireworks",
+      timeout: DEFAULT_SDK_TIMEOUT_MS,
     });
   });
 
@@ -1317,6 +1337,7 @@ describe("custom baseURL initialization", () => {
     expect(lastConstructorOptions).toEqual({
       apiKey: "fw-user-key",
       baseURL: "https://api.fireworks.ai/inference/v1",
+      timeout: DEFAULT_SDK_TIMEOUT_MS,
     });
   });
 
@@ -1329,6 +1350,7 @@ describe("custom baseURL initialization", () => {
     expect(lastConstructorOptions).toEqual({
       apiKey: "ast-key-123",
       baseURL: "https://platform.example.com/v1/runtime-proxy/openrouter",
+      timeout: DEFAULT_SDK_TIMEOUT_MS,
     });
   });
 
@@ -1338,6 +1360,30 @@ describe("custom baseURL initialization", () => {
     expect(lastConstructorOptions).toEqual({
       apiKey: "or-user-key",
       baseURL: "https://openrouter.ai/api/v1",
+      timeout: DEFAULT_SDK_TIMEOUT_MS,
+    });
+  });
+
+  test("MinimaxProvider forwards a custom baseURL", () => {
+    const managed = new MinimaxProvider("ast-key-123", "MiniMax-M2.7", {
+      baseURL: "https://platform.example.com/v1/runtime-proxy/minimax",
+    });
+
+    expect(managed.name).toBe("minimax");
+    expect(lastConstructorOptions).toEqual({
+      apiKey: "ast-key-123",
+      baseURL: "https://platform.example.com/v1/runtime-proxy/minimax",
+      timeout: DEFAULT_SDK_TIMEOUT_MS,
+    });
+  });
+
+  test("MinimaxProvider without custom baseURL uses default MiniMax URL", () => {
+    new MinimaxProvider("mm-user-key", "MiniMax-M2.7");
+
+    expect(lastConstructorOptions).toEqual({
+      apiKey: "mm-user-key",
+      baseURL: "https://api.minimax.io/v1",
+      timeout: DEFAULT_SDK_TIMEOUT_MS,
     });
   });
 });
@@ -1744,4 +1790,109 @@ describe("OpenAIProvider reasoning_effort", () => {
     });
     expect(lastCreateParams!.reasoning_effort).toBe("medium");
   });
+
+  test('maxReasoningEffort: "max" passes "max" through unclamped', async () => {
+    const uncapped = new OpenAIProvider("test-key", "gpt-5", {
+      maxReasoningEffort: "max",
+    });
+    await uncapped.sendMessage([userMsg("hi")], undefined, "system", {
+      config: { effort: "max" },
+    });
+    expect(lastCreateParams!.reasoning_effort).toBe("max");
+    await uncapped.sendMessage([userMsg("hi")], undefined, "system", {
+      config: { effort: "xhigh" },
+    });
+    expect(lastCreateParams!.reasoning_effort).toBe("xhigh");
+  });
+});
+
+describe("FireworksProvider reasoning_effort ceiling", () => {
+  beforeEach(() => {
+    fakeChunks = [];
+    lastCreateParams = null;
+  });
+
+  test('DeepSeek V4 Pro accepts "max" unclamped', async () => {
+    const fw = new FireworksProvider(
+      "fw-key",
+      "accounts/fireworks/models/deepseek-v4-pro",
+    );
+    await fw.sendMessage([userMsg("hi")], undefined, "system", {
+      config: { effort: "max" },
+    });
+    expect(lastCreateParams!.reasoning_effort).toBe("max");
+  });
+
+  test('DeepSeek V4 Pro accepts "xhigh" unclamped', async () => {
+    const fw = new FireworksProvider(
+      "fw-key",
+      "accounts/fireworks/models/deepseek-v4-pro",
+    );
+    await fw.sendMessage([userMsg("hi")], undefined, "system", {
+      config: { effort: "xhigh" },
+    });
+    expect(lastCreateParams!.reasoning_effort).toBe("xhigh");
+  });
+
+  test('Kimi K2.6 clamps "xhigh"/"max" down to "high"', async () => {
+    const fw = new FireworksProvider(
+      "fw-key",
+      "accounts/fireworks/models/kimi-k2p6",
+    );
+    await fw.sendMessage([userMsg("hi")], undefined, "system", {
+      config: { effort: "xhigh" },
+    });
+    expect(lastCreateParams!.reasoning_effort).toBe("high");
+    await fw.sendMessage([userMsg("hi")], undefined, "system", {
+      config: { effort: "max" },
+    });
+    expect(lastCreateParams!.reasoning_effort).toBe("high");
+  });
+
+  test('unknown Fireworks model falls back to "high" ceiling', async () => {
+    const fw = new FireworksProvider(
+      "fw-key",
+      "accounts/fireworks/models/some-future-model",
+    );
+    await fw.sendMessage([userMsg("hi")], undefined, "system", {
+      config: { effort: "max" },
+    });
+    expect(lastCreateParams!.reasoning_effort).toBe("high");
+  });
+
+  test("effort below ceiling is forwarded verbatim", async () => {
+    const fw = new FireworksProvider(
+      "fw-key",
+      "accounts/fireworks/models/deepseek-v4-pro",
+    );
+    await fw.sendMessage([userMsg("hi")], undefined, "system", {
+      config: { effort: "medium" },
+    });
+    expect(lastCreateParams!.reasoning_effort).toBe("medium");
+  });
+
+  test('effort: "none" passes through regardless of ceiling', async () => {
+    const fw = new FireworksProvider(
+      "fw-key",
+      "accounts/fireworks/models/kimi-k2p6",
+    );
+    await fw.sendMessage([userMsg("hi")], undefined, "system", {
+      config: { effort: "none" },
+    });
+    expect(lastCreateParams!.reasoning_effort).toBe("none");
+  });
+
+  test("model override picks ceiling from runtime model, not constructor model", async () => {
+    const fw = new FireworksProvider(
+      "fw-key",
+      "accounts/fireworks/models/kimi-k2p6",
+    );
+    await fw.sendMessage([userMsg("hi")], undefined, "system", {
+      config: {
+        effort: "max",
+        model: "accounts/fireworks/models/deepseek-v4-pro",
+      },
+    });
+    expect(lastCreateParams!.reasoning_effort).toBe("max");
+  });
 });

package/src/__tests__/openai-responses-provider.test.ts

@@ -22,6 +22,7 @@ let lastStreamParams: Record<string, unknown> | null = null;
 let lastStreamOptions: Record<string, unknown> | null = null;
 let lastConstructorOptions: Record<string, unknown> | null = null;
 let shouldThrow: Error | null = null;
+const DEFAULT_SDK_TIMEOUT_MS = 1_860_000;
 
 // Simulate OpenAI.APIError
 class FakeAPIError extends Error {
@@ -200,6 +201,19 @@ describe("OpenAIResponsesProvider", () => {
     expect(lastConstructorOptions).toEqual({
       apiKey: "sk-custom",
       baseURL: "https://proxy.example.com/v1",
+      timeout: DEFAULT_SDK_TIMEOUT_MS,
+    });
+  });
+
+  test("passes configured stream timeout plus buffer to OpenAI client", () => {
+    new OpenAIResponsesProvider("sk-custom", "gpt-5.4", {
+      streamTimeoutMs: 300_000,
+    });
+
+    expect(lastConstructorOptions).toEqual({
+      apiKey: "sk-custom",
+      baseURL: undefined,
+      timeout: 360_000,
     });
   });
 
@@ -273,18 +287,6 @@ describe("OpenAIResponsesProvider", () => {
     }
   });
 
-  test("strips SYSTEM_PROMPT_CACHE_BOUNDARY from system prompt", async () => {
-    fakeStreamEvents = [textDeltaEvent("OK"), completedEvent(10, 2)];
-
-    await provider.sendMessage(
-      [{ role: "user", content: [{ type: "text", text: "Hi" }] }],
-      undefined,
-      "Before\n<!-- SYSTEM_PROMPT_CACHE_BOUNDARY -->\nAfter",
-    );
-
-    expect(lastStreamParams!.instructions).toBe("Before\nAfter");
-  });
-
   // -----------------------------------------------------------------------
   // Tool definitions
   // -----------------------------------------------------------------------
@@ -714,16 +716,16 @@ describe("OpenAIResponsesProvider", () => {
   });
 
   // -----------------------------------------------------------------------
-  // store: false
+  // store — omitted so prompt caching can persist across turns
   // -----------------------------------------------------------------------
-  test("sends store: false in params", async () => {
+  test("does not set store in params (defaults to true server-side)", async () => {
     fakeStreamEvents = [textDeltaEvent("OK"), completedEvent(10, 2)];
 
     await provider.sendMessage([
       { role: "user", content: [{ type: "text", text: "Hi" }] },
     ]);
 
-    expect(lastStreamParams!.store).toBe(false);
+    expect(lastStreamParams!.store).toBeUndefined();
   });
 
   // -----------------------------------------------------------------------
@@ -1122,7 +1124,7 @@ describe("OpenAIResponsesProvider", () => {
     const rawReq = result.rawRequest as Record<string, unknown>;
     expect(rawReq.model).toBe("gpt-5.2");
     expect(rawReq.instructions).toBe("System prompt");
-    expect(rawReq.store).toBe(false);
+    expect(rawReq.store).toBeUndefined();
 
     // rawResponse should contain the final response object, including `output`
     // which downstream normalization relies on for Responses API detection.
@@ -1657,4 +1659,104 @@ describe("OpenAIResponsesProvider — Native Web Search", () => {
       text: "No search needed.",
     });
   });
+
+  // -----------------------------------------------------------------------
+  // codexSubscription — parameter stripping
+  // -----------------------------------------------------------------------
+  test("codexSubscription: strips max_output_tokens from params", async () => {
+    const codexProvider = new OpenAIResponsesProvider("sk-test", "gpt-5.4", {
+      codexSubscription: true,
+    });
+    fakeStreamEvents = [textDeltaEvent("OK"), completedEvent(10, 2)];
+
+    await codexProvider.sendMessage(
+      [{ role: "user", content: [{ type: "text", text: "Hi" }] }],
+      undefined,
+      undefined,
+      { config: { max_tokens: 64000 } },
+    );
+
+    expect(lastStreamParams!.max_output_tokens).toBeUndefined();
+  });
+
+  test("codexSubscription: strips reasoning param even when effort is set", async () => {
+    const codexProvider = new OpenAIResponsesProvider("sk-test", "gpt-5.4", {
+      codexSubscription: true,
+    });
+    fakeStreamEvents = [textDeltaEvent("OK"), completedEvent(10, 2)];
+
+    await codexProvider.sendMessage(
+      [{ role: "user", content: [{ type: "text", text: "Hi" }] }],
+      undefined,
+      undefined,
+      { config: { effort: "high" } },
+    );
+
+    expect(lastStreamParams!.reasoning).toBeUndefined();
+  });
+
+  test("codexSubscription: strips text.verbosity param", async () => {
+    const codexProvider = new OpenAIResponsesProvider("sk-test", "gpt-5.4", {
+      codexSubscription: true,
+    });
+    fakeStreamEvents = [textDeltaEvent("OK"), completedEvent(10, 2)];
+
+    await codexProvider.sendMessage(
+      [{ role: "user", content: [{ type: "text", text: "Hi" }] }],
+      undefined,
+      undefined,
+      { config: { verbosity: "low" } },
+    );
+
+    expect(lastStreamParams!.text).toBeUndefined();
+  });
+
+  test("codexSubscription: uses Codex baseURL", async () => {
+    new OpenAIResponsesProvider("sk-test", "gpt-5.4", {
+      codexSubscription: true,
+    });
+
+    expect(lastConstructorOptions!.baseURL).toBe(
+      "https://chatgpt.com/backend-api/codex",
+    );
+  });
+
+  test("codexSubscription: strips tools param", async () => {
+    const codexProvider = new OpenAIResponsesProvider("sk-test", "gpt-5.4", {
+      codexSubscription: true,
+    });
+    fakeStreamEvents = [textDeltaEvent("OK"), completedEvent(10, 2)];
+
+    const sampleTool: ToolDefinition = {
+      name: "test_tool",
+      description: "A test tool",
+      input_schema: { type: "object", properties: {} },
+    };
+    await codexProvider.sendMessage(
+      [{ role: "user", content: [{ type: "text", text: "Hi" }] }],
+      [sampleTool],
+    );
+
+    expect(lastStreamParams!.tools).toBeUndefined();
+  });
+
+  test("codexSubscription: still sends model, input, and instructions", async () => {
+    const codexProvider = new OpenAIResponsesProvider("sk-test", "gpt-5.4", {
+      codexSubscription: true,
+    });
+    fakeStreamEvents = [textDeltaEvent("OK"), completedEvent(10, 2)];
+
+    await codexProvider.sendMessage(
+      [{ role: "user", content: [{ type: "text", text: "Hi" }] }],
+      undefined,
+      "You are helpful.",
+      { config: { effort: "max", verbosity: "high", max_tokens: 64000 } },
+    );
+
+    expect(lastStreamParams!.model).toBe("gpt-5.4");
+    expect(lastStreamParams!.instructions).toBe("You are helpful.");
+    expect(lastStreamParams!.max_output_tokens).toBeUndefined();
+    expect(lastStreamParams!.reasoning).toBeUndefined();
+    expect(lastStreamParams!.text).toBeUndefined();
+  });
 });

package/src/__tests__/outbound-slack-persistence.test.ts

@@ -22,24 +22,33 @@ mock.module("../util/logger.js", () => ({
     }),
 }));
 
-mock.module("../config/loader.js", () => ({
-  getConfig: () => ({
-    skills: {
-      entries: {},
-      load: { extraDirs: [], watch: true, watchDebounceMs: 250 },
-      install: { nodeManager: "npm" },
-      allowBundled: null,
-      remoteProviders: {
-        skillssh: { enabled: true },
-        clawhub: { enabled: true },
-      },
-      remotePolicy: {
-        blockSuspicious: true,
-        blockMalware: true,
-        maxSkillsShRisk: "medium",
-      },
+type TestConfig = {
+  ui: { userTimezone?: string; detectedTimezone?: string };
+  skills: Record<string, unknown>;
+};
+
+const baseConfig: TestConfig = {
+  ui: {},
+  skills: {
+    entries: {},
+    load: { extraDirs: [], watch: true, watchDebounceMs: 250 },
+    install: { nodeManager: "npm" },
+    allowBundled: null,
+    remoteProviders: {
+      skillssh: { enabled: true },
+      clawhub: { enabled: true },
     },
-  }),
+    remotePolicy: {
+      blockSuspicious: true,
+      blockMalware: true,
+      maxSkillsShRisk: "medium",
+    },
+  },
+};
+let currentConfig: TestConfig = structuredClone(baseConfig);
+
+mock.module("../config/loader.js", () => ({
+  getConfig: () => currentConfig,
   loadConfig: () => ({}),
 }));
 
@@ -47,12 +56,21 @@ mock.module("../config/loader.js", () => ({
 // its arguments per test invocation so each case can assert on the metadata
 // that was actually persisted.
 interface AddMessageCall {
+  id: string;
   conversationId: string;
   role: string;
   content: string;
   metadata?: Record<string, unknown>;
 }
 const addMessageCalls: AddMessageCall[] = [];
+const persistedRows: Array<{
+  id: string;
+  conversationId: string;
+  role: string;
+  content: string;
+  createdAt: number;
+  metadata: string | null;
+}> = [];
 mock.module("../memory/conversation-crud.js", () => ({
   addMessage: (
     conversationId: string,
@@ -60,11 +78,35 @@ mock.module("../memory/conversation-crud.js", () => ({
     content: string,
     metadata?: Record<string, unknown>,
   ) => {
-    addMessageCalls.push({ conversationId, role, content, metadata });
-    return { id: `mock-msg-${addMessageCalls.length}` };
+    const id = `mock-msg-${addMessageCalls.length + 1}`;
+    addMessageCalls.push({ id, conversationId, role, content, metadata });
+    persistedRows.push({
+      id,
+      conversationId,
+      role,
+      content,
+      createdAt: Date.now(),
+      metadata: metadata ? JSON.stringify(metadata) : null,
+    });
+    return { id };
   },
   getConversation: () => null,
-  getMessageById: () => null,
+  getMessageById: (messageId: string) =>
+    persistedRows.find((row) => row.id === messageId) ?? null,
+  getMessages: (conversationId: string) =>
+    persistedRows.filter((row) => row.conversationId === conversationId),
+  updateMessageMetadata: (
+    messageId: string,
+    updates: Record<string, unknown>,
+  ) => {
+    const row = persistedRows.find((candidate) => candidate.id === messageId);
+    if (!row) return;
+    const existing =
+      row.metadata && typeof row.metadata === "string"
+        ? (JSON.parse(row.metadata) as Record<string, unknown>)
+        : {};
+    row.metadata = JSON.stringify({ ...existing, ...updates });
+  },
   updateMessageContent: () => {},
   // The handler treats provenance as a flat spread; returning {} keeps the
   // metadata snapshot focused on the fields under test.
@@ -84,6 +126,18 @@ mock.module("../memory/conversation-disk-view.js", () => ({
   syncMessageToDisk: () => {},
 }));
 
+let nextDeliveryTs: string | null = null;
+mock.module("../runtime/gateway-client.js", () => ({
+  deliverChannelReply: async () => ({
+    ok: true,
+    ...(nextDeliveryTs ? { ts: nextDeliveryTs } : {}),
+  }),
+}));
+
+mock.module("../memory/attachments-store.js", () => ({
+  getAttachmentMetadataForMessage: () => [],
+}));
+
 // ── Imports (after mocks) ──────────────────────────────────────────────────
 
 import type { AgentEvent } from "../agent/loop.js";
@@ -98,6 +152,7 @@ import {
 import type { ServerMessage } from "../daemon/message-protocol.js";
 import { clearThreadTs, setThreadTs } from "../memory/slack-thread-store.js";
 import { readSlackMetadata } from "../messaging/providers/slack/message-metadata.js";
+import { deliverReplyViaCallback } from "../runtime/channel-reply-delivery.js";
 
 // ── Helpers ────────────────────────────────────────────────────────────────
 
@@ -106,6 +161,8 @@ function makeDeps(
   overrides: {
     assistantMessageChannel?: "slack" | "vellum" | "telegram";
     requesterChatId?: string;
+    requesterTimezoneLabel?: string;
+    clientTimezone?: string;
   } = {},
 ): EventHandlerDeps {
   const assistantMessageChannel = overrides.assistantMessageChannel ?? "slack";
@@ -119,7 +176,9 @@ function makeDeps(
         sourceChannel: assistantMessageChannel,
         trustClass: "guardian",
         requesterChatId: overrides.requesterChatId,
+        requesterTimezoneLabel: overrides.requesterTimezoneLabel,
       },
+      clientTimezone: overrides.clientTimezone,
     } as unknown as EventHandlerDeps["ctx"],
     onEvent: (_msg: ServerMessage) => {},
     reqId: "test-req-id",
@@ -172,12 +231,17 @@ describe("outbound assistant Slack metadata persistence", () => {
 
   beforeEach(() => {
     addMessageCalls.length = 0;
+    persistedRows.length = 0;
+    currentConfig = structuredClone(baseConfig);
+    nextDeliveryTs = null;
     state = createEventHandlerState();
     state.turnStartedAt = 1_700_000_000_000;
   });
 
   afterEach(() => {
     addMessageCalls.length = 0;
+    persistedRows.length = 0;
+    nextDeliveryTs = null;
   });
 
   test("stamps slackMeta with threadTs when the conversation has a Slack thread mapping", async () => {
@@ -217,6 +281,109 @@ describe("outbound assistant Slack metadata persistence", () => {
     expect(readSlackMetadata(slackMetaRaw as string)).toBeNull();
   });
 
+  test("stamps assistant Slack rows with effective timestamp timezone and no speaker suffix", async () => {
+    currentConfig = {
+      ...structuredClone(baseConfig),
+      ui: { userTimezone: "America/Denver" },
+    };
+    state.turnStartedAt = Date.parse("2026-03-05T03:38:00Z");
+    const conversationId = "conv-slack-timezone";
+    const channelId = "C999TIMEZONE";
+
+    const deps = makeDeps(conversationId, {
+      assistantMessageChannel: "slack",
+      requesterChatId: channelId,
+      requesterTimezoneLabel: "ET",
+      clientTimezone: "America/Los_Angeles",
+    });
+    await handleMessageComplete(
+      state,
+      deps,
+      makeMessageCompleteEvent("timezone-aware reply"),
+    );
+
+    const persisted = lastAssistantPersisted();
+    const slackMetaRaw = persisted.metadata?.slackMeta;
+    expect(typeof slackMetaRaw).toBe("string");
+
+    const slackMeta = JSON.parse(slackMetaRaw as string) as Record<
+      string,
+      unknown
+    >;
+    expect(slackMeta.timestampTimezone).toBe("America/Denver");
+    expect(slackMeta.timestampTimezoneLabel).toBe("MT");
+    expect(slackMeta.speakerTimezoneLabel).toBeUndefined();
+  });
+
+  test("falls back to the turn client timezone when no configured user timezone is set", async () => {
+    const conversationId = "conv-slack-client-timezone";
+    const channelId = "C999CLIENTTZ";
+
+    const deps = makeDeps(conversationId, {
+      assistantMessageChannel: "slack",
+      requesterChatId: channelId,
+      clientTimezone: "America/Los_Angeles",
+    });
+    await handleMessageComplete(
+      state,
+      deps,
+      makeMessageCompleteEvent("client timezone reply"),
+    );
+
+    const persisted = lastAssistantPersisted();
+    const slackMeta = JSON.parse(
+      persisted.metadata?.slackMeta as string,
+    ) as Record<string, unknown>;
+    expect(slackMeta.timestampTimezone).toBe("America/Los_Angeles");
+    expect(slackMeta.timestampTimezoneLabel).toBe("PT");
+  });
+
+  test("post-send reconciliation preserves assistant Slack timezone metadata", async () => {
+    currentConfig = {
+      ...structuredClone(baseConfig),
+      ui: { userTimezone: "America/Denver" },
+    };
+    const conversationId = "conv-slack-reconcile-timezone";
+    const channelId = "C999RECONCILE";
+
+    const deps = makeDeps(conversationId, {
+      assistantMessageChannel: "slack",
+      requesterChatId: channelId,
+      requesterTimezoneLabel: "ET",
+    });
+    await handleMessageComplete(
+      state,
+      deps,
+      makeMessageCompleteEvent("delivery reconciliation reply"),
+    );
+
+    const persisted = lastAssistantPersisted();
+    const beforeRaw = persisted.metadata?.slackMeta;
+    expect(typeof beforeRaw).toBe("string");
+    expect(readSlackMetadata(beforeRaw as string)).toBeNull();
+
+    nextDeliveryTs = "1772678280.000200";
+    await deliverReplyViaCallback(
+      conversationId,
+      channelId,
+      "http://gateway/deliver/slack",
+      "assistant-1",
+      { messageId: persisted.id },
+    );
+
+    const row = persistedRows.find(
+      (candidate) => candidate.id === persisted.id,
+    );
+    expect(typeof row?.metadata).toBe("string");
+    const envelope = JSON.parse(row!.metadata!) as Record<string, unknown>;
+    const reconciled = readSlackMetadata(envelope.slackMeta as string);
+    expect(reconciled).not.toBeNull();
+    expect(reconciled!.channelTs).toBe("1772678280.000200");
+    expect(reconciled!.timestampTimezone).toBe("America/Denver");
+    expect(reconciled!.timestampTimezoneLabel).toBe("MT");
+    expect(reconciled!.speakerTimezoneLabel).toBeUndefined();
+  });
+
   test("stamps slackMeta WITHOUT threadTs for top-level Slack replies", async () => {
     const conversationId = "conv-slack-toplevel";
     const channelId = "C456NOTHREAD";