@adaptic/maestro 1.0.0

package/scripts/daemon/test-context-compiler.mjs

@@ -0,0 +1,238 @@
+#!/usr/bin/env node
+/**
+ * test-context-compiler.mjs — Tests for context-compiler.mjs
+ *
+ * Uses node:test and node:assert/strict.
+ * Test directory: .test-context-compiler via process.env.__TEST_SOPHIE_DIR
+ */
+
+import { describe, it, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, writeFileSync, rmSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+
+// ── Set up test environment BEFORE importing the module ────────────
+
+const TEST_DIR = join(tmpdir(), ".test-context-compiler-" + process.pid);
+process.env.__TEST_SOPHIE_DIR = TEST_DIR;
+process.env.__TEST_SESSION_DIR = join(TEST_DIR, "state", "sessions");
+
+// Dynamic import AFTER env vars are set (ESM module caching is fine)
+const { compileContext } = await import("./context-compiler.mjs");
+
+// ── Test fixtures ──────────────────────────────────────────────────
+
+const BARRIERS_YAML = `domains:
+  adaptic-internal-legal:
+    description: "Adaptic's own legal strategy, GC advice, privilege-protected"
+    default_sensitivity: high
+  rollup-strategy:
+    description: "Project Aether M&A targets, deal terms, pipeline"
+    default_sensitivity: critical
+  ftlab-operations:
+    description: "FTLab JV operational matters shared domain"
+    default_sensitivity: low
+  public:
+    description: "Published information, press, website no restrictions"
+    default_sensitivity: none
+`;
+
+function setupTestDir() {
+  // Create directory structure
+  mkdirSync(join(TEST_DIR, "memory", "profiles", "users"), { recursive: true });
+  mkdirSync(join(TEST_DIR, "memory", "interactions", "slack", "dm-alice-smith"), { recursive: true });
+  mkdirSync(join(TEST_DIR, "memory", "interactions", "slack", "D001TESTCH"), { recursive: true });
+  mkdirSync(join(TEST_DIR, "policies"), { recursive: true });
+  mkdirSync(join(TEST_DIR, "state", "sessions"), { recursive: true });
+
+  // Write barriers policy
+  writeFileSync(join(TEST_DIR, "policies", "information-barriers.yaml"), BARRIERS_YAML);
+
+  // Write empty active.json
+  writeFileSync(join(TEST_DIR, "state", "sessions", "active.json"), "{}");
+}
+
+function teardownTestDir() {
+  try {
+    rmSync(TEST_DIR, { recursive: true, force: true });
+  } catch { /* ignore */ }
+}
+
+// ── Tests ──────────────────────────────────────────────────────────
+
+describe("context-compiler", () => {
+  beforeEach(() => {
+    setupTestDir();
+  });
+
+  afterEach(() => {
+    teardownTestDir();
+  });
+
+  // 1. Token budget adapts to priority
+  it("token budget adapts to priority", async () => {
+    const item = { sender: "alice-smith", channel_id: "D001TESTCH" };
+
+    const critical = await compileContext(item, { priority: "critical" });
+    assert.ok(critical.tokenBudget >= 12000, `critical budget should be >= 12000, got ${critical.tokenBudget}`);
+
+    const normal = await compileContext(item, { priority: "normal" });
+    assert.ok(normal.tokenBudget >= 8000 && normal.tokenBudget < 12000,
+      `normal budget should be 8000-11999, got ${normal.tokenBudget}`);
+
+    const low = await compileContext(item, { priority: "low" });
+    assert.ok(low.tokenBudget >= 4000 && low.tokenBudget < 8000,
+      `low budget should be 4000-7999, got ${low.tokenBudget}`);
+  });
+
+  // 2. Includes sender profile when available
+  it("includes sender profile when available", async () => {
+    const profileYaml = `name: Alice Smith
+slug: alice-smith
+role: Partner
+privilege_level: partner
+`;
+    writeFileSync(join(TEST_DIR, "memory", "profiles", "users", "alice-smith.yaml"), profileYaml);
+
+    const item = { sender: "alice-smith", channel_id: "D001TESTCH" };
+    const result = await compileContext(item, { priority: "normal" });
+
+    assert.ok(result.contextBlock.includes("Sender Profile"), "should include Sender Profile header");
+    assert.ok(result.contextBlock.includes("Alice Smith"), "should include the sender name");
+  });
+
+  // 3. Produces minimal block when no profile exists
+  it("produces minimal block when no profile exists", async () => {
+    const item = { sender: "unknown-person", channel_id: "D001TESTCH" };
+    const result = await compileContext(item, { priority: "normal" });
+
+    assert.ok(result.contextBlock.includes("--- COMPILED CONTEXT"), "should include COMPILED CONTEXT marker");
+    assert.ok(result.contextBlock.includes("--- END CONTEXT ---"), "should include END CONTEXT marker");
+    // Should not crash — that's the main test
+    assert.ok(result.tokenBudget > 0, "should have a positive token budget");
+  });
+
+  // 4. Filters history by disclosure boundaries
+  it("filters history by disclosure boundaries", async () => {
+    // Profile with excluded_domains
+    const profileYaml = `name: Alice Smith
+slug: alice-smith
+role: Partner
+privilege_level: partner
+information_boundaries:
+  excluded_domains:
+    - rollup-strategy
+    - adaptic-internal-legal
+`;
+    writeFileSync(join(TEST_DIR, "memory", "profiles", "users", "alice-smith.yaml"), profileYaml);
+
+    // History entries — 4 messages
+    const history = [
+      JSON.stringify({ ts: "1001", from: "sophie", content: "FTLab project update: everything on track for Q2 delivery", received_at: "2026-04-06T10:00:00Z" }),
+      JSON.stringify({ ts: "1002", from: "mehran", content: "Project Aether acquisition target list needs review of deal terms and pipeline", received_at: "2026-04-06T10:01:00Z" }),
+      JSON.stringify({ ts: "1003", from: "sophie", content: "FTLab operations dashboard is looking good this week", received_at: "2026-04-06T10:02:00Z" }),
+      JSON.stringify({ ts: "1004", from: "nima", content: "GC advice on legal strategy is privileged under Adaptic internal counsel", received_at: "2026-04-06T10:03:00Z" }),
+    ].join("\n");
+
+    writeFileSync(join(TEST_DIR, "memory", "interactions", "slack", "dm-alice-smith", "2026-04-06.jsonl"), history);
+
+    const item = { sender: "alice-smith", channel_id: "D001TESTCH" };
+    const result = await compileContext(item, { priority: "normal" });
+
+    // Safe entries should be included
+    assert.ok(result.contextBlock.includes("FTLab project update"), "should include safe FTLab project entry");
+    assert.ok(result.contextBlock.includes("FTLab operations dashboard"), "should include safe FTLab operations entry");
+
+    // Forbidden entries should be excluded
+    assert.ok(!result.contextBlock.includes("Aether acquisition target"), "should NOT include rollup-strategy content");
+    assert.ok(!result.contextBlock.includes("legal strategy is privileged"), "should NOT include legal content");
+  });
+
+  // 5. Includes disclosure boundaries block with restrictions
+  it("includes disclosure boundaries block with restrictions", async () => {
+    const profileYaml = `name: Alice Smith
+slug: alice-smith
+role: Partner
+privilege_level: partner
+information_boundaries:
+  excluded_domains:
+    - rollup-strategy
+`;
+    writeFileSync(join(TEST_DIR, "memory", "profiles", "users", "alice-smith.yaml"), profileYaml);
+
+    const item = { sender: "alice-smith", channel_id: "D001TESTCH" };
+    const result = await compileContext(item, { priority: "normal" });
+
+    assert.ok(result.contextBlock.includes("Disclosure Boundaries"), "should include Disclosure Boundaries header");
+    assert.ok(result.contextBlock.includes("DO NOT mention"), "should include DO NOT mention instruction");
+  });
+
+  // 6. Includes active sessions when present
+  it("includes active sessions when present", async () => {
+    const activeSessions = {
+      "sess-001": {
+        sessionId: "sess-001",
+        summary: "Processing hiring pipeline review",
+        model: "sonnet",
+        sender: "mehran-granfar",
+        startTime: new Date().toISOString(),
+      },
+    };
+    writeFileSync(join(TEST_DIR, "state", "sessions", "active.json"), JSON.stringify(activeSessions));
+
+    const item = { sender: "alice-smith", channel_id: "D001TESTCH" };
+    const result = await compileContext(item, { priority: "normal" });
+
+    assert.ok(result.contextBlock.includes("Active Sessions"), "should include Active Sessions header");
+    assert.ok(result.contextBlock.includes("Processing hiring pipeline review"), "should include session summary");
+  });
+
+  // 7. Includes sent-registry entries for same channel
+  it("includes sent-registry entries for same channel", async () => {
+    const registryEntry = JSON.stringify({
+      timestamp: "2026-04-06T09:00:00Z",
+      channelId: "D001TESTCH",
+      type: "reply",
+      preview: "I'll get back to you on the hiring update shortly",
+    });
+    writeFileSync(join(TEST_DIR, "state", "sessions", "sent-registry.jsonl"), registryEntry + "\n");
+
+    const item = { sender: "alice-smith", channel_id: "D001TESTCH" };
+    const result = await compileContext(item, { priority: "normal" });
+
+    assert.ok(result.contextBlock.includes("Already Sent"), "should include Already Sent header");
+    assert.ok(result.contextBlock.includes("hiring update shortly"), "should include sent message preview");
+  });
+
+  // 8. CEO gets all domains — no filtering
+  it("CEO gets all domains — no filtering", async () => {
+    const profileYaml = `name: Mehran Granfar
+slug: mehran-granfar
+role: CEO
+privilege_level: ceo
+`;
+    writeFileSync(join(TEST_DIR, "memory", "profiles", "users", "mehran-granfar.yaml"), profileYaml);
+
+    // History with rollup and legal content
+    const history = [
+      JSON.stringify({ ts: "2001", from: "sophie", content: "Project Aether acquisition target list has nine deal terms in the pipeline", received_at: "2026-04-06T10:00:00Z" }),
+      JSON.stringify({ ts: "2002", from: "nima", content: "GC advice on legal strategy is privileged under internal counsel review", received_at: "2026-04-06T10:01:00Z" }),
+      JSON.stringify({ ts: "2003", from: "sophie", content: "FTLab operations are on track", received_at: "2026-04-06T10:02:00Z" }),
+    ].join("\n");
+
+    mkdirSync(join(TEST_DIR, "memory", "interactions", "slack", "dm-mehran-granfar"), { recursive: true });
+    writeFileSync(join(TEST_DIR, "memory", "interactions", "slack", "dm-mehran-granfar", "2026-04-06.jsonl"), history);
+
+    const item = { sender: "mehran-granfar", channel_id: "D001TESTCH" };
+    const result = await compileContext(item, { priority: "critical" });
+
+    // ALL content should appear for CEO
+    assert.ok(result.contextBlock.includes("Aether acquisition target"), "CEO should see rollup-strategy content");
+    assert.ok(result.contextBlock.includes("legal strategy is privileged"), "CEO should see legal content");
+    assert.ok(result.contextBlock.includes("FTLab operations"), "CEO should see FTLab content");
+
+    // No disclosure boundaries block for CEO
+    assert.ok(!result.contextBlock.includes("DO NOT mention"), "CEO should NOT see DO NOT mention block");
+  });
+});

package/scripts/daemon/test-integration.mjs

@@ -0,0 +1,130 @@
+#!/usr/bin/env node
+/**
+ * test-integration.mjs — End-to-end integration tests for session lock + context compiler pipeline
+ */
+
+import { describe, it, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, rmSync, writeFileSync, readFileSync, existsSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const TEST_DIR = join(__dirname, "../../.test-integration");
+
+// Set env BEFORE importing modules
+process.env.__TEST_SESSION_DIR = join(TEST_DIR, "state", "sessions");
+process.env.__TEST_SOPHIE_DIR = TEST_DIR;
+
+function setupTestEnv() {
+  mkdirSync(join(TEST_DIR, "state", "sessions", "locks"), { recursive: true });
+  mkdirSync(join(TEST_DIR, "memory", "profiles", "users"), { recursive: true });
+  mkdirSync(join(TEST_DIR, "memory", "interactions", "slack", "dm-test-user"), { recursive: true });
+  mkdirSync(join(TEST_DIR, "policies"), { recursive: true });
+  writeFileSync(join(TEST_DIR, "state", "sessions", "active.json"), "{}");
+
+  writeFileSync(join(TEST_DIR, "policies", "information-barriers.yaml"), `domains:
+  adaptic-internal-legal:
+    description: "Adaptic legal strategy, GC advice, privilege-protected"
+    default_sensitivity: high
+  rollup-strategy:
+    description: "Project Aether M&A targets, deal terms, pipeline"
+    default_sensitivity: critical
+  public:
+    description: "Published information, press, website"
+    default_sensitivity: none
+`);
+}
+
+function cleanTestEnv() {
+  rmSync(TEST_DIR, { recursive: true, force: true });
+}
+
+const { acquireLock, releaseLock, registerSent, checkRecentlySent } = await import("./session-lock.mjs");
+const { compileContext } = await import("./context-compiler.mjs");
+
+// ─── Integration tests ─────────────────────────────────────────────────
+
+describe("Integration: lock → compile → prompt pipeline", () => {
+  beforeEach(setupTestEnv);
+  afterEach(cleanTestEnv);
+
+  it("acquireLock prevents duplicate processing of same item", () => {
+    const first = acquireLock("slack-C001-12345", { sender: "Test", channel: "C001" });
+    assert.equal(first.acquired, true);
+
+    const second = acquireLock("slack-C001-12345", { sender: "Test", channel: "C001" });
+    assert.equal(second.acquired, false);
+
+    releaseLock("slack-C001-12345");
+  });
+
+  it("sent-registry prevents duplicate sends across quick-reply and holding paths", () => {
+    // Holding message sent
+    registerSent("C001", "12345.6789", "holding", "s-1", "Looking into this now");
+
+    // Quick reply to same channel+thread should still be allowed (different type)
+    const quickCheck = checkRecentlySent("C001", "12345.6789", "quick_reply");
+    assert.equal(quickCheck.allowed, true);
+
+    // Another holding to same channel+thread should be blocked
+    const holdCheck = checkRecentlySent("C001", "12345.6789", "holding");
+    assert.equal(holdCheck.allowed, false);
+  });
+
+  it("context compiler respects disclosure boundaries end-to-end", async () => {
+    // Create a profile with restrictions
+    writeFileSync(
+      join(TEST_DIR, "memory", "profiles", "users", "test-user.yaml"),
+      `name: Test User\ninformation_boundaries:\n  excluded_domains:\n    - rollup-strategy\n`
+    );
+
+    // Create history with mixed content
+    const today = new Date().toISOString().split("T")[0];
+    writeFileSync(
+      join(TEST_DIR, "memory", "interactions", "slack", "dm-test-user", `${today}.jsonl`),
+      [
+        JSON.stringify({ ts: "100", from: "test-user", content: "What is the status?", received_at: "2026-04-06T10:00:00Z" }),
+        JSON.stringify({ ts: "101", from: "sophie", content: "Project Aether deal terms are looking good", received_at: "2026-04-06T10:01:00Z" }),
+        JSON.stringify({ ts: "102", from: "sophie", content: "The public website update is live", received_at: "2026-04-06T10:02:00Z" }),
+      ].join("\n") + "\n"
+    );
+
+    const { contextBlock } = await compileContext(
+      { sender: "Test User", channel: "D001", channel_id: "D001" },
+      { priority: "normal", model: "sonnet", action: "respond" },
+      {}
+    );
+
+    // Public content should be included
+    assert.ok(contextBlock.includes("website update is live"));
+    // Rollup content should be filtered
+    assert.ok(!contextBlock.includes("Aether deal terms"));
+    // Should have disclosure boundaries
+    assert.ok(contextBlock.includes("DO NOT mention"));
+  });
+
+  it("active sessions are visible in compiled context", async () => {
+    writeFileSync(
+      join(TEST_DIR, "state", "sessions", "active.json"),
+      JSON.stringify({
+        "s-999": {
+          sender: "Alice",
+          channel: "C002",
+          summary: "Preparing board pack",
+          model: "opus",
+          startTime: Date.now() - 120000,
+        },
+      })
+    );
+
+    const { contextBlock } = await compileContext(
+      { sender: "Test", channel: "C001" },
+      { priority: "normal", model: "sonnet", action: "respond" },
+      {}
+    );
+
+    assert.ok(contextBlock.includes("Preparing board pack"));
+    assert.ok(contextBlock.includes("Active Sessions"));
+  });
+});

package/scripts/daemon/test-session-lock.mjs

@@ -0,0 +1,215 @@
+#!/usr/bin/env node
+/**
+ * test-session-lock.mjs — Tests for file-based session locks and sent-message registry
+ */
+
+import { describe, it, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, rmSync, existsSync, readFileSync, writeFileSync, unlinkSync } from "fs";
+import { join } from "path";
+
+// Tests use a temporary directory to avoid polluting real state
+const TEST_DIR = join(import.meta.dirname, "../../.test-session-locks");
+const LOCKS_DIR = join(TEST_DIR, "locks");
+const REGISTRY_PATH = join(TEST_DIR, "sent-registry.jsonl");
+
+// We'll set these env vars so the module uses our test paths
+process.env.__TEST_SESSION_DIR = TEST_DIR;
+
+const {
+  sanitiseItemId,
+  acquireLock,
+  releaseLock,
+  updateLock,
+  readLock,
+  scanStaleLocks,
+  checkRecentlySent,
+  registerSent,
+} = await import("./session-lock.mjs");
+
+// ─── sanitiseItemId ─────────────────────────────────────────────
+
+describe("sanitiseItemId", () => {
+  it("replaces colons and dots with hyphens", () => {
+    assert.equal(
+      sanitiseItemId("slack:D099N1JGKRQ:1775331885.690669"),
+      "slack-D099N1JGKRQ-1775331885-690669"
+    );
+  });
+
+  it("handles simple alphanumeric IDs unchanged", () => {
+    assert.equal(sanitiseItemId("abc123"), "abc123");
+  });
+
+  it("replaces spaces and special chars", () => {
+    assert.equal(sanitiseItemId("foo bar/baz@qux"), "foo-bar-baz-qux");
+  });
+});
+
+// ─── acquireLock / releaseLock / readLock ────────────────────────
+
+describe("acquireLock / releaseLock / readLock", () => {
+  beforeEach(() => {
+    mkdirSync(LOCKS_DIR, { recursive: true });
+  });
+
+  afterEach(() => {
+    rmSync(TEST_DIR, { recursive: true, force: true });
+  });
+
+  it("acquires a lock on first call", () => {
+    const result = acquireLock("test-item-1", { sender: "Alice", channel: "C001" });
+    assert.equal(result.acquired, true);
+    assert.equal(existsSync(join(LOCKS_DIR, "test-item-1.lock")), true);
+  });
+
+  it("rejects second acquire for same item", () => {
+    acquireLock("test-item-2", { sender: "Alice", channel: "C001" });
+    const result = acquireLock("test-item-2", { sender: "Bob", channel: "C002" });
+    assert.equal(result.acquired, false);
+    assert.ok(result.existing);
+    assert.equal(result.existing.sender, "Alice");
+  });
+
+  it("allows acquire after release", () => {
+    acquireLock("test-item-3", { sender: "Alice", channel: "C001" });
+    releaseLock("test-item-3");
+    const result = acquireLock("test-item-3", { sender: "Bob", channel: "C002" });
+    assert.equal(result.acquired, true);
+  });
+
+  it("readLock returns lock data when locked", () => {
+    acquireLock("test-item-4", { sender: "Alice", channel: "C001" });
+    const data = readLock("test-item-4");
+    assert.equal(data.sender, "Alice");
+    assert.equal(data.channel, "C001");
+    assert.equal(data.holdingSent, false);
+    assert.equal(data.substantiveSent, false);
+  });
+
+  it("readLock returns null when no lock", () => {
+    const data = readLock("nonexistent-item");
+    assert.equal(data, null);
+  });
+
+  it("overwrites stale lock (>15 min old)", () => {
+    // Write a lock with an old timestamp
+    const lockPath = join(LOCKS_DIR, "test-item-5.lock");
+    mkdirSync(LOCKS_DIR, { recursive: true });
+    const staleLock = {
+      sessionId: "old-session",
+      itemId: "test-item-5",
+      sender: "Alice",
+      channel: "C001",
+      acquiredAt: new Date(Date.now() - 20 * 60 * 1000).toISOString(),
+      holdingSent: false,
+      substantiveSent: false,
+    };
+    writeFileSync(lockPath, JSON.stringify(staleLock));
+
+    const result = acquireLock("test-item-5", { sender: "Bob", channel: "C002" });
+    assert.equal(result.acquired, true);
+    const data = readLock("test-item-5");
+    assert.equal(data.sender, "Bob");
+  });
+});
+
+// ─── updateLock ─────────────────────────────────────────────────
+
+describe("updateLock", () => {
+  beforeEach(() => {
+    mkdirSync(LOCKS_DIR, { recursive: true });
+  });
+
+  afterEach(() => {
+    rmSync(TEST_DIR, { recursive: true, force: true });
+  });
+
+  it("updates holdingSent flag on existing lock", () => {
+    acquireLock("test-item-6", { sender: "Alice", channel: "C001" });
+    updateLock("test-item-6", { holdingSent: true });
+    const data = readLock("test-item-6");
+    assert.equal(data.holdingSent, true);
+    assert.equal(data.substantiveSent, false);
+  });
+
+  it("no-ops when lock does not exist", () => {
+    // Should not throw
+    updateLock("nonexistent", { holdingSent: true });
+  });
+});
+
+// ─── scanStaleLocks ─────────────────────────────────────────────
+
+describe("scanStaleLocks", () => {
+  beforeEach(() => {
+    mkdirSync(LOCKS_DIR, { recursive: true });
+  });
+
+  afterEach(() => {
+    rmSync(TEST_DIR, { recursive: true, force: true });
+  });
+
+  it("clears stale locks and leaves fresh ones", () => {
+    // Fresh lock
+    acquireLock("fresh-item", { sender: "Alice", channel: "C001" });
+
+    // Stale lock (manually written with old timestamp)
+    const stalePath = join(LOCKS_DIR, "stale-item.lock");
+    writeFileSync(stalePath, JSON.stringify({
+      sessionId: "old", itemId: "stale-item", sender: "Bob", channel: "C002",
+      acquiredAt: new Date(Date.now() - 20 * 60 * 1000).toISOString(),
+      holdingSent: false, substantiveSent: false,
+    }));
+
+    const cleared = scanStaleLocks();
+    assert.equal(cleared, 1);
+    assert.equal(existsSync(join(LOCKS_DIR, "fresh-item.lock")), true);
+    assert.equal(existsSync(stalePath), false);
+  });
+});
+
+// ─── sent-message registry ──────────────────────────────────────
+
+describe("sent-message registry", () => {
+  beforeEach(() => {
+    mkdirSync(TEST_DIR, { recursive: true });
+    // Ensure clean registry
+    try { unlinkSync(REGISTRY_PATH); } catch {}
+  });
+
+  afterEach(() => {
+    rmSync(TEST_DIR, { recursive: true, force: true });
+  });
+
+  it("allows first send to a channel", () => {
+    const result = checkRecentlySent("C001", "1234.5678", "holding");
+    assert.equal(result.allowed, true);
+  });
+
+  it("blocks duplicate send to same channel+thread+type within window", () => {
+    registerSent("C001", "1234.5678", "holding", "s-1", "Got it");
+    const result = checkRecentlySent("C001", "1234.5678", "holding");
+    assert.equal(result.allowed, false);
+    assert.ok(result.reason.includes("duplicate"));
+  });
+
+  it("allows different type to same channel+thread", () => {
+    registerSent("C001", "1234.5678", "holding", "s-1", "Got it");
+    const result = checkRecentlySent("C001", "1234.5678", "substantive");
+    assert.equal(result.allowed, true);
+  });
+
+  it("allows same type to different channel", () => {
+    registerSent("C001", "1234.5678", "holding", "s-1", "Got it");
+    const result = checkRecentlySent("C002", "1234.5678", "holding");
+    assert.equal(result.allowed, true);
+  });
+
+  it("blocks rapid substantive sends to same channel even with different threads", () => {
+    registerSent("C001", "1111.0000", "substantive", "s-1", "Here is the answer");
+    const result = checkRecentlySent("C001", "2222.0000", "substantive");
+    assert.equal(result.allowed, false);
+    assert.ok(result.reason.includes("rapid"));
+  });
+});