@vellumai/assistant 0.5.15 → 0.6.0

package/src/memory/graph/triggers.test.ts

@@ -0,0 +1,487 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+  evaluateEventTriggers,
+  evaluateSemanticTriggers,
+  evaluateTemporalTriggers,
+} from "./triggers.js";
+import type { MemoryTrigger } from "./types.js";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+const DAY_MS = 1000 * 60 * 60 * 24;
+
+function makeTrigger(overrides: Partial<MemoryTrigger> = {}): MemoryTrigger {
+  return {
+    id: "trigger-1",
+    nodeId: "node-1",
+    type: "temporal",
+    schedule: null,
+    condition: null,
+    conditionEmbedding: null,
+    threshold: null,
+    eventDate: null,
+    rampDays: null,
+    followUpDays: null,
+    recurring: false,
+    consumed: false,
+    cooldownMs: null,
+    lastFired: null,
+    ...overrides,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// evaluateTemporalTriggers
+// ---------------------------------------------------------------------------
+
+describe("evaluateTemporalTriggers", () => {
+  test("fires day-of-week trigger on matching day", () => {
+    // 2025-06-16 is a Monday
+    const monday = new Date("2025-06-16T10:00:00Z");
+    const trigger = makeTrigger({
+      type: "temporal",
+      schedule: "day-of-week:monday",
+    });
+    const results = evaluateTemporalTriggers([trigger], monday);
+    expect(results).toHaveLength(1);
+    expect(results[0].boost).toBe(1.0);
+  });
+
+  test("does not fire day-of-week trigger on non-matching day", () => {
+    // 2025-06-17 is a Tuesday
+    const tuesday = new Date("2025-06-17T10:00:00Z");
+    const trigger = makeTrigger({
+      type: "temporal",
+      schedule: "day-of-week:monday",
+    });
+    const results = evaluateTemporalTriggers([trigger], tuesday);
+    expect(results).toHaveLength(0);
+  });
+
+  test("fires date trigger on matching date", () => {
+    const april8 = new Date("2025-04-08T15:00:00Z");
+    const trigger = makeTrigger({
+      type: "temporal",
+      schedule: "date:04-08",
+    });
+    const results = evaluateTemporalTriggers([trigger], april8);
+    expect(results).toHaveLength(1);
+  });
+
+  test("does not fire date trigger on non-matching date", () => {
+    const april9 = new Date("2025-04-09T15:00:00Z");
+    const trigger = makeTrigger({
+      type: "temporal",
+      schedule: "date:04-08",
+    });
+    const results = evaluateTemporalTriggers([trigger], april9);
+    expect(results).toHaveLength(0);
+  });
+
+  test("fires time:morning trigger between 5-11", () => {
+    const morning = new Date("2025-06-15T08:00:00"); // local hour 8
+    const trigger = makeTrigger({
+      type: "temporal",
+      schedule: "time:morning",
+    });
+    const results = evaluateTemporalTriggers([trigger], morning);
+    expect(results).toHaveLength(1);
+  });
+
+  test("fires time:afternoon trigger between 12-16", () => {
+    const afternoon = new Date("2025-06-15T14:00:00"); // local hour 14
+    const trigger = makeTrigger({
+      type: "temporal",
+      schedule: "time:afternoon",
+    });
+    const results = evaluateTemporalTriggers([trigger], afternoon);
+    expect(results).toHaveLength(1);
+  });
+
+  test("fires time:evening trigger between 17-20", () => {
+    const evening = new Date("2025-06-15T18:00:00"); // local hour 18
+    const trigger = makeTrigger({
+      type: "temporal",
+      schedule: "time:evening",
+    });
+    const results = evaluateTemporalTriggers([trigger], evening);
+    expect(results).toHaveLength(1);
+  });
+
+  test("fires time:night trigger at 22:00", () => {
+    const night = new Date("2025-06-15T22:00:00"); // local hour 22
+    const trigger = makeTrigger({
+      type: "temporal",
+      schedule: "time:night",
+    });
+    const results = evaluateTemporalTriggers([trigger], night);
+    expect(results).toHaveLength(1);
+  });
+
+  test("fires time:night trigger at 3 AM (wraps past midnight)", () => {
+    const lateNight = new Date("2025-06-15T03:00:00"); // local hour 3
+    const trigger = makeTrigger({
+      type: "temporal",
+      schedule: "time:night",
+    });
+    const results = evaluateTemporalTriggers([trigger], lateNight);
+    expect(results).toHaveLength(1);
+  });
+
+  test("does not fire time:morning at 14:00", () => {
+    const afternoon = new Date("2025-06-15T14:00:00");
+    const trigger = makeTrigger({
+      type: "temporal",
+      schedule: "time:morning",
+    });
+    const results = evaluateTemporalTriggers([trigger], afternoon);
+    expect(results).toHaveLength(0);
+  });
+
+  test("skips non-temporal triggers", () => {
+    const now = new Date("2025-06-16T10:00:00Z");
+    const trigger = makeTrigger({
+      type: "semantic",
+      schedule: "day-of-week:monday",
+    });
+    const results = evaluateTemporalTriggers([trigger], now);
+    expect(results).toHaveLength(0);
+  });
+
+  test("skips triggers without a schedule", () => {
+    const now = new Date("2025-06-16T10:00:00Z");
+    const trigger = makeTrigger({
+      type: "temporal",
+      schedule: null,
+    });
+    const results = evaluateTemporalTriggers([trigger], now);
+    expect(results).toHaveLength(0);
+  });
+
+  test("respects cooldown for recurring triggers", () => {
+    const now = new Date("2025-06-16T10:00:00Z");
+    const trigger = makeTrigger({
+      type: "temporal",
+      schedule: "day-of-week:monday",
+      recurring: true,
+      cooldownMs: DAY_MS,
+      lastFired: now.getTime() - DAY_MS / 2, // fired 12h ago, cooldown 24h
+    });
+    const results = evaluateTemporalTriggers([trigger], now);
+    expect(results).toHaveLength(0);
+  });
+
+  test("fires recurring trigger after cooldown expires", () => {
+    const now = new Date("2025-06-16T10:00:00Z");
+    const trigger = makeTrigger({
+      type: "temporal",
+      schedule: "day-of-week:monday",
+      recurring: true,
+      cooldownMs: DAY_MS,
+      lastFired: now.getTime() - DAY_MS * 2, // fired 2 days ago, cooldown 24h
+    });
+    const results = evaluateTemporalTriggers([trigger], now);
+    expect(results).toHaveLength(1);
+  });
+
+  test("non-recurring triggers bypass cooldown check", () => {
+    const now = new Date("2025-06-16T10:00:00Z");
+    const trigger = makeTrigger({
+      type: "temporal",
+      schedule: "day-of-week:monday",
+      recurring: false,
+      lastFired: now.getTime() - 1000, // fired 1s ago
+    });
+    const results = evaluateTemporalTriggers([trigger], now);
+    expect(results).toHaveLength(1);
+  });
+
+  test("handles case-insensitive schedule matching", () => {
+    const monday = new Date("2025-06-16T10:00:00Z");
+    const trigger = makeTrigger({
+      type: "temporal",
+      schedule: "Day-Of-Week:Monday",
+    });
+    const results = evaluateTemporalTriggers([trigger], monday);
+    expect(results).toHaveLength(1);
+  });
+
+  test("evaluates multiple triggers independently", () => {
+    const monday = new Date("2025-06-16T10:00:00Z");
+    const triggers = [
+      makeTrigger({
+        id: "t1",
+        type: "temporal",
+        schedule: "day-of-week:monday",
+      }),
+      makeTrigger({
+        id: "t2",
+        type: "temporal",
+        schedule: "day-of-week:tuesday",
+      }),
+      makeTrigger({
+        id: "t3",
+        type: "temporal",
+        schedule: "day-of-week:monday",
+      }),
+    ];
+    const results = evaluateTemporalTriggers(triggers, monday);
+    expect(results).toHaveLength(2);
+    expect(results.map((r) => r.trigger.id)).toEqual(["t1", "t3"]);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// evaluateSemanticTriggers
+// ---------------------------------------------------------------------------
+
+describe("evaluateSemanticTriggers", () => {
+  test("fires when cosine similarity exceeds threshold", () => {
+    // Two identical unit vectors → similarity = 1.0
+    const embedding = new Float32Array([1, 0, 0]);
+    const trigger = makeTrigger({
+      type: "semantic",
+      conditionEmbedding: new Float32Array([1, 0, 0]),
+      threshold: 0.5,
+    });
+    const results = evaluateSemanticTriggers([trigger], embedding);
+    expect(results).toHaveLength(1);
+    expect(results[0].boost).toBeGreaterThanOrEqual(0.5);
+  });
+
+  test("does not fire when similarity is below threshold", () => {
+    // Orthogonal vectors → similarity = 0
+    const embedding = new Float32Array([1, 0, 0]);
+    const trigger = makeTrigger({
+      type: "semantic",
+      conditionEmbedding: new Float32Array([0, 1, 0]),
+      threshold: 0.5,
+    });
+    const results = evaluateSemanticTriggers([trigger], embedding);
+    expect(results).toHaveLength(0);
+  });
+
+  test("boost scales by how far above threshold", () => {
+    // Identical vectors: similarity = 1.0, threshold = 0.5
+    // boost = (1.0 - 0.5) / (1 - 0.5 + 0.001) ≈ 1.0
+    const embedding = new Float32Array([1, 0, 0]);
+    const trigger = makeTrigger({
+      type: "semantic",
+      conditionEmbedding: new Float32Array([1, 0, 0]),
+      threshold: 0.5,
+    });
+    const results = evaluateSemanticTriggers([trigger], embedding);
+    expect(results[0].boost).toBeCloseTo(1.0, 1);
+  });
+
+  test("boost has minimum of 0.5", () => {
+    // Barely above threshold — boost would be near 0, but floored to 0.5
+    const embedding = new Float32Array([1, 0, 0]);
+    const trigger = makeTrigger({
+      type: "semantic",
+      conditionEmbedding: new Float32Array([0.98, 0.2, 0]),
+      threshold: 0.97,
+    });
+    const results = evaluateSemanticTriggers([trigger], embedding);
+    if (results.length > 0) {
+      expect(results[0].boost).toBeGreaterThanOrEqual(0.5);
+    }
+  });
+
+  test("skips consumed triggers", () => {
+    const embedding = new Float32Array([1, 0, 0]);
+    const trigger = makeTrigger({
+      type: "semantic",
+      conditionEmbedding: new Float32Array([1, 0, 0]),
+      threshold: 0.5,
+      consumed: true,
+    });
+    const results = evaluateSemanticTriggers([trigger], embedding);
+    expect(results).toHaveLength(0);
+  });
+
+  test("skips triggers without embeddings", () => {
+    const embedding = new Float32Array([1, 0, 0]);
+    const trigger = makeTrigger({
+      type: "semantic",
+      conditionEmbedding: null,
+      threshold: 0.5,
+    });
+    const results = evaluateSemanticTriggers([trigger], embedding);
+    expect(results).toHaveLength(0);
+  });
+
+  test("skips triggers without threshold", () => {
+    const embedding = new Float32Array([1, 0, 0]);
+    const trigger = makeTrigger({
+      type: "semantic",
+      conditionEmbedding: new Float32Array([1, 0, 0]),
+      threshold: null,
+    });
+    const results = evaluateSemanticTriggers([trigger], embedding);
+    expect(results).toHaveLength(0);
+  });
+
+  test("skips non-semantic triggers", () => {
+    const embedding = new Float32Array([1, 0, 0]);
+    const trigger = makeTrigger({
+      type: "temporal",
+      conditionEmbedding: new Float32Array([1, 0, 0]),
+      threshold: 0.5,
+    });
+    const results = evaluateSemanticTriggers([trigger], embedding);
+    expect(results).toHaveLength(0);
+  });
+
+  test("handles mismatched vector lengths gracefully", () => {
+    const embedding = new Float32Array([1, 0, 0]);
+    const trigger = makeTrigger({
+      type: "semantic",
+      conditionEmbedding: new Float32Array([1, 0]),
+      threshold: 0.5,
+    });
+    // cosineSimilarity returns 0 for mismatched lengths → no fire
+    const results = evaluateSemanticTriggers([trigger], embedding);
+    expect(results).toHaveLength(0);
+  });
+
+  test("accepts number[] as query embedding", () => {
+    const embedding = [1, 0, 0];
+    const trigger = makeTrigger({
+      type: "semantic",
+      conditionEmbedding: new Float32Array([1, 0, 0]),
+      threshold: 0.5,
+    });
+    const results = evaluateSemanticTriggers([trigger], embedding);
+    expect(results).toHaveLength(1);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// evaluateEventTriggers
+// ---------------------------------------------------------------------------
+
+describe("evaluateEventTriggers", () => {
+  test("returns background boost (0.05) for events far in the future", () => {
+    const now = new Date("2025-06-15T10:00:00Z");
+    const trigger = makeTrigger({
+      type: "event",
+      eventDate: now.getTime() + 30 * DAY_MS, // 30 days away
+      rampDays: 7,
+      followUpDays: 2,
+    });
+    const results = evaluateEventTriggers([trigger], now);
+    expect(results).toHaveLength(1);
+    expect(results[0].boost).toBeCloseTo(0.05, 5);
+  });
+
+  test("ramps linearly from 0.05 to 1.0 as event approaches", () => {
+    const now = new Date("2025-06-15T10:00:00Z");
+    const eventDate = now.getTime() + 7 * DAY_MS; // exactly at rampDays boundary
+    const trigger = makeTrigger({
+      type: "event",
+      eventDate,
+      rampDays: 7,
+      followUpDays: 2,
+    });
+
+    // At rampDays boundary: daysUntil = 7, rampDays = 7 → boost = 0.05
+    const resultsAtBoundary = evaluateEventTriggers([trigger], now);
+    expect(resultsAtBoundary[0].boost).toBeCloseTo(0.05, 5);
+
+    // Halfway through ramp: 3.5 days before event
+    const halfwayNow = new Date(now.getTime() + 3.5 * DAY_MS);
+    const resultsHalfway = evaluateEventTriggers([trigger], halfwayNow);
+    expect(resultsHalfway[0].boost).toBeCloseTo(0.525, 1);
+
+    // Day before: daysUntil ≈ 0 → boost ≈ 1.0
+    const dayBeforeNow = new Date(eventDate - 0.1 * DAY_MS);
+    const resultsDayBefore = evaluateEventTriggers([trigger], dayBeforeNow);
+    expect(resultsDayBefore[0].boost).toBeGreaterThan(0.9);
+  });
+
+  test("returns full boost (1.0) on the day of the event", () => {
+    const now = new Date("2025-06-15T10:00:00Z");
+    const eventDate = now.getTime(); // right now
+    const trigger = makeTrigger({
+      type: "event",
+      eventDate,
+      rampDays: 7,
+      followUpDays: 2,
+    });
+    // daysUntil = 0, which is > -1 → day-of boost = 1.0
+    const results = evaluateEventTriggers([trigger], now);
+    expect(results).toHaveLength(1);
+    expect(results[0].boost).toBe(1.0);
+  });
+
+  test("decays exponentially after the event", () => {
+    const eventDate = new Date("2025-06-15T10:00:00Z").getTime();
+    const trigger = makeTrigger({
+      type: "event",
+      eventDate,
+      rampDays: 7,
+      followUpDays: 2,
+    });
+
+    // 1.5 days after event
+    const afterNow = new Date(eventDate + 1.5 * DAY_MS);
+    const results = evaluateEventTriggers([trigger], afterNow);
+    expect(results).toHaveLength(1);
+    expect(results[0].boost).toBeGreaterThan(0.01);
+    expect(results[0].boost).toBeLessThan(1.0);
+  });
+
+  test("returns 0 after followUpDays", () => {
+    const eventDate = new Date("2025-06-15T10:00:00Z").getTime();
+    const trigger = makeTrigger({
+      type: "event",
+      eventDate,
+      rampDays: 7,
+      followUpDays: 2,
+    });
+
+    // 3 days after event (beyond followUpDays=2)
+    const longAfter = new Date(eventDate + 3 * DAY_MS);
+    const results = evaluateEventTriggers([trigger], longAfter);
+    expect(results).toHaveLength(0);
+  });
+
+  test("skips non-event triggers", () => {
+    const now = new Date("2025-06-15T10:00:00Z");
+    const trigger = makeTrigger({
+      type: "temporal",
+      eventDate: now.getTime() + DAY_MS,
+    });
+    const results = evaluateEventTriggers([trigger], now);
+    expect(results).toHaveLength(0);
+  });
+
+  test("skips triggers without eventDate", () => {
+    const now = new Date("2025-06-15T10:00:00Z");
+    const trigger = makeTrigger({
+      type: "event",
+      eventDate: null,
+    });
+    const results = evaluateEventTriggers([trigger], now);
+    expect(results).toHaveLength(0);
+  });
+
+  test("uses default rampDays=7 and followUpDays=2 when not specified", () => {
+    const now = new Date("2025-06-15T10:00:00Z");
+    const eventDate = now.getTime() + 5 * DAY_MS; // 5 days away (inside default 7-day ramp)
+    const trigger = makeTrigger({
+      type: "event",
+      eventDate,
+      rampDays: null, // triggers default of 7
+      followUpDays: null, // triggers default of 2
+    });
+    const results = evaluateEventTriggers([trigger], now);
+    expect(results).toHaveLength(1);
+    // Should be in the ramp-up phase with boost > background
+    expect(results[0].boost).toBeGreaterThan(0.05);
+  });
+});

package/src/memory/graph/triggers.ts

@@ -0,0 +1,223 @@
+// ---------------------------------------------------------------------------
+// Memory Graph — Trigger evaluation
+// ---------------------------------------------------------------------------
+
+import type { MemoryTrigger } from "./types.js";
+
+export interface TriggeredResult {
+  trigger: MemoryTrigger;
+  /** Relevance boost from this trigger (0–1). */
+  boost: number;
+}
+
+// ---------------------------------------------------------------------------
+// Temporal triggers — pure date math
+// ---------------------------------------------------------------------------
+
+/**
+ * Evaluate temporal triggers against the current time.
+ * Schedule patterns:
+ *   "day-of-week:monday"  → fires every Monday
+ *   "date:04-08"          → fires on April 8 every year
+ *   "time:morning"        → fires between 5 AM and 11 AM
+ *   "time:afternoon"      → fires between 12 PM and 5 PM
+ *   "time:evening"        → fires between 5 PM and 9 PM
+ *   "time:night"          → fires between 9 PM and 5 AM
+ */
+export function evaluateTemporalTriggers(
+  triggers: MemoryTrigger[],
+  now: Date,
+): TriggeredResult[] {
+  const results: TriggeredResult[] = [];
+  const dayNames = [
+    "sunday",
+    "monday",
+    "tuesday",
+    "wednesday",
+    "thursday",
+    "friday",
+    "saturday",
+  ];
+  const currentDay = dayNames[now.getDay()];
+  const currentMonth = String(now.getMonth() + 1).padStart(2, "0");
+  const currentDate = String(now.getDate()).padStart(2, "0");
+  const currentHour = now.getHours();
+  const dateStr = `${currentMonth}-${currentDate}`;
+
+  for (const trigger of triggers) {
+    if (trigger.type !== "temporal" || !trigger.schedule) continue;
+    if (!passesCooldown(trigger, now)) continue;
+
+    const schedule = trigger.schedule.toLowerCase();
+    let fired = false;
+
+    if (schedule.startsWith("day-of-week:")) {
+      const target = schedule.slice("day-of-week:".length).trim();
+      fired = currentDay === target;
+    } else if (schedule.startsWith("date:")) {
+      const target = schedule.slice("date:".length).trim();
+      fired = dateStr === target;
+    } else if (schedule.startsWith("time:")) {
+      const period = schedule.slice("time:".length).trim();
+      fired = matchesTimePeriod(period, currentHour);
+    }
+
+    if (fired) {
+      results.push({ trigger, boost: 1.0 });
+    }
+  }
+
+  return results;
+}
+
+function matchesTimePeriod(period: string, hour: number): boolean {
+  switch (period) {
+    case "morning":
+      return hour >= 5 && hour < 12;
+    case "afternoon":
+      return hour >= 12 && hour < 17;
+    case "evening":
+      return hour >= 17 && hour < 21;
+    case "night":
+      return hour >= 21 || hour < 5;
+    default:
+      return false;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Semantic triggers — cosine similarity against pre-computed embeddings
+// ---------------------------------------------------------------------------
+
+/**
+ * Evaluate semantic triggers by computing cosine similarity between
+ * the current conversational context embedding and each trigger's
+ * pre-computed condition embedding.
+ *
+ * Fast: ~5ms for 50 triggers (just vector math, no LLM).
+ */
+export function evaluateSemanticTriggers(
+  triggers: MemoryTrigger[],
+  queryEmbedding: number[] | Float32Array,
+): TriggeredResult[] {
+  const results: TriggeredResult[] = [];
+
+  for (const trigger of triggers) {
+    if (trigger.type !== "semantic") continue;
+    if (!trigger.conditionEmbedding || trigger.threshold == null) continue;
+    if (trigger.consumed) continue;
+    if (!passesCooldown(trigger, new Date())) continue;
+
+    const similarity = cosineSimilarity(
+      queryEmbedding,
+      trigger.conditionEmbedding,
+    );
+    if (similarity >= trigger.threshold) {
+      // Scale boost by how far above threshold (0 at threshold, 1 at similarity=1)
+      const boost = Math.min(
+        1.0,
+        (similarity - trigger.threshold) / (1 - trigger.threshold + 0.001),
+      );
+      results.push({ trigger, boost: Math.max(0.5, boost) });
+    }
+  }
+
+  return results;
+}
+
+/**
+ * Cosine similarity between two vectors. Returns value in [-1, 1].
+ */
+function cosineSimilarity(
+  a: number[] | Float32Array,
+  b: number[] | Float32Array,
+): number {
+  if (a.length !== b.length) return 0;
+  let dot = 0;
+  let normA = 0;
+  let normB = 0;
+  for (let i = 0; i < a.length; i++) {
+    dot += a[i] * b[i];
+    normA += a[i] * a[i];
+    normB += b[i] * b[i];
+  }
+  const denom = Math.sqrt(normA) * Math.sqrt(normB);
+  return denom === 0 ? 0 : dot / denom;
+}
+
+// ---------------------------------------------------------------------------
+// Event triggers — ramp function for future events
+// ---------------------------------------------------------------------------
+
+/**
+ * Evaluate event triggers with a relevance ramp:
+ *
+ *   announced → low bg (0.05) → ramping (linear 0.05→1.0) → day-of (1.0)
+ *   → decay (exponential) → 0
+ */
+export function evaluateEventTriggers(
+  triggers: MemoryTrigger[],
+  now: Date,
+): TriggeredResult[] {
+  const results: TriggeredResult[] = [];
+  const nowMs = now.getTime();
+
+  for (const trigger of triggers) {
+    if (trigger.type !== "event" || trigger.eventDate == null) continue;
+
+    const boost = computeEventRelevance(
+      trigger.eventDate,
+      trigger.rampDays ?? 7,
+      trigger.followUpDays ?? 2,
+      nowMs,
+    );
+
+    if (boost > 0.01) {
+      results.push({ trigger, boost });
+    }
+  }
+
+  return results;
+}
+
+/**
+ * Compute the relevance boost for an event at the current time.
+ */
+function computeEventRelevance(
+  eventDateMs: number,
+  rampDays: number,
+  followUpDays: number,
+  nowMs: number,
+): number {
+  const msPerDay = 1000 * 60 * 60 * 24;
+  const daysUntil = (eventDateMs - nowMs) / msPerDay;
+
+  if (daysUntil > rampDays) {
+    // Background awareness — the event exists and is coming
+    return 0.05;
+  }
+  if (daysUntil > 0) {
+    // Linear ramp from 0.05 to 1.0 over the ramp period
+    return 0.05 + 0.95 * (1 - daysUntil / rampDays);
+  }
+  if (daysUntil > -1) {
+    // Day-of: full boost
+    return 1.0;
+  }
+  if (-daysUntil <= followUpDays) {
+    // Rapid exponential decay after the event
+    return Math.exp(-(-daysUntil - 1));
+  }
+  // Event is over
+  return 0;
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function passesCooldown(trigger: MemoryTrigger, now: Date): boolean {
+  if (!trigger.recurring) return true;
+  if (!trigger.lastFired || !trigger.cooldownMs) return true;
+  return now.getTime() - trigger.lastFired >= trigger.cooldownMs;
+}