@vellumai/assistant 0.8.11 → 0.8.12-staging.2

package/src/__tests__/config-loader-quarantine-bulletin.test.ts

@@ -1,202 +0,0 @@
-/**
- * When loadConfig()/loadRawConfig() quarantines a corrupt config.json, it
- * appends a bulletin to <workspace>/UPDATES.md so the background update-
- * bulletin job picks up the event inside a background-only conversation.
- * The agent decides whether to surface the quarantine to the user — it's
- * agent-visible context, not a push notification.
- *
- * The bulletin is keyed on the quarantine filename via an HTML marker so
- * repeated appends for the same quarantine are idempotent — per the
- * Release-Update-Hygiene rule in the root AGENTS.md, idempotency at both the
- * runner level AND an in-file marker is required to close the crash-mid-append
- * window.
- */
-
-import {
-  existsSync,
-  mkdirSync,
-  readdirSync,
-  readFileSync,
-  rmSync,
-  writeFileSync,
-} from "node:fs";
-import { basename, join } from "node:path";
-import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-
-import {
-  _appendQuarantineBulletin,
-  invalidateConfigCache,
-  loadConfig,
-} from "../config/loader.js";
-import { setStorePathForTesting } from "./encrypted-store-test-helpers.js";
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-const WORKSPACE_DIR = process.env.VELLUM_WORKSPACE_DIR!;
-const CONFIG_PATH = join(WORKSPACE_DIR, "config.json");
-const UPDATES_PATH = join(WORKSPACE_DIR, "UPDATES.md");
-
-function ensureTestDir(): void {
-  const dirs = [
-    WORKSPACE_DIR,
-    join(WORKSPACE_DIR, "data"),
-    join(WORKSPACE_DIR, "data", "memory"),
-    join(WORKSPACE_DIR, "data", "memory", "knowledge"),
-    join(WORKSPACE_DIR, "data", "logs"),
-  ];
-  for (const dir of dirs) {
-    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
-  }
-}
-
-function resetWorkspace(): void {
-  for (const name of readdirSync(WORKSPACE_DIR)) {
-    rmSync(join(WORKSPACE_DIR, name), { recursive: true, force: true });
-  }
-  ensureTestDir();
-}
-
-function listQuarantinedFiles(): string[] {
-  return readdirSync(WORKSPACE_DIR).filter((name) =>
-    /^config\.json\.corrupt-.+\.json$/.test(name),
-  );
-}
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-describe("config-quarantine UPDATES.md bulletin", () => {
-  beforeEach(() => {
-    resetWorkspace();
-    setStorePathForTesting(join(WORKSPACE_DIR, "keys.enc"));
-    invalidateConfigCache();
-  });
-
-  afterEach(() => {
-    setStorePathForTesting(null);
-    invalidateConfigCache();
-  });
-
-  test("writes a bulletin with the quarantine marker when config.json is corrupt", () => {
-    writeFileSync(CONFIG_PATH, '{"provider": "anthropic", "mo');
-
-    loadConfig();
-
-    const [quarantinedName] = listQuarantinedFiles();
-    expect(quarantinedName).toBeDefined();
-    const quarantinedPath = join(WORKSPACE_DIR, quarantinedName);
-
-    expect(existsSync(UPDATES_PATH)).toBe(true);
-    const body = readFileSync(UPDATES_PATH, "utf-8");
-
-    // Heading must match the wording the background update-bulletin job
-    // relays to the user.
-    expect(body).toContain("## Config was reset to defaults");
-    // Quarantine file path is what the user cats to recover.
-    expect(body).toContain(quarantinedPath);
-    // Idempotency marker is shape-exact, basename-keyed (not full path).
-    expect(body).toContain(`<!-- config-quarantine:${quarantinedName} -->`);
-    expect(body).toMatch(
-      /<!-- config-quarantine:config\.json\.corrupt-.+\.json -->/,
-    );
-  });
-
-  test("two successive quarantines append two distinct bulletins (not overwrite)", () => {
-    // First corruption round.
-    writeFileSync(CONFIG_PATH, '{"partial": ');
-    loadConfig();
-    invalidateConfigCache();
-
-    const firstQuarantined = listQuarantinedFiles();
-    expect(firstQuarantined).toHaveLength(1);
-    const firstBody = readFileSync(UPDATES_PATH, "utf-8");
-    const firstMarker = `<!-- config-quarantine:${firstQuarantined[0]} -->`;
-    expect(firstBody).toContain(firstMarker);
-
-    // Loader wrote a fresh default config.json after quarantine; corrupt it
-    // again. Sleep briefly to guarantee a different ISO-timestamp millisecond
-    // component and therefore a distinct quarantine filename.
-    const untilDifferentMs = Date.now() + 5;
-    while (Date.now() < untilDifferentMs) {
-      /* spin */
-    }
-    writeFileSync(CONFIG_PATH, "still not json");
-    loadConfig();
-
-    const quarantined = listQuarantinedFiles().sort();
-    expect(quarantined).toHaveLength(2);
-
-    const body = readFileSync(UPDATES_PATH, "utf-8");
-    for (const name of quarantined) {
-      expect(body).toContain(`<!-- config-quarantine:${name} -->`);
-    }
-    // Two "Config was reset to defaults" sections — appended, not overwritten.
-    const headingMatches = body.match(/## Config was reset to defaults/g) ?? [];
-    expect(headingMatches).toHaveLength(2);
-    // The earlier marker is still present (append semantics).
-    expect(body).toContain(firstMarker);
-  });
-
-  test("idempotent: pre-existing marker for the same quarantine filename skips the append", () => {
-    // Simulate a crash-mid-append: UPDATES.md already contains a marker for
-    // a specific quarantine filename. A follow-up call referencing the same
-    // filename must leave the file untouched.
-    const quarantineName = "config.json.corrupt-2026-04-20T12-00-00.000Z.json";
-    const quarantinePath = join(WORKSPACE_DIR, quarantineName);
-    const preexisting =
-      `## Config was reset to defaults\n\n` +
-      `Pre-existing bulletin for ${quarantinePath}.\n\n` +
-      `<!-- config-quarantine:${quarantineName} -->\n`;
-    writeFileSync(UPDATES_PATH, preexisting, "utf-8");
-    // Also create the quarantine file on disk so the helper sees an
-    // environment consistent with a prior successful rename.
-    writeFileSync(quarantinePath, "{ not json", "utf-8");
-
-    _appendQuarantineBulletin(CONFIG_PATH, quarantinePath);
-
-    const after = readFileSync(UPDATES_PATH, "utf-8");
-    expect(after).toBe(preexisting);
-    // Exactly one marker present — no duplicate was appended.
-    expect(
-      after.match(
-        new RegExp(`<!-- config-quarantine:${quarantineName} -->`, "g"),
-      )?.length,
-    ).toBe(1);
-    expect(basename(quarantinePath)).toBe(quarantineName);
-  });
-
-  test("valid config.json does not create UPDATES.md (regression guard)", () => {
-    writeFileSync(
-      CONFIG_PATH,
-      JSON.stringify({ provider: "anthropic", model: "claude-opus-4-7" }),
-    );
-
-    loadConfig();
-
-    expect(listQuarantinedFiles()).toHaveLength(0);
-    expect(existsSync(UPDATES_PATH)).toBe(false);
-  });
-
-  test("appends (does not overwrite) when UPDATES.md already has unrelated content", () => {
-    const priorContent =
-      `## Some earlier bulletin\n\n` +
-      `Unrelated prior content from a previous migration.\n\n` +
-      `<!-- release-note-id:unrelated-note -->\n`;
-    writeFileSync(UPDATES_PATH, priorContent, "utf-8");
-
-    writeFileSync(CONFIG_PATH, "{oops");
-    loadConfig();
-
-    const body = readFileSync(UPDATES_PATH, "utf-8");
-    // Prior content preserved verbatim at the start.
-    expect(body.startsWith(priorContent)).toBe(true);
-    // New bulletin appended.
-    expect(body).toContain("## Config was reset to defaults");
-    expect(body).toMatch(
-      /<!-- config-quarantine:config\.json\.corrupt-.+\.json -->/,
-    );
-  });
-});

package/src/__tests__/conversation-starters-cadence.test.ts

@@ -1,161 +0,0 @@
-import { beforeEach, describe, expect, mock, test } from "bun:test";
-
-import { v4 as uuid } from "uuid";
-
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
-
-import { maybeEnqueueConversationStartersJob } from "../memory/conversation-starters-cadence.js";
-import { getSqlite } from "../memory/db-connection.js";
-import { initializeDb } from "../memory/db-init.js";
-initializeDb();
-
-function clearTables() {
-  getSqlite().run("DELETE FROM memory_graph_nodes");
-  getSqlite().run("DELETE FROM memory_jobs");
-  getSqlite().run("DELETE FROM memory_checkpoints");
-}
-
-function insertMemoryNode(scopeId = "default") {
-  const now = Date.now();
-  getSqlite().run(
-    `INSERT INTO memory_graph_nodes (
-      id, content, type, created, last_accessed, last_consolidated,
-      emotional_charge, fidelity, confidence, significance,
-      stability, reinforcement_count, last_reinforced,
-      source_conversations, source_type, scope_id
-    ) VALUES (?, ?, ?, ?, ?, ?, ?, 'vivid', 0.8, 0.5, 14, 0, ?, '[]', 'inferred', ?)`,
-    [
-      uuid(),
-      "test statement",
-      "semantic",
-      now,
-      now,
-      now,
-      '{"valence":0,"intensity":0.1,"decayCurve":"linear","decayRate":0.05,"originalIntensity":0.1}',
-      now,
-      scopeId,
-    ],
-  );
-}
-
-function setCheckpoint(key: string, value: string) {
-  getSqlite().run(
-    `INSERT OR REPLACE INTO memory_checkpoints (key, value, updated_at) VALUES (?, ?, ?)`,
-    [key, value, Date.now()],
-  );
-}
-
-function getPendingJobs(): Array<{ type: string }> {
-  return getSqlite()
-    .prepare(
-      `SELECT type FROM memory_jobs WHERE type = 'generate_conversation_starters' AND status = 'pending'`,
-    )
-    .all() as Array<{ type: string }>;
-}
-
-beforeEach(() => {
-  clearTables();
-});
-
-describe("maybeEnqueueConversationStartersJob", () => {
-  test("no-op when zero memory nodes", () => {
-    maybeEnqueueConversationStartersJob("default");
-    expect(getPendingJobs()).toHaveLength(0);
-  });
-
-  test("enqueues when threshold exceeded (<=10 nodes, threshold=1)", () => {
-    insertMemoryNode();
-    insertMemoryNode();
-
-    maybeEnqueueConversationStartersJob("default");
-    expect(getPendingJobs()).toHaveLength(1);
-  });
-
-  test("no-op when delta below threshold", () => {
-    for (let i = 0; i < 5; i++) insertMemoryNode();
-
-    // Set checkpoint to current count — no new items since last gen
-    setCheckpoint("conversation_starters:item_count_at_last_gen:default", "5");
-
-    maybeEnqueueConversationStartersJob("default");
-    expect(getPendingJobs()).toHaveLength(0);
-  });
-
-  test("uses higher threshold for larger memory counts (>50 nodes, threshold=10)", () => {
-    for (let i = 0; i < 55; i++) insertMemoryNode();
-
-    // Set checkpoint so delta is only 4 (below threshold of 10)
-    setCheckpoint(
-      "conversation_starters:item_count_at_last_gen:default",
-      "51",
-    );
-
-    maybeEnqueueConversationStartersJob("default");
-    expect(getPendingJobs()).toHaveLength(0);
-
-    // Add more to exceed threshold
-    for (let i = 0; i < 6; i++) insertMemoryNode();
-
-    maybeEnqueueConversationStartersJob("default");
-    expect(getPendingJobs()).toHaveLength(1);
-  });
-
-  test("dedup prevents double-enqueue", () => {
-    insertMemoryNode();
-    insertMemoryNode();
-
-    maybeEnqueueConversationStartersJob("default");
-    expect(getPendingJobs()).toHaveLength(1);
-
-    // Call again — should not create a second job
-    maybeEnqueueConversationStartersJob("default");
-    expect(getPendingJobs()).toHaveLength(1);
-  });
-
-  test("enqueues when active memory count drops below the last-generation checkpoint", () => {
-    // Start with 5 nodes and set checkpoint to 5
-    for (let i = 0; i < 5; i++) insertMemoryNode();
-    setCheckpoint("conversation_starters:item_count_at_last_gen:default", "5");
-
-    // Simulate pruning: mark 3 nodes as gone (reducing totalActive to 2)
-    const ids = (
-      getSqlite()
-        .prepare(`SELECT id FROM memory_graph_nodes LIMIT 3`)
-        .all() as Array<{ id: string }>
-    ).map((r) => r.id);
-    for (const id of ids) {
-      getSqlite().run(
-        `UPDATE memory_graph_nodes SET fidelity = 'gone' WHERE id = ?`,
-        [id],
-      );
-    }
-
-    // The checkpoint is now ahead of the active memory count. This should
-    // enqueue a refresh immediately so stale starters can recover.
-    maybeEnqueueConversationStartersJob("default");
-    expect(getPendingJobs()).toHaveLength(1);
-  });
-
-  test("scopes are independent", () => {
-    insertMemoryNode("scope-a");
-    insertMemoryNode("scope-b");
-
-    maybeEnqueueConversationStartersJob("scope-a");
-    maybeEnqueueConversationStartersJob("scope-b");
-
-    const jobs = getSqlite()
-      .prepare(
-        `SELECT payload FROM memory_jobs WHERE type = 'generate_conversation_starters' AND status = 'pending'`,
-      )
-      .all() as Array<{ payload: string }>;
-
-    expect(jobs).toHaveLength(2);
-    const payloads = jobs.map((j) => JSON.parse(j.payload).scopeId).sort();
-    expect(payloads).toEqual(["scope-a", "scope-b"]);
-  });
-});

package/src/__tests__/guardian-action-followup-executor.test.ts

@@ -1,322 +0,0 @@
-import { beforeEach, describe, expect, mock, test } from "bun:test";
-
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
-
-// Track call starts for assertions
-const startedCalls: Array<{
-  phoneNumber: string;
-  task: string;
-  conversationId: string;
-}> = [];
-let mockStartCallResult:
-  | {
-      ok: true;
-      session: { id: string };
-      callSid: string;
-      callerIdentityMode: string;
-    }
-  | { ok: false; error: string } = {
-  ok: true,
-  session: { id: "mock-call-session" },
-  callSid: "CA-mock",
-  callerIdentityMode: "assistant_number",
-};
-
-mock.module("../calls/call-domain.js", () => ({
-  startCall: async (input: {
-    phoneNumber: string;
-    task: string;
-    conversationId: string;
-  }) => {
-    startedCalls.push(input);
-    return mockStartCallResult;
-  },
-}));
-
-mock.module("../config/env.js", () => ({
-  isHttpAuthDisabled: () => true,
-  getGatewayInternalBaseUrl: () => "http://127.0.0.1:7830",
-}));
-
-// Mock conversation-key-store for call_back conversation creation
-let conversationCounter = 0;
-mock.module("../memory/conversation-key-store.js", () => ({
-  getOrCreateConversation: () => ({
-    conversationId: `mock-conv-${++conversationCounter}`,
-    created: true,
-  }),
-}));
-
-import {
-  createCallSession,
-  createPendingQuestion,
-} from "../calls/call-store.js";
-import { getDb } from "../memory/db-connection.js";
-import { initializeDb } from "../memory/db-init.js";
-import {
-  createGuardianActionDelivery,
-  createGuardianActionRequest,
-  getGuardianActionRequest,
-  markTimedOutWithReason,
-  progressFollowupState,
-  startFollowupFromExpiredRequest,
-  updateDeliveryStatus,
-} from "../memory/guardian-action-store.js";
-import { conversations } from "../memory/schema.js";
-import { executeFollowupAction } from "../runtime/guardian-action-followup-executor.js";
-import { resolveCounterparty } from "../runtime/guardian-action-followup-executor.js";
-
-initializeDb();
-
-function ensureConversation(id: string): void {
-  const db = getDb();
-  const now = Date.now();
-  db.insert(conversations)
-    .values({
-      id,
-      title: `Conversation ${id}`,
-      createdAt: now,
-      updatedAt: now,
-    })
-    .run();
-}
-
-function resetTables(): void {
-  const db = getDb();
-  db.run("DELETE FROM guardian_action_deliveries");
-  db.run("DELETE FROM guardian_action_requests");
-  db.run("DELETE FROM call_pending_questions");
-  db.run("DELETE FROM call_events");
-  db.run("DELETE FROM call_sessions");
-  db.run("DELETE FROM messages");
-  db.run("DELETE FROM conversations");
-  startedCalls.length = 0;
-  conversationCounter = 0;
-  mockStartCallResult = {
-    ok: true,
-    session: { id: "mock-call-session" },
-    callSid: "CA-mock",
-    callerIdentityMode: "assistant_number",
-  };
-}
-
-/**
- * Create a request in `dispatching` state ready for the executor.
- * The call session has fromNumber='+15550001111' (the counterparty).
- */
-function createDispatchingRequest(convId: string, action: "call_back") {
-  ensureConversation(convId);
-  const session = createCallSession({
-    conversationId: convId,
-    provider: "twilio",
-    fromNumber: "+15550001111",
-    toNumber: "+15550002222",
-  });
-  const pq = createPendingQuestion(session.id, "What is the gate code?");
-  const request = createGuardianActionRequest({
-    kind: "ask_guardian",
-    sourceChannel: "phone",
-    sourceConversationId: convId,
-    callSessionId: session.id,
-    pendingQuestionId: pq.id,
-    questionText: pq.questionText,
-    expiresAt: Date.now() - 10_000,
-  });
-
-  const deliveryConvId = `delivery-conv-${request.id}`;
-  ensureConversation(deliveryConvId);
-  const delivery = createGuardianActionDelivery({
-    requestId: request.id,
-    destinationChannel: "telegram",
-    destinationChatId: "chat-123",
-    destinationExternalUserId: "user-456",
-    destinationConversationId: deliveryConvId,
-  });
-  updateDeliveryStatus(delivery.id, "sent");
-
-  // Expire the request
-  markTimedOutWithReason(request.id, "call_timeout");
-
-  // Start follow-up
-  startFollowupFromExpiredRequest(request.id, "The gate code is 1234");
-
-  // Progress to dispatching with the given action
-  progressFollowupState(request.id, "dispatching", action);
-
-  return {
-    request: getGuardianActionRequest(request.id)!,
-    delivery,
-    callSession: session,
-  };
-}
-
-describe("guardian-action-followup-executor", () => {
-  beforeEach(() => {
-    resetTables();
-  });
-
-  // ── Counterparty resolution ─────────────────────────────────────────
-
-  describe("resolveCounterparty", () => {
-    test("resolves fromNumber as counterparty for inbound call", () => {
-      ensureConversation("cp-test-1");
-      const session = createCallSession({
-        conversationId: "cp-test-1",
-        provider: "twilio",
-        fromNumber: "+15550001111",
-        toNumber: "+15550002222",
-      });
-
-      const result = resolveCounterparty(session.id);
-      expect(result).not.toBeNull();
-      expect(result!.phoneNumber).toBe("+15550001111");
-      expect(result!.displayIdentifier).toBe("+15550001111");
-    });
-
-    test("resolves toNumber as counterparty for outbound call", () => {
-      ensureConversation("cp-test-outbound");
-      const session = createCallSession({
-        conversationId: "cp-test-outbound",
-        provider: "twilio",
-        fromNumber: "+15550002222", // assistant's number
-        toNumber: "+15550001111", // callee (the counterparty)
-        initiatedFromConversationId: "cp-test-outbound", // signals outbound
-      });
-
-      const result = resolveCounterparty(session.id);
-      expect(result).not.toBeNull();
-      expect(result!.phoneNumber).toBe("+15550001111");
-      expect(result!.displayIdentifier).toBe("+15550001111");
-    });
-
-    test("returns null for nonexistent call session", () => {
-      const result = resolveCounterparty("nonexistent-session-id");
-      expect(result).toBeNull();
-    });
-  });
-
-  // ── call_back execution ─────────────────────────────────────────────
-
-  describe("call_back", () => {
-    test("starts outbound call to counterparty and finalizes as completed", async () => {
-      const { request } = createDispatchingRequest("exec-call-1", "call_back");
-
-      const result = await executeFollowupAction(request.id, "call_back");
-
-      expect(result.ok).toBe(true);
-      expect(result.action).toBe("call_back");
-      expect(result.guardianReplyText.length).toBeGreaterThan(0);
-
-      // Verify call was started to the counterparty
-      expect(startedCalls.length).toBe(1);
-      expect(startedCalls[0].phoneNumber).toBe("+15550001111");
-      expect(startedCalls[0].task).toContain("gate code");
-
-      // Verify follow-up state is completed
-      const updated = getGuardianActionRequest(request.id);
-      expect(updated!.followupState).toBe("completed");
-      expect(updated!.followupCompletedAt).toBeGreaterThan(0);
-    });
-
-    test("confirmation text mentions calling back", async () => {
-      const { request } = createDispatchingRequest("exec-call-2", "call_back");
-
-      const result = await executeFollowupAction(request.id, "call_back");
-
-      expect(result.ok).toBe(true);
-      expect(result.guardianReplyText).toContain("calling");
-    });
-
-    test("failed call start finalizes as failed with error message", async () => {
-      mockStartCallResult = { ok: false, error: "Twilio account suspended" };
-      const { request } = createDispatchingRequest(
-        "exec-call-fail-1",
-        "call_back",
-      );
-
-      const result = await executeFollowupAction(request.id, "call_back");
-
-      expect(result.ok).toBe(false);
-      if (!result.ok) {
-        expect(result.error).toContain("Twilio account suspended");
-      }
-      expect(result.guardianReplyText.length).toBeGreaterThan(0);
-
-      // Verify follow-up state is failed
-      const updated = getGuardianActionRequest(request.id);
-      expect(updated!.followupState).toBe("failed");
-      expect(updated!.followupCompletedAt).toBeGreaterThan(0);
-    });
-  });
-
-  // ── Error handling ──────────────────────────────────────────────────
-
-  describe("error handling", () => {
-    test("nonexistent request returns failure with error message", async () => {
-      const result = await executeFollowupAction("nonexistent-id", "call_back");
-
-      expect(result.ok).toBe(false);
-      if (!result.ok) {
-        expect(result.error).toContain("not found");
-      }
-      expect(result.guardianReplyText.length).toBeGreaterThan(0);
-    });
-
-    test("request not in dispatching state returns failure", async () => {
-      // Create a request in awaiting_guardian_choice (not dispatching)
-      ensureConversation("exec-wrong-state");
-      const session = createCallSession({
-        conversationId: "exec-wrong-state",
-        provider: "twilio",
-        fromNumber: "+15550001111",
-        toNumber: "+15550002222",
-      });
-      const pq = createPendingQuestion(session.id, "Question?");
-      const request = createGuardianActionRequest({
-        kind: "ask_guardian",
-        sourceChannel: "phone",
-        sourceConversationId: "exec-wrong-state",
-        callSessionId: session.id,
-        pendingQuestionId: pq.id,
-        questionText: pq.questionText,
-        expiresAt: Date.now() - 10_000,
-      });
-      markTimedOutWithReason(request.id, "call_timeout");
-      startFollowupFromExpiredRequest(request.id, "Answer");
-      // Still in awaiting_guardian_choice — do NOT progress to dispatching
-
-      const result = await executeFollowupAction(request.id, "call_back");
-
-      expect(result.ok).toBe(false);
-      if (!result.ok) {
-        expect(result.error).toContain("Invalid followup state");
-      }
-    });
-
-    test("follow-up states terminate correctly on success", async () => {
-      const { request } = createDispatchingRequest("exec-state-1", "call_back");
-
-      await executeFollowupAction(request.id, "call_back");
-
-      const updated = getGuardianActionRequest(request.id);
-      expect(updated!.followupState).toBe("completed");
-      expect(updated!.followupCompletedAt).not.toBeNull();
-    });
-
-    test("follow-up states terminate correctly on failure", async () => {
-      mockStartCallResult = { ok: false, error: "Provider error" };
-      const { request } = createDispatchingRequest("exec-state-2", "call_back");
-
-      await executeFollowupAction(request.id, "call_back");
-
-      const updated = getGuardianActionRequest(request.id);
-      expect(updated!.followupState).toBe("failed");
-      expect(updated!.followupCompletedAt).not.toBeNull();
-    });
-  });
-});