@vellumai/assistant 0.5.16 → 0.6.1

package/src/__tests__/copy-composer-tc-templates.test.ts

@@ -0,0 +1,335 @@
+/**
+ * Tests for the trusted contact lifecycle fallback copy templates.
+ *
+ * Verifies that `ingress.trusted_contact.guardian_decision` and
+ * `ingress.trusted_contact.denied` templates in copy-composer.ts render
+ * display names when available and fall back to Slack <@ID> mention format
+ * for raw user IDs on the Slack source channel.
+ */
+import { describe, expect, test } from "bun:test";
+
+import { composeFallbackCopy } from "../notifications/copy-composer.js";
+import type { NotificationSignal } from "../notifications/signal.js";
+
+// ── Helpers ──────────────────────────────────────────────────────────────────
+
+function buildGuardianDecisionSignal(
+  payloadOverrides: Record<string, unknown> = {},
+  sourceChannel: "slack" | "telegram" | "vellum" = "slack",
+): NotificationSignal {
+  return {
+    signalId: "test-signal-gd",
+    createdAt: Date.now(),
+    sourceChannel,
+    sourceContextId: "test-ctx-1",
+    sourceEventName: "ingress.trusted_contact.guardian_decision",
+    contextPayload: {
+      sourceChannel,
+      requesterExternalUserId: "U07CLDQ4TB3",
+      requesterChatId: "D0AQ9C5PPPF",
+      decidedByExternalUserId: "U099H19C0KA",
+      requesterDisplayName: null,
+      decidedByDisplayName: null,
+      decision: "denied",
+      ...payloadOverrides,
+    },
+    attentionHints: {
+      requiresAction: false,
+      urgency: "medium",
+      isAsyncBackground: false,
+      visibleInSourceNow: false,
+    },
+  };
+}
+
+function buildDeniedSignal(
+  payloadOverrides: Record<string, unknown> = {},
+  sourceChannel: "slack" | "telegram" | "vellum" = "slack",
+): NotificationSignal {
+  return {
+    signalId: "test-signal-denied",
+    createdAt: Date.now(),
+    sourceChannel,
+    sourceContextId: "test-ctx-2",
+    sourceEventName: "ingress.trusted_contact.denied",
+    contextPayload: {
+      sourceChannel,
+      requesterExternalUserId: "U07CLDQ4TB3",
+      requesterChatId: "D0AQ9C5PPPF",
+      decidedByExternalUserId: "U099H19C0KA",
+      requesterDisplayName: null,
+      decidedByDisplayName: null,
+      decision: "denied",
+      ...payloadOverrides,
+    },
+    attentionHints: {
+      requiresAction: false,
+      urgency: "low",
+      isAsyncBackground: false,
+      visibleInSourceNow: false,
+    },
+  };
+}
+
+// ── guardian_decision template ────────────────────────────────────────────────
+
+describe("guardian_decision fallback copy", () => {
+  test("uses display names when both are present", () => {
+    const signal = buildGuardianDecisionSignal({
+      requesterDisplayName: "Alice",
+      decidedByDisplayName: "Bob",
+      decision: "denied",
+    });
+    const result = composeFallbackCopy(signal, ["vellum"]);
+    const copy = result.vellum!;
+
+    expect(copy.title).toBe("Trusted Contact Decision");
+    expect(copy.body).toBe("Alice's access request has been denied by Bob.");
+  });
+
+  test("falls back to Slack <@ID> mention format when display names are absent on Slack", () => {
+    const signal = buildGuardianDecisionSignal({
+      requesterDisplayName: null,
+      decidedByDisplayName: null,
+      requesterExternalUserId: "U07CLDQ4TB3",
+      decidedByExternalUserId: "U099H19C0KA",
+      sourceChannel: "slack",
+      decision: "denied",
+    });
+    const result = composeFallbackCopy(signal, ["vellum"]);
+    const copy = result.vellum!;
+
+    expect(copy.body).toBe(
+      "<@U07CLDQ4TB3>'s access request has been denied by <@U099H19C0KA>.",
+    );
+  });
+
+  test("uses raw user IDs without Slack formatting on non-Slack channels", () => {
+    const signal = buildGuardianDecisionSignal(
+      {
+        requesterDisplayName: null,
+        decidedByDisplayName: null,
+        requesterExternalUserId: "U07CLDQ4TB3",
+        decidedByExternalUserId: "U099H19C0KA",
+        sourceChannel: "telegram",
+        decision: "denied",
+      },
+      "telegram",
+    );
+    const result = composeFallbackCopy(signal, ["vellum"]);
+    const copy = result.vellum!;
+
+    expect(copy.body).toBe(
+      "U07CLDQ4TB3's access request has been denied by U099H19C0KA.",
+    );
+    expect(copy.body).not.toContain("<@");
+  });
+
+  test("produces distinct copy for approved vs denied decisions", () => {
+    const deniedSignal = buildGuardianDecisionSignal({
+      requesterDisplayName: "Alice",
+      decidedByDisplayName: "Bob",
+      decision: "denied",
+    });
+    const approvedSignal = buildGuardianDecisionSignal({
+      requesterDisplayName: "Alice",
+      decidedByDisplayName: "Bob",
+      decision: "approved",
+    });
+
+    const deniedCopy = composeFallbackCopy(deniedSignal, ["vellum"]).vellum!;
+    const approvedCopy = composeFallbackCopy(approvedSignal, [
+      "vellum",
+    ]).vellum!;
+
+    expect(deniedCopy.body).toContain("denied");
+    expect(deniedCopy.body).not.toContain("approved");
+    expect(approvedCopy.body).toContain("approved");
+    expect(approvedCopy.body).not.toContain("denied");
+  });
+
+  test("does not expose raw conversation IDs (requesterChatId) in output", () => {
+    const signal = buildGuardianDecisionSignal({
+      requesterDisplayName: null,
+      decidedByDisplayName: null,
+      requesterChatId: "D0AQ9C5PPPF",
+      requesterExternalUserId: "U07CLDQ4TB3",
+      decidedByExternalUserId: "U099H19C0KA",
+    });
+    const result = composeFallbackCopy(signal, ["vellum"]);
+    const copy = result.vellum!;
+
+    expect(copy.body).not.toContain("D0AQ9C5PPPF");
+  });
+
+  test("falls back to 'Someone' when requester identity is entirely absent", () => {
+    const signal = buildGuardianDecisionSignal({
+      requesterDisplayName: null,
+      requesterExternalUserId: null,
+      decidedByDisplayName: "Bob",
+      decision: "denied",
+    });
+    const result = composeFallbackCopy(signal, ["vellum"]);
+    const copy = result.vellum!;
+
+    expect(copy.body).toBe("Someone's access request has been denied by Bob.");
+  });
+
+  test("falls back to 'a guardian' when decider identity is entirely absent", () => {
+    const signal = buildGuardianDecisionSignal({
+      requesterDisplayName: "Alice",
+      decidedByDisplayName: null,
+      decidedByExternalUserId: null,
+      decision: "approved",
+    });
+    const result = composeFallbackCopy(signal, ["vellum"]);
+    const copy = result.vellum!;
+
+    expect(copy.body).toBe(
+      "Alice's access request has been approved by a guardian.",
+    );
+  });
+
+  test("prefers display name over Slack user ID when both are present", () => {
+    const signal = buildGuardianDecisionSignal({
+      requesterDisplayName: "Alice",
+      requesterExternalUserId: "U07CLDQ4TB3",
+      decidedByDisplayName: "Bob",
+      decidedByExternalUserId: "U099H19C0KA",
+      sourceChannel: "slack",
+      decision: "denied",
+    });
+    const result = composeFallbackCopy(signal, ["vellum"]);
+    const copy = result.vellum!;
+
+    expect(copy.body).toBe("Alice's access request has been denied by Bob.");
+    expect(copy.body).not.toContain("<@");
+  });
+
+  test("sanitizes control characters from display names", () => {
+    const signal = buildGuardianDecisionSignal({
+      requesterDisplayName: "Alice\x00\x07\nEvil",
+      decidedByDisplayName: "Bob\r\nMalicious",
+      decision: "approved",
+    });
+    const result = composeFallbackCopy(signal, ["vellum"]);
+    const copy = result.vellum!;
+
+    expect(copy.body).not.toMatch(/[\x00-\x1f\x7f-\x9f]/);
+    expect(copy.body).toContain("Alice");
+    expect(copy.body).toContain("Bob");
+  });
+
+  test("clamps excessively long display names", () => {
+    const longName = "A".repeat(200);
+    const signal = buildGuardianDecisionSignal({
+      requesterDisplayName: longName,
+      decidedByDisplayName: "Bob",
+      decision: "denied",
+    });
+    const result = composeFallbackCopy(signal, ["vellum"]);
+    const copy = result.vellum!;
+
+    // sanitizeIdentityField clamps to 120 chars + ellipsis
+    expect(copy.body.length).toBeLessThan(longName.length);
+    expect(copy.body).toContain("…");
+  });
+});
+
+// ── denied template ──────────────────────────────────────────────────────────
+
+describe("trusted_contact.denied fallback copy", () => {
+  test("uses display name when present", () => {
+    const signal = buildDeniedSignal({
+      requesterDisplayName: "Alice",
+    });
+    const result = composeFallbackCopy(signal, ["vellum"]);
+    const copy = result.vellum!;
+
+    expect(copy.title).toBe("Trusted Contact Denied");
+    expect(copy.body).toBe(
+      "A trusted contact request from Alice has been denied.",
+    );
+  });
+
+  test("falls back to Slack <@ID> mention format on Slack when display name absent", () => {
+    const signal = buildDeniedSignal({
+      requesterDisplayName: null,
+      requesterExternalUserId: "U07CLDQ4TB3",
+      sourceChannel: "slack",
+    });
+    const result = composeFallbackCopy(signal, ["vellum"]);
+    const copy = result.vellum!;
+
+    expect(copy.body).toBe(
+      "A trusted contact request from <@U07CLDQ4TB3> has been denied.",
+    );
+  });
+
+  test("uses raw user ID without Slack formatting on non-Slack channels", () => {
+    const signal = buildDeniedSignal(
+      {
+        requesterDisplayName: null,
+        requesterExternalUserId: "U07CLDQ4TB3",
+        sourceChannel: "telegram",
+      },
+      "telegram",
+    );
+    const result = composeFallbackCopy(signal, ["vellum"]);
+    const copy = result.vellum!;
+
+    expect(copy.body).toBe(
+      "A trusted contact request from U07CLDQ4TB3 has been denied.",
+    );
+    expect(copy.body).not.toContain("<@");
+  });
+
+  test("falls back to 'Someone' when requester identity is absent", () => {
+    const signal = buildDeniedSignal({
+      requesterDisplayName: null,
+      requesterExternalUserId: null,
+    });
+    const result = composeFallbackCopy(signal, ["vellum"]);
+    const copy = result.vellum!;
+
+    expect(copy.body).toBe(
+      "A trusted contact request from Someone has been denied.",
+    );
+  });
+
+  test("does not expose raw conversation IDs (requesterChatId) in output", () => {
+    const signal = buildDeniedSignal({
+      requesterDisplayName: null,
+      requesterExternalUserId: "U07CLDQ4TB3",
+      requesterChatId: "D0AQ9C5PPPF",
+    });
+    const result = composeFallbackCopy(signal, ["vellum"]);
+    const copy = result.vellum!;
+
+    expect(copy.body).not.toContain("D0AQ9C5PPPF");
+  });
+
+  test("sanitizes control characters from display names", () => {
+    const signal = buildDeniedSignal({
+      requesterDisplayName: "Alice\x00\x07\nEvil",
+    });
+    const result = composeFallbackCopy(signal, ["vellum"]);
+    const copy = result.vellum!;
+
+    expect(copy.body).not.toMatch(/[\x00-\x1f\x7f-\x9f]/);
+    expect(copy.body).toContain("Alice");
+  });
+
+  test("clamps excessively long display names", () => {
+    const longName = "A".repeat(200);
+    const signal = buildDeniedSignal({
+      requesterDisplayName: longName,
+    });
+    const result = composeFallbackCopy(signal, ["vellum"]);
+    const copy = result.vellum!;
+
+    // sanitizeIdentityField clamps to 120 chars + ellipsis
+    expect(copy.body.length).toBeLessThan(longName.length);
+    expect(copy.body).toContain("…");
+  });
+});

