@vellumai/assistant 0.8.3 → 0.8.4

package/src/messaging/providers/slack/render-transcript.ts

@@ -1,10 +1,10 @@
 /**
- * Pure chronological thread-tag rendering for Slack transcripts.
+ * Pure chronological transcript rendering for Slack transcripts.
  *
  * Given a list of stored messages (post-upgrade rows with structured metadata
  * AND legacy pre-upgrade rows with `metadata === null`), produces a flat
- * `{role, content}[]` chronologically ordered with compact thread tags so
- * the model can reason across sibling threads in one channel.
+ * `{role, content}[]` chronologically ordered with compact Slack tags so the
+ * model can reason across sibling threads in one channel.
  *
  * The function is pure: no I/O, no implicit clock reads. Time is taken from
  * `opts.now` only when needed for relative formatting. Sort and tag rendering
@@ -21,7 +21,10 @@ import {
   parseExternalContentEnvelope,
   wrapUntrustedContent,
 } from "../../../security/untrusted-content.js";
-import type { SlackMessageMetadata } from "./message-metadata.js";
+import {
+  formatSlackTimezoneLabel,
+  type SlackMessageMetadata,
+} from "./message-metadata.js";
 
 export interface RenderableSlackMessage {
   role: "user" | "assistant";
@@ -78,8 +81,15 @@ export interface RenderedSlackTranscript {
 export interface RenderedSlackTranscriptMessage {
   readonly message: Message;
   readonly sourceChannelTs: string | null;
+  /** How the first rendered text line got its Slack attribution, if any. */
+  readonly tagLineProvenance: RenderedSlackTranscriptTagLineProvenance;
 }
 