package/src/__tests__/credential-execution-feature-gates.test.ts

@@ -180,7 +180,7 @@ describe("CES flags do not affect unrelated flags", () => {
     expect(isAssistantFeatureFlagEnabled("browser", config)).toBe(true);
   });
 
-  test("enabling all CES flags does not change contacts flag (defaultEnabled: true)", () => {
+  test("enabling all CES flags does not change sounds flag (defaultEnabled: true)", () => {
     const overrides: Record<string, boolean> = {};
     for (const key of ALL_CES_FLAG_KEYS) {
       overrides[key] = true;
@@ -188,7 +188,7 @@ describe("CES flags do not affect unrelated flags", () => {
     _setOverridesForTesting(overrides);
     const config = makeConfig();
 
-    // contacts defaults to true in the registry and should stay true
-    expect(isAssistantFeatureFlagEnabled("contacts", config)).toBe(true);
+    // sounds defaults to true in the registry and should stay true
+    expect(isAssistantFeatureFlagEnabled("sounds", config)).toBe(true);
   });
 });

package/src/__tests__/credential-execution-shell-lockdown.test.ts

@@ -33,8 +33,8 @@ describe("trust class categorization for CES lockdown", () => {
     expect(isUntrustedTrustClass("unknown")).toBe(true);
   });
 
-  test("undefined is not untrusted", () => {
-    expect(isUntrustedTrustClass(undefined)).toBe(false);
+  test("undefined is untrusted", () => {
+    expect(isUntrustedTrustClass(undefined)).toBe(true);
   });
 });
 

package/src/__tests__/credential-security-e2e.test.ts

@@ -70,6 +70,8 @@ mock.module("../security/secure-keys.js", () => {
       accounts: [...storedKeys.keys()],
       unreachable: false,
     }),
+    getProviderKeyAsync: async () => undefined,
+    getMaskedProviderKey: async () => null,
   };
 });
 

package/src/__tests__/date-context.test.ts

@@ -1,219 +1,10 @@
 import { describe, expect, test } from "bun:test";
 
 import {
-  buildTemporalContext,
   extractUserTimeZoneFromRecall,
+  formatTurnTimestamp,
 } from "../daemon/date-context.js";
 
-// Fixed timestamps for deterministic assertions (all UTC midday to avoid DST edge cases).
-
-/** Wednesday 2026-02-18 12:00 UTC */
-const WED_FEB_18 = Date.UTC(2026, 1, 18, 12, 0, 0);
-
-/** Tuesday 2026-12-29 12:00 UTC - year boundary */
-const TUE_DEC_29 = Date.UTC(2026, 11, 29, 12, 0, 0);
-
-// ---------------------------------------------------------------------------
-// Basic structure
-// ---------------------------------------------------------------------------
-
-describe("buildTemporalContext", () => {
-  test("returns output wrapped in <temporal_context> tags", () => {
-    const result = buildTemporalContext({ nowMs: WED_FEB_18, timeZone: "UTC" });
-    expect(result).toStartWith("<temporal_context>");
-    expect(result).toEndWith("</temporal_context>");
-  });
-
-  test("includes today date, weekday, time and offset on one line", () => {
-    const result = buildTemporalContext({ nowMs: WED_FEB_18, timeZone: "UTC" });
-    expect(result).toContain("Today: 2026-02-18 (Wed) 12:00 +00:00");
-  });
-
-  test("includes timezone", () => {
-    const result = buildTemporalContext({
-      nowMs: WED_FEB_18,
-      timeZone: "America/New_York",
-    });
-    expect(result).toContain("TZ: America/New_York");
-  });
-
-  test("does not include UTC time, timezone source, or seconds", () => {
-    const result = buildTemporalContext({ nowMs: WED_FEB_18, timeZone: "UTC" });
-    expect(result).not.toContain("Current UTC time");
-    expect(result).not.toContain("Current local time");
-    expect(result).not.toContain("Timezone source:");
-    // No seconds in the time
-    expect(result).not.toContain("12:00:00");
-  });
-
-  test("does not include week definitions, next weekend, next work week, or horizon dates", () => {
-    const result = buildTemporalContext({ nowMs: WED_FEB_18, timeZone: "UTC" });
-    expect(result).not.toContain("Week definitions");
-    expect(result).not.toContain("Next weekend");
-    expect(result).not.toContain("Next work week");
-    expect(result).not.toContain("Upcoming dates");
-  });
-
-  test("uses user timezone when provided", () => {
-    const result = buildTemporalContext({
-      nowMs: WED_FEB_18,
-      hostTimeZone: "UTC",
-      userTimeZone: "America/New_York",
-    });
-    expect(result).toContain("TZ: America/New_York");
-    expect(result).toContain("Today: 2026-02-18 (Wed) 07:00 -05:00");
-    expect(result).not.toContain("(host fallback)");
-  });
-
-  test("shows user TZ only when different from primary timezone", () => {
-    // When user timezone equals the primary timezone, omit it
-    const sameResult = buildTemporalContext({
-      nowMs: WED_FEB_18,
-      hostTimeZone: "UTC",
-      configuredUserTimeZone: "UTC",
-    });
-    expect(sameResult).not.toContain("User TZ:");
-
-    // When user timezone differs from host, it becomes the primary timezone
-    // and the host timezone is shown as a secondary annotation
-    const diffResult = buildTemporalContext({
-      nowMs: WED_FEB_18,
-      hostTimeZone: "UTC",
-      userTimeZone: "America/New_York",
-    });
-    expect(diffResult).toContain("TZ: America/New_York");
-    expect(diffResult).toContain("Host TZ: UTC");
-    expect(diffResult).not.toContain("User TZ:");
-  });
-
-  test("shows host TZ only when different from primary timezone", () => {
-    // When host timezone equals the primary timezone, omit it
-    const sameResult = buildTemporalContext({
-      nowMs: WED_FEB_18,
-      hostTimeZone: "UTC",
-      timeZone: "UTC",
-    });
-    expect(sameResult).not.toContain("Host TZ:");
-
-    // When different, include it
-    const diffResult = buildTemporalContext({
-      nowMs: WED_FEB_18,
-      hostTimeZone: "UTC",
-      userTimeZone: "America/New_York",
-    });
-    expect(diffResult).toContain("Host TZ: UTC");
-  });
-
-  test("uses configured user timezone when profile timezone is unavailable", () => {
-    const result = buildTemporalContext({
-      nowMs: WED_FEB_18,
-      hostTimeZone: "UTC",
-      configuredUserTimeZone: "America/Chicago",
-      userTimeZone: null,
-    });
-    expect(result).toContain("TZ: America/Chicago");
-    expect(result).toContain("Today: 2026-02-18 (Wed) 06:00 -06:00");
-    expect(result).not.toContain("(host fallback)");
-  });
-
-  test("configured user timezone takes precedence over profile timezone", () => {
-    const result = buildTemporalContext({
-      nowMs: WED_FEB_18,
-      hostTimeZone: "UTC",
-      configuredUserTimeZone: "America/Los_Angeles",
-      userTimeZone: "America/New_York",
-    });
-    expect(result).toContain("TZ: America/Los_Angeles");
-    expect(result).toContain("Today: 2026-02-18 (Wed) 04:00 -08:00");
-  });
-
-  test("falls back to host timezone with (host fallback) suffix", () => {
-    const result = buildTemporalContext({
-      nowMs: WED_FEB_18,
-      hostTimeZone: "UTC",
-      userTimeZone: null,
-    });
-    expect(result).toContain("TZ: UTC (host fallback)");
-  });
-
-  test("accepts UTC/GMT offset-style user timezone values", () => {
-    const result = buildTemporalContext({
-      nowMs: WED_FEB_18,
-      hostTimeZone: "UTC",
-      userTimeZone: "UTC+2",
-    });
-    expect(result).toContain("TZ: Etc/GMT-2");
-    expect(result).toContain("Today: 2026-02-18 (Wed) 14:00 +02:00");
-    expect(result).not.toContain("(host fallback)");
-  });
-
-  test("accepts fractional UTC/GMT offset-style user timezone values", () => {
-    const result = buildTemporalContext({
-      nowMs: WED_FEB_18,
-      hostTimeZone: "UTC",
-      userTimeZone: "UTC+5:30",
-    });
-    expect(result).toContain("TZ: +05:30");
-    expect(result).toContain("Today: 2026-02-18 (Wed) 17:30 +05:30");
-    expect(result).not.toContain("(host fallback)");
-  });
-
-  test("formats midnight hours as 00 (never 24)", () => {
-    const justAfterMidnight = Date.UTC(2026, 1, 19, 0, 5, 0);
-    const result = buildTemporalContext({
-      nowMs: justAfterMidnight,
-      timeZone: "UTC",
-    });
-    expect(result).toContain("00:05 +00:00");
-    expect(result).not.toContain("24:05");
-  });
-
-  test("Today line includes full YYYY-MM-DD format with year", () => {
-    const result = buildTemporalContext({ nowMs: WED_FEB_18, timeZone: "UTC" });
-    expect(result).toMatch(/Today: \d{4}-\d{2}-\d{2} \(\w{3}\) \d{2}:\d{2}/);
-    expect(result).toContain("2026-02-18");
-  });
-
-  test("handles year boundary correctly", () => {
-    const result = buildTemporalContext({ nowMs: TUE_DEC_29, timeZone: "UTC" });
-    expect(result).toContain("Today: 2026-12-29 (Tue)");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// DST-safe timezone behavior
-// ---------------------------------------------------------------------------
-
-describe("DST-safe timezone behavior", () => {
-  test("date labels are correct in US Eastern timezone", () => {
-    const result = buildTemporalContext({
-      nowMs: WED_FEB_18,
-      timeZone: "America/New_York",
-    });
-    expect(result).toContain("Today: 2026-02-18 (Wed) 07:00 -05:00");
-  });
-
-  test("date labels are correct in timezone ahead of UTC", () => {
-    // Feb 18 23:00 UTC = Feb 19 08:00 JST
-    const nearMidnight = Date.UTC(2026, 1, 18, 23, 0, 0);
-    const result = buildTemporalContext({
-      nowMs: nearMidnight,
-      timeZone: "Asia/Tokyo",
-    });
-    expect(result).toContain("Today: 2026-02-19 (Thu) 08:00 +09:00");
-  });
-
-  test("local offset tracks daylight saving changes", () => {
-    // Jul 1 12:00 UTC = Jul 1 08:00 EDT
-    const summer = Date.UTC(2026, 6, 1, 12, 0, 0);
-    const result = buildTemporalContext({
-      nowMs: summer,
-      timeZone: "America/New_York",
-    });
-    expect(result).toContain("Today: 2026-07-01 (Wed) 08:00 -04:00");
-  });
-});
-
 // ---------------------------------------------------------------------------
 // extractUserTimeZoneFromRecall
 // ---------------------------------------------------------------------------
@@ -293,3 +84,78 @@ describe("extractUserTimeZoneFromRecall", () => {
     expect(extractUserTimeZoneFromRecall(text)).toBe("America/Denver");
   });
 });
+
+// ---------------------------------------------------------------------------
+// formatTurnTimestamp
+// ---------------------------------------------------------------------------
+
+describe("formatTurnTimestamp", () => {
+  /** 2026-04-02 06:52:33 UTC (Thursday) */
+  const THU_APR_02_0652 = Date.UTC(2026, 3, 2, 6, 52, 33);
+
+  test("includes seconds in the timestamp", () => {
+    const result = formatTurnTimestamp({
+      nowMs: THU_APR_02_0652,
+      timeZone: "America/Chicago",
+    });
+    expect(result).toContain("01:52:33");
+  });
+
+  test("timezone name appears in parentheses", () => {
+    const result = formatTurnTimestamp({
+      nowMs: THU_APR_02_0652,
+      timeZone: "America/Chicago",
+    });
+    expect(result).toContain("(America/Chicago)");
+  });
+
+  test("produces expected full format", () => {
+    const result = formatTurnTimestamp({
+      nowMs: THU_APR_02_0652,
+      timeZone: "America/Chicago",
+    });
+    expect(result).toBe(
+      "2026-04-02 (Thu) 01:52:33 -05:00 (America/Chicago)",
+    );
+  });
+
+  test("handles UTC fallback when no timezone provided", () => {
+    const result = formatTurnTimestamp({
+      nowMs: THU_APR_02_0652,
+      hostTimeZone: "UTC",
+    });
+    expect(result).toBe("2026-04-02 (Thu) 06:52:33 +00:00 (UTC)");
+  });
+
+  test("handles user timezone override", () => {
+    const result = formatTurnTimestamp({
+      nowMs: THU_APR_02_0652,
+      hostTimeZone: "UTC",
+      userTimeZone: "Asia/Tokyo",
+    });
+    expect(result).toBe("2026-04-02 (Thu) 15:52:33 +09:00 (Asia/Tokyo)");
+  });
+
+  test("handles DST correctly", () => {
+    // Jul 1 12:00:30 UTC = Jul 1 08:00:30 EDT (Eastern Daylight Time, -04:00)
+    const summerWithSeconds = Date.UTC(2026, 6, 1, 12, 0, 30);
+    const result = formatTurnTimestamp({
+      nowMs: summerWithSeconds,
+      timeZone: "America/New_York",
+    });
+    expect(result).toBe(
+      "2026-07-01 (Wed) 08:00:30 -04:00 (America/New_York)",
+    );
+  });
+
+  test("formats midnight as 00", () => {
+    // 2026-02-19 00:00:15 UTC
+    const justAfterMidnight = Date.UTC(2026, 1, 19, 0, 0, 15);
+    const result = formatTurnTimestamp({
+      nowMs: justAfterMidnight,
+      timeZone: "UTC",
+    });
+    expect(result).toContain("00:00:15");
+    expect(result).not.toContain("24:");
+  });
+});