+export type RenderedSlackTranscriptTagLineProvenance =
+  | "none"
+  | "slack-reaction"
+  | "slack-timezone-message";
+
 /**
  * Replayable Anthropic content-block types that we preserve verbatim from a
  * persisted row when rendering the Slack chronological transcript.
@@ -117,31 +127,6 @@ export function parentAlias(channelTs: string): string {
   return `M${hash.slice(0, 6)}`;
 }
 
-/**
- * Trailing signature of a reaction or reaction-overflow line, both of
- * which end with a `parentAlias` target and a closing bracket:
- * `[... reacted 👍 to M1a2b3c]`, `[... removed 👍 from M1a2b3c]`,
- * `[…and N more reactions to M1a2b3c]`. Regular message tag lines end
- * with the message body, not with `]`, so they never match.
- */
-const REACTION_TAG_LINE_SUFFIX = /M[0-9a-f]{6}\]$/;
-
-/**
- * Whether a rendered tag-line string was produced by the reaction or
- * reaction-overflow code paths (`renderReaction` / the overflow trailer).
- *
- * Reaction lines already embed the actor attribution inline
- * (`[11/14/23 14:28 @assistant reacted 👍 to M1a2b3c]`), so consumers
- * that flatten the rendered transcript and re-apply role labels should
- * skip these lines to avoid double-attribution.
- *
- * Co-located with `renderReaction` and `parentAlias` so the format
- * knowledge lives with the functions that own the line shape.
- */
-export function isReactionTagLine(text: string): boolean {
-  return REACTION_TAG_LINE_SUFFIX.test(text);
-}
-
 /**
  * Format a Slack ts (`"1700000000.000100"`) as `MM/DD/YY HH:MM` (UTC).
  *
@@ -168,6 +153,112 @@ function formatEpochMs(ms: number): string {
   return `${mo}/${da}/${yy} ${hh}:${mm}`;
 }
 
+const compactDateTimeFormatters = new Map<string, Intl.DateTimeFormat>();
+
+function getCompactDateTimeFormatter(timeZone: string): Intl.DateTimeFormat {
+  let formatter = compactDateTimeFormatters.get(timeZone);
+  if (!formatter) {
+    formatter = new Intl.DateTimeFormat("en-US", {
+      timeZone,
+      month: "short",
+      day: "numeric",
+      year: "numeric",
+      hour: "numeric",
+      minute: "2-digit",
+      hour12: true,
+    });
+    compactDateTimeFormatters.set(timeZone, formatter);
+  }
+  return formatter;
+}
+
+function compactDateTimeParts(ms: number, timeZone: string) {
+  try {
+    const parts = getCompactDateTimeFormatter(timeZone).formatToParts(
+      new Date(ms),
+    );
+    const get = (type: Intl.DateTimeFormatPartTypes) =>
+      parts.find((part) => part.type === type)?.value;
+    const month = get("month")?.toLowerCase();
+    const day = get("day");
+    const year = get("year");
+    const hour = get("hour");
+    const minute = get("minute");
+    const dayPeriod = get("dayPeriod");
+    if (!month || !day || !year || !hour || !minute || !dayPeriod) {
+      return null;
+    }
+    return { month, day, year, hour, minute, dayPeriod };
+  } catch {
+    return null;
+  }
+}
+
+function formatCompactEpochMs(
+  ms: number,
+  timeZone: string,
+  timezoneLabel: string | undefined,
+): string {
+  if (!Number.isFinite(ms)) {
+    return `??? ?? ???? ??:?? ${
+      formatSlackTimezoneLabel(timeZone, {
+        persistedLabel: timezoneLabel,
+        nowMs: ms,
+      }) ?? timeZone
+    }`;
+  }
+  const parts = compactDateTimeParts(ms, timeZone);
+  if (!parts) return formatEpochMs(ms);
+  const label =
+    formatSlackTimezoneLabel(timeZone, {
+      persistedLabel: timezoneLabel,
+      nowMs: ms,
+    }) ?? timeZone;
+  return `${parts.month} ${parts.day} ${parts.year} ${parts.hour}:${parts.minute} ${parts.dayPeriod} ${label}`;
+}
+
+function formatCompactSlackTs(
+  channelTs: string,
+  timeZone: string,
+  timezoneLabel: string | undefined,
+): string {
+  const seconds = Number.parseFloat(channelTs);
+  if (!Number.isFinite(seconds)) {
+    return `??? ?? ???? ??:?? ${
+      formatSlackTimezoneLabel(timeZone, {
+        persistedLabel: timezoneLabel,
+        nowMs: Number.NaN,
+      }) ?? timeZone
+    }`;
+  }
+  return formatCompactEpochMs(seconds * 1000, timeZone, timezoneLabel);
+}
+
+function hasTimestampTimezone(
+  meta: SlackMessageMetadata | null,
+): meta is SlackMessageMetadata & { timestampTimezone: string } {
+  return (
+    typeof meta?.timestampTimezone === "string" &&
+    meta.timestampTimezone.trim().length > 0
+  );
+}
+
+function speakerLabel(
+  msg: RenderableSlackMessage,
+  meta: SlackMessageMetadata,
+): string {
+  const speaker =
+    msg.senderLabel ?? (msg.role === "assistant" ? "assistant" : "");
+  const suffix =
+    msg.role === "assistant"
+      ? null
+      : formatSlackTimezoneLabel(undefined, {
+          persistedLabel: meta.speakerTimezoneLabel,
+        });
+  if (!speaker) return "";
+  return suffix ? `${speaker} (${suffix})` : speaker;
+}
+
 function renderSlackFileMarkers(
   files: SlackMessageMetadata["slackFiles"],
 ): string {
@@ -242,37 +333,62 @@ function maxNullableSlackTs(a: string | null, b: string | null): string | null {
  * is preserved without carrying a mimickable timestamp.
  *
  * Tradeoffs deliberately accepted by this simplification:
- * - Thread arrows (`→ Mxxxxxx`) are dropped from assistant rows. In the
- *   common single-thread-at-a-time case, role alternation + chronological
- *   adjacency tells the model which user turn each assistant reply answers,
- *   so no attribution is lost. The degenerate case is a channel where the
- *   assistant is fielding two thread conversations in parallel and the
- *   model has to disambiguate which reply lands in which thread from the
- *   full chronological transcript — the bracketed arrow previously carried
- *   that signal and is now absent. The `<active_thread>` focus block
- *   (single thread by construction) is unaffected.
+ * - Thread arrows (`→ Mxxxxxx`) are dropped from message-row tag lines. The
+ *   common single-thread-at-a-time case still has role alternation +
+ *   chronological adjacency, and the `<active_thread>` focus block remains a
+ *   single-thread view by construction.
  * - Edited assistant rows render only the latest content, not an edit
  *   marker. Edits are rare for the assistant and the latest content is the
  *   only replayable signal anyway.
  *
- * Any alternative "subtle" marker (e.g. an unbracketed `→ Mxxxxxx`) would
- * reintroduce a consistent, mimickable prefix pattern — the very problem
- * this function is designed to avoid — so we keep the content-only form.
+ * Any alternative "subtle" assistant marker would reintroduce a consistent,
+ * mimickable prefix pattern — the very problem this function is designed to
+ * avoid — so we keep the content-only form.
  */
 function renderMessage(msg: RenderableSlackMessage): string {
-  if (msg.role === "assistant") {
+  const meta = msg.metadata;
+
+  if (msg.role === "assistant" && !hasTimestampTimezone(meta)) {
     if (msg.metadata?.deletedAt !== undefined) return "[deleted]";
     return appendSlackFileMarkers(msg.content, msg.metadata?.slackFiles);
   }
 
-  const meta = msg.metadata;
   const senderPart = msg.senderLabel ? ` ${msg.senderLabel}` : "";
   if (!meta) {
-    // Legacy pre-upgrade row: flat render, no thread tag.
+    // Legacy pre-upgrade row: flat render, no Slack metadata-derived fields.
     const time = formatEpochMs(msg.createdAt);
     return `[${time}${senderPart}]: ${renderModelBodyWithSlackFiles(msg, undefined)}`;
   }
 
+  if (hasTimestampTimezone(meta)) {
+    const time = formatCompactSlackTs(
+      meta.channelTs,
+      meta.timestampTimezone,
+      meta.timestampTimezoneLabel,
+    );
+    const speaker = speakerLabel(msg, meta);
+    const speakerPart = speaker ? ` ${speaker}` : "";
+    if (meta.deletedAt !== undefined) {
+      const dtime = formatCompactEpochMs(
+        meta.deletedAt,
+        meta.timestampTimezone,
+        meta.timestampTimezoneLabel,
+      );
+      return `[${time}${speakerPart} - deleted ${dtime}]`;
+    }
+
+    let head = `[${time}${speakerPart}`;
+    if (meta.editedAt !== undefined) {
+      head += `, edited ${formatCompactEpochMs(
+        meta.editedAt,
+        meta.timestampTimezone,
+        meta.timestampTimezoneLabel,
+      )}`;
+    }
+    head += `] ${renderModelBodyWithSlackFiles(msg, meta.slackFiles)}`;
+    return head;
+  }
+
   const time = formatSlackTs(meta.channelTs);
 
   if (meta.deletedAt !== undefined) {
@@ -281,9 +397,6 @@ function renderMessage(msg: RenderableSlackMessage): string {
   }
 
   let head = `[${time}${senderPart}`;
-  if (meta.threadTs && meta.threadTs !== meta.channelTs) {
-    head += ` → ${parentAlias(meta.threadTs)}`;
-  }
   if (meta.editedAt !== undefined) {
     head += `, edited ${formatEpochMs(meta.editedAt)}`;
   }
@@ -343,7 +456,13 @@ function renderModelBody(msg: RenderableSlackMessage, body: string): string {
 function renderReaction(msg: RenderableSlackMessage): string | null {
   const meta = msg.metadata;
   if (!meta || meta.eventKind !== "reaction" || !meta.reaction) return null;
-  const time = formatSlackTs(meta.channelTs);
+  const time = hasTimestampTimezone(meta)
+    ? formatCompactSlackTs(
+        meta.channelTs,
+        meta.timestampTimezone,
+        meta.timestampTimezoneLabel,
+      )
+    : formatSlackTs(meta.channelTs);
   const actor =
     msg.senderLabel ?? (msg.role === "assistant" ? "@assistant" : "@user");
   const verb = meta.reaction.op === "added" ? "reacted" : "removed";
@@ -444,7 +563,7 @@ function buildMessageContentBlocks(
 }
 
 /**
- * Render a chronological transcript with compact thread tags.
+ * Render a chronological transcript with compact Slack tags.
  *
  * Sort is stable: messages with identical sort keys preserve their input
  * order so callers controlling input ordering can break ties deterministically.
@@ -517,6 +636,7 @@ export function renderSlackTranscriptWithProvenance(
       ],
     },
     sourceChannelTs: acc.sourceChannelTs,
+    tagLineProvenance: "slack-reaction",
   });
 
   const flushOverflowExcept = (
@@ -550,6 +670,7 @@ export function renderSlackTranscriptWithProvenance(
               content: [{ type: "text" as const, text: line }],
             },
             sourceChannelTs: meta.channelTs,
+            tagLineProvenance: "slack-reaction",
           });
         }
       } else {
@@ -575,12 +696,17 @@ export function renderSlackTranscriptWithProvenance(
     const tagLine = renderMessage(m);
     const blocks = buildMessageContentBlocks(m, tagLine);
     if (blocks.length === 0) continue;
+    const hasRenderedText = blocks.some((block) => block.type === "text");
     out.push({
       message: {
         role: m.role,
         content: blocks,
       },
       sourceChannelTs: meta?.channelTs ?? null,
+      tagLineProvenance:
+        hasRenderedText && hasTimestampTimezone(meta)
+          ? "slack-timezone-message"
+          : "none",
     });
   }
 
@@ -645,6 +771,7 @@ function filterOrphanToolPairs(
       out.push({
         message: { role: msg.role, content: kept },
         sourceChannelTs: entry.sourceChannelTs,
+        tagLineProvenance: entry.tagLineProvenance,
       });
     }
   }

package/src/messaging/providers/slack/send.test.ts

@@ -0,0 +1,77 @@
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+type CallSlackApi = (
+  method: string,
+  body: Record<string, unknown>,
+) => Promise<Record<string, unknown>>;
+
+const callSlackApiMock = mock<CallSlackApi>(async () => ({ ok: true }));
+
+mock.module("../../../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+mock.module("./api.js", () => ({
+  callSlackApi: (method: string, body: Record<string, unknown>) =>
+    callSlackApiMock(method, body),
+  callSlackApiForm: async () => ({}),
+  completeSlackUpload: async () => {},
+  SlackApiError: class SlackApiError extends Error {
+    slackError?: string;
+  },
+  uploadToSlackUrl: async () => {},
+}));
+
+import { sendSlackAssistantThreadStatus } from "./send.js";
+
+describe("sendSlackAssistantThreadStatus", () => {
+  beforeEach(() => {
+    callSlackApiMock.mockReset();
+    callSlackApiMock.mockImplementation(async () => ({ ok: true }));
+  });
+
+  test("serializes loading messages for Slack assistant thread status", async () => {
+    await sendSlackAssistantThreadStatus(
+      "C123",
+      "1700000000.000100",
+      "is working...",
+      ["Reading files", "Running tests"],
+    );
+
+    expect(callSlackApiMock).toHaveBeenCalledTimes(1);
+    expect(callSlackApiMock).toHaveBeenCalledWith(
+      "assistant.threads.setStatus",
+      {
+        channel_id: "C123",
+        thread_ts: "1700000000.000100",
+        status: "is working...",
+        loading_messages: ["Reading files", "Running tests"],
+      },
+    );
+  });
+
+  test("falls back to the reaction path when status API delivery fails", async () => {
+    callSlackApiMock
+      .mockImplementationOnce(async () => {
+        throw new Error("missing_scope");
+      })
+      .mockImplementationOnce(async () => ({ ok: true }));
+
+    await sendSlackAssistantThreadStatus(
+      "C123",
+      "1700000000.000100",
+      "is working...",
+      ["Reading files"],
+    );
+
+    expect(callSlackApiMock).toHaveBeenCalledTimes(2);
+    expect(callSlackApiMock).toHaveBeenNthCalledWith(2, "reactions.add", {
+      channel: "C123",
+      name: "eyes",
+      timestamp: "1700000000.000100",
+    });
+  });
+});

package/src/messaging/providers/slack/send.ts

@@ -275,13 +275,19 @@ export async function sendSlackAssistantThreadStatus(
   channel: string,
   threadTs: string,
   status: string,
+  loadingMessages?: string[],
 ): Promise<void> {
   try {
-    await callSlackApi("assistant.threads.setStatus", {
+    const body: Record<string, unknown> = {
       channel_id: channel,
       thread_ts: threadTs,
       status,
-    });
+    };
+    if (loadingMessages !== undefined) {
+      body.loading_messages = loadingMessages;
+    }
+
+    await callSlackApi("assistant.threads.setStatus", body);
     return;
   } catch {
     log.warn(

package/src/messaging/providers/slack/types.ts

@@ -13,6 +13,17 @@ export interface SlackAuthTestResponse extends SlackApiResponse {
   user_id: string;
 }
 
+export interface SlackBotsInfoResponse extends SlackApiResponse {
+  bot: {
+    id: string;
+    user_id?: string;
+    app_id?: string;
+    name?: string;
+    deleted?: boolean;
+    updated?: number;
+  };
+}
+
 export interface SlackConversation {
   id: string;
   name?: string;
@@ -78,6 +89,9 @@ export interface SlackUser {
   id: string;
   name: string;
   real_name?: string;
+  tz?: string;
+  tz_label?: string;
+  tz_offset?: number;
   profile?: {
     display_name?: string;
     real_name?: string;

package/src/notifications/__tests__/emit-signal-home-feed.test.ts

@@ -159,7 +159,10 @@ describe("emitNotificationSignal home-feed wire-up", () => {
     expect(appended.id).toBe(`notif:${result.signalId}`);
     expect(appended.title).toBe("Background job done");
     expect(appended.summary).toBe("Summary of what happened.");
-    expect(appended.conversationId).toBe("conv-vellum-1");
+    // The feed item's conversationId points to the source conversation
+    // that emitted the signal, not the conversation the notification
+    // pipeline spawned to handle it.
+    expect(appended.conversationId).toBe("conv-source-1");
   });
 
   test("interactive standard conversation does NOT trigger appendFeedItem", async () => {