@vellumai/assistant 0.7.2 → 0.8.0

package/src/__tests__/channel-inbound-disk-pressure.test.ts

@@ -0,0 +1,537 @@
+import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
+
+import { eq } from "drizzle-orm";
+
+import type { DiskPressureStatus } from "../daemon/disk-pressure-guard.js";
+
+const deliverChannelReplyMock = mock(
+  async (_callbackUrl: string, _payload: Record<string, unknown>) => {},
+);
+const expectedRemoteBlockReply =
+  "Storage is critically low, so remote messages are ignored until the guardian frees enough space. Please try again later.";
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+mock.module("../runtime/gateway-client.js", () => ({
+  deliverChannelReply: deliverChannelReplyMock,
+}));
+
+const lockedDiskPressureStatus: DiskPressureStatus = {
+  enabled: true,
+  state: "critical",
+  locked: true,
+  acknowledged: true,
+  overrideActive: false,
+  effectivelyLocked: true,
+  lockId: "disk-pressure-test",
+  usagePercent: 98,
+  thresholdPercent: 95,
+  path: "/workspace",
+  lastCheckedAt: "2026-05-05T00:00:00.000Z",
+  blockedCapabilities: ["agent-turns", "background-work", "remote-ingress"],
+  error: null,
+};
+const disabledDiskPressureStatus: DiskPressureStatus = {
+  enabled: false,
+  state: "disabled",
+  locked: false,
+  acknowledged: false,
+  overrideActive: false,
+  effectivelyLocked: false,
+  lockId: null,
+  usagePercent: null,
+  thresholdPercent: 95,
+  path: null,
+  lastCheckedAt: null,
+  blockedCapabilities: [],
+  error: null,
+};
+let diskPressureStatus = lockedDiskPressureStatus;
+let diskPressureStatusSequence: DiskPressureStatus[] | undefined;
+
+mock.module("../daemon/disk-pressure-guard.js", () => ({
+  getDiskPressureStatus: () =>
+    diskPressureStatusSequence?.shift() ?? diskPressureStatus,
+}));
+
+import { upsertContact } from "../contacts/contact-store.js";
+import { getDb } from "../memory/db-connection.js";
+import { initializeDb } from "../memory/db-init.js";
+import * as deliveryCrud from "../memory/delivery-crud.js";
+import {
+  canonicalGuardianRequests,
+  channelInboundEvents,
+  messages,
+} from "../memory/schema.js";
+import { sweepFailedEvents } from "../runtime/channel-retry-sweep.js";
+import {
+  handleChannelInbound,
+  setAdapterProcessMessage,
+} from "./helpers/channel-test-adapter.js";
+import { createGuardianBinding } from "./helpers/create-guardian-binding.js";
+
+initializeDb();
+
+function resetTables(): void {
+  const db = getDb();
+  db.run("DELETE FROM channel_inbound_events");
+  db.run("DELETE FROM channel_guardian_approval_requests");
+  db.run("DELETE FROM canonical_guardian_requests");
+  db.run("DELETE FROM conversation_keys");
+  db.run("DELETE FROM messages");
+  db.run("DELETE FROM conversations");
+  db.run("DELETE FROM external_conversation_bindings");
+  db.run("DELETE FROM contact_channels");
+  db.run("DELETE FROM contacts");
+}
+
+function seedTrustedContact(policy: "allow" | "escalate" = "allow"): void {
+  upsertContact({
+    displayName: "Example User",
+    channels: [
+      {
+        type: "telegram",
+        address: "telegram-user-1",
+        externalUserId: "telegram-user-1",
+        status: "active",
+        policy,
+      },
+    ],
+  });
+}
+
+function makeInboundRequest(overrides: Record<string, unknown> = {}): Request {
+  return new Request("http://localhost/channels/inbound", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "X-Gateway-Origin": "test-token",
+    },
+    body: JSON.stringify({
+      sourceChannel: "telegram",
+      interface: "telegram",
+      conversationExternalId: "chat-123",
+      externalMessageId: `msg-${Date.now()}-${Math.random()
+        .toString(36)
+        .slice(2, 8)}`,
+      content: "hello",
+      actorExternalId: "telegram-user-1",
+      replyCallbackUrl: "https://gateway.test/deliver/telegram",
+      ...overrides,
+    }),
+  });
+}
+
+describe("channel inbound disk pressure gate", () => {
+  beforeEach(() => {
+    resetTables();
+    seedTrustedContact();
+    setAdapterProcessMessage(undefined);
+    deliverChannelReplyMock.mockClear();
+    deliverChannelReplyMock.mockImplementation(
+      async (_callbackUrl: string, _payload: Record<string, unknown>) => {},
+    );
+    diskPressureStatus = lockedDiskPressureStatus;
+    diskPressureStatusSequence = undefined;
+  });
+
+  afterAll(() => {
+    diskPressureStatus = disabledDiskPressureStatus;
+  });
+
+  test("blocks trusted-contact ingress before payload persistence or processing", async () => {
+    const processMessage = mock(async () => {
+      throw new Error("processMessage should not run");
+    });
+    setAdapterProcessMessage(processMessage);
+
+    const res = await handleChannelInbound(makeInboundRequest());
+    const body = (await res.json()) as Record<string, unknown>;
+
+    expect(res.status).toBe(200);
+    expect(body).toMatchObject({
+      accepted: true,
+      duplicate: false,
+      diskPressure: "blocked",
+      reason: "trusted-contact",
+    });
+    expect(processMessage).not.toHaveBeenCalled();
+    expect(deliverChannelReplyMock).toHaveBeenCalledWith(
+      "https://gateway.test/deliver/telegram",
+      expect.objectContaining({
+        chatId: "chat-123",
+        text: expect.stringContaining("remote messages are ignored"),
+      }),
+    );
+
+    const db = getDb();
+    const event = db.select().from(channelInboundEvents).get();
+    expect(event?.processingStatus).toBe("processed");
+    expect(event?.messageId).toBeNull();
+    expect(event?.rawPayload).toBeNull();
+    expect(db.select().from(messages).all()).toHaveLength(0);
+  });
+
+  test("preserves retryable duplicate ingress without re-sending block replies", async () => {
+    const inbound = deliveryCrud.recordInbound(
+      "telegram",
+      "chat-123",
+      "msg-duplicate-blocked",
+    );
+    deliveryCrud.storePayload(inbound.eventId, {
+      content: "retry me",
+      sourceChannel: "telegram",
+      interface: "telegram",
+      externalChatId: "chat-123",
+      trustCtx: {
+        trustClass: "trusted_contact",
+        sourceChannel: "telegram",
+        requesterExternalUserId: "telegram-user-1",
+        requesterChatId: "chat-123",
+      },
+      replyCallbackUrl: "https://gateway.test/deliver/telegram",
+    });
+
+    const db = getDb();
+    db.update(channelInboundEvents)
+      .set({
+        processingStatus: "failed",
+        processingAttempts: 1,
+        retryAfter: Date.now() - 1,
+      })
+      .where(eq(channelInboundEvents.id, inbound.eventId))
+      .run();
+
+    const processMessage = mock(async () => {
+      throw new Error("processMessage should not run");
+    });
+    setAdapterProcessMessage(processMessage);
+
+    const res = await handleChannelInbound(
+      makeInboundRequest({ externalMessageId: "msg-duplicate-blocked" }),
+    );
+    const body = (await res.json()) as Record<string, unknown>;
+
+    expect(body).toMatchObject({
+      accepted: true,
+      duplicate: true,
+      diskPressure: "blocked",
+      reason: "trusted-contact",
+    });
+    expect(processMessage).not.toHaveBeenCalled();
+    expect(deliverChannelReplyMock).not.toHaveBeenCalled();
+
+    const event = db
+      .select()
+      .from(channelInboundEvents)
+      .where(eq(channelInboundEvents.id, inbound.eventId))
+      .get();
+    expect(event?.processingStatus).toBe("failed");
+    expect(event?.messageId).toBeNull();
+    expect(event?.rawPayload).not.toBeNull();
+    expect(db.select().from(messages).all()).toHaveLength(0);
+  });
+
+  test("blocks non-guardian Slack reactions before persistence while locked", async () => {
+    upsertContact({
+      displayName: "Example Slack User",
+      channels: [
+        {
+          type: "slack",
+          address: "slack-user-1",
+          externalUserId: "slack-user-1",
+          status: "active",
+          policy: "allow",
+        },
+      ],
+    });
+    const processMessage = mock(async () => {
+      throw new Error("processMessage should not run");
+    });
+    setAdapterProcessMessage(processMessage);
+
+    const res = await handleChannelInbound(
+      makeInboundRequest({
+        sourceChannel: "slack",
+        interface: "slack",
+        conversationExternalId: "slack-channel-1",
+        externalMessageId: "slack-reaction-blocked",
+        content: "reaction:thumbsup",
+        actorExternalId: "slack-user-1",
+        callbackData: "reaction:thumbsup",
+        replyCallbackUrl: "https://gateway.test/deliver/slack",
+      }),
+    );
+    const body = (await res.json()) as Record<string, unknown>;
+
+    expect(body).toMatchObject({
+      accepted: true,
+      duplicate: false,
+      diskPressure: "blocked",
+      reason: "trusted-contact",
+    });
+    expect(processMessage).not.toHaveBeenCalled();
+    expect(deliverChannelReplyMock.mock.calls).toEqual([
+      [
+        "https://gateway.test/deliver/slack",
+        {
+          chatId: "slack-channel-1",
+          text: expectedRemoteBlockReply,
+          assistantId: "self",
+          ephemeral: true,
+          user: "slack-user-1",
+        },
+      ],
+    ]);
+
+    const db = getDb();
+    const event = db
+      .select()
+      .from(channelInboundEvents)
+      .where(
+        eq(channelInboundEvents.externalMessageId, "slack-reaction-blocked"),
+      )
+      .get();
+    expect(event?.processingStatus).toBe("processed");
+    expect(event?.messageId).toBeNull();
+    expect(event?.rawPayload).toBeNull();
+    expect(db.select().from(messages).all()).toHaveLength(0);
+  });
+
+  test("blocks escalation-policy trusted-contact ingress before escalation state", async () => {
+    resetTables();
+    createGuardianBinding({
+      channel: "telegram",
+      guardianExternalUserId: "guardian-user-1",
+      guardianDeliveryChatId: "guardian-chat-1",
+      guardianPrincipalId: "guardian-user-1",
+    });
+    seedTrustedContact("escalate");
+    const processMessage = mock(async () => {
+      throw new Error("processMessage should not run");
+    });
+    setAdapterProcessMessage(processMessage);
+
+    const res = await handleChannelInbound(
+      makeInboundRequest({ externalMessageId: "msg-escalate-blocked" }),
+    );
+    const body = (await res.json()) as Record<string, unknown>;
+
+    expect(body).toMatchObject({
+      accepted: true,
+      duplicate: false,
+      diskPressure: "blocked",
+      reason: "trusted-contact",
+    });
+    expect(processMessage).not.toHaveBeenCalled();
+
+    const db = getDb();
+    const event = db
+      .select()
+      .from(channelInboundEvents)
+      .where(eq(channelInboundEvents.externalMessageId, "msg-escalate-blocked"))
+      .get();
+    expect(event?.processingStatus).toBe("processed");
+    expect(event?.messageId).toBeNull();
+    expect(event?.rawPayload).toBeNull();
+
+    expect(db.select().from(canonicalGuardianRequests).all()).toHaveLength(0);
+    expect(db.select().from(messages).all()).toHaveLength(0);
+  });
+
+  test("marks trusted-contact retry-sweep events processed without replaying", async () => {
+    const inbound = deliveryCrud.recordInbound(
+      "telegram",
+      "chat-retry",
+      "msg-retry",
+    );
+    deliveryCrud.storePayload(inbound.eventId, {
+      content: "retry me",
+      sourceChannel: "telegram",
+      interface: "telegram",
+      externalChatId: "chat-retry",
+      trustCtx: {
+        trustClass: "trusted_contact",
+        sourceChannel: "telegram",
+        requesterExternalUserId: "telegram-user-1",
+        requesterChatId: "chat-retry",
+      },
+      replyCallbackUrl: "https://gateway.test/deliver/telegram",
+    });
+
+    const db = getDb();
+    db.update(channelInboundEvents)
+      .set({
+        processingStatus: "failed",
+        processingAttempts: 1,
+        retryAfter: Date.now() - 1,
+      })
+      .where(eq(channelInboundEvents.id, inbound.eventId))
+      .run();
+
+    const processMessage = mock(async () => ({ messageId: "msg-should-not" }));
+    await sweepFailedEvents(processMessage);
+
+    expect(processMessage).not.toHaveBeenCalled();
+    expect(deliverChannelReplyMock).toHaveBeenCalledWith(
+      "https://gateway.test/deliver/telegram",
+      expect.objectContaining({
+        chatId: "chat-retry",
+        text: expect.stringContaining("remote messages are ignored"),
+      }),
+    );
+
+    const row = db
+      .select()
+      .from(channelInboundEvents)
+      .where(eq(channelInboundEvents.id, inbound.eventId))
+      .get();
+    expect(row?.processingStatus).toBe("processed");
+    expect(row?.messageId).toBeNull();
+    expect(row?.rawPayload).toBeNull();
+  });
+
+  test("uses ephemeral Slack retry block replies targeted to the requester", async () => {
+    const inbound = deliveryCrud.recordInbound(
+      "slack",
+      "slack-channel-1",
+      "slack-msg-retry",
+    );
+    deliveryCrud.storePayload(inbound.eventId, {
+      content: "retry me",
+      sourceChannel: "slack",
+      interface: "slack",
+      externalChatId: "slack-channel-1",
+      trustCtx: {
+        trustClass: "trusted_contact",
+        sourceChannel: "slack",
+        requesterExternalUserId: "slack-user-1",
+        requesterChatId: "slack-channel-1",
+      },
+      replyCallbackUrl: "https://gateway.test/deliver/slack",
+      assistantId: "self",
+    });
+
+    const db = getDb();
+    db.update(channelInboundEvents)
+      .set({
+        processingStatus: "failed",
+        processingAttempts: 1,
+        retryAfter: Date.now() - 1,
+      })
+      .where(eq(channelInboundEvents.id, inbound.eventId))
+      .run();
+
+    const processMessage = mock(async () => ({ messageId: "msg-should-not" }));
+    await sweepFailedEvents(processMessage);
+
+    expect(processMessage).not.toHaveBeenCalled();
+    expect(deliverChannelReplyMock.mock.calls).toEqual([
+      [
+        "https://gateway.test/deliver/slack",
+        {
+          chatId: "slack-channel-1",
+          text: expectedRemoteBlockReply,
+          assistantId: "self",
+          ephemeral: true,
+          user: "slack-user-1",
+        },
+      ],
+    ]);
+
+    const row = db
+      .select()
+      .from(channelInboundEvents)
+      .where(eq(channelInboundEvents.id, inbound.eventId))
+      .get();
+    expect(row?.processingStatus).toBe("processed");
+    expect(row?.messageId).toBeNull();
+    expect(row?.rawPayload).toBeNull();
+  });
+
+  test("rechecks disk pressure between retry-sweep events", async () => {
+    const blocked = deliveryCrud.recordInbound(
+      "telegram",
+      "chat-retry-blocked",
+      "msg-retry-blocked",
+    );
+    deliveryCrud.storePayload(blocked.eventId, {
+      content: "retry while locked",
+      sourceChannel: "telegram",
+      interface: "telegram",
+      externalChatId: "chat-retry-blocked",
+      trustCtx: {
+        trustClass: "trusted_contact",
+        sourceChannel: "telegram",
+        requesterExternalUserId: "telegram-user-1",
+        requesterChatId: "chat-retry-blocked",
+      },
+      replyCallbackUrl: "https://gateway.test/deliver/telegram",
+    });
+
+    const replayed = deliveryCrud.recordInbound(
+      "telegram",
+      "chat-retry-replayed",
+      "msg-retry-replayed",
+    );
+    deliveryCrud.storePayload(replayed.eventId, {
+      content: "retry after unlock",
+      sourceChannel: "telegram",
+      interface: "telegram",
+      externalChatId: "chat-retry-replayed",
+      trustCtx: {
+        trustClass: "trusted_contact",
+        sourceChannel: "telegram",
+        requesterExternalUserId: "telegram-user-1",
+        requesterChatId: "chat-retry-replayed",
+      },
+      replyCallbackUrl: "https://gateway.test/deliver/telegram",
+    });
+
+    const db = getDb();
+    for (const eventId of [blocked.eventId, replayed.eventId]) {
+      db.update(channelInboundEvents)
+        .set({
+          processingStatus: "failed",
+          processingAttempts: 1,
+          retryAfter: Date.now() - 1,
+        })
+        .where(eq(channelInboundEvents.id, eventId))
+        .run();
+    }
+
+    diskPressureStatusSequence = [
+      lockedDiskPressureStatus,
+      disabledDiskPressureStatus,
+    ];
+    const processMessage = mock(
+      async (conversationId: string, content: string) => {
+        db.insert(messages)
+          .values({
+            id: "msg-replayed",
+            conversationId,
+            role: "user",
+            content: JSON.stringify([{ type: "text", text: content }]),
+            createdAt: Date.now(),
+          })
+          .run();
+        return { messageId: "msg-replayed" };
+      },
+    );
+
+    await sweepFailedEvents(processMessage);
+
+    expect(processMessage).toHaveBeenCalledTimes(1);
+    expect(deliverChannelReplyMock).toHaveBeenCalledTimes(1);
+    const rows = db.select().from(channelInboundEvents).all();
+    expect(rows.filter((row) => row.rawPayload === null)).toHaveLength(1);
+    expect(rows.filter((row) => row.messageId === "msg-replayed")).toHaveLength(
+      1,
+    );
+  });
+});

package/src/__tests__/channel-readiness-service.test.ts

@@ -23,7 +23,9 @@ mock.module("../channels/config.js", () => ({
   }),
 }));
 
-mock.module("../config/env.js", () => ({}));
+mock.module("../config/env.js", () => ({
+  getIngressPublicBaseUrl: () => undefined,
+}));
 
 mock.module("../config/loader.js", () => ({
   loadRawConfig: () => mockRawConfig ?? {},
@@ -305,7 +307,7 @@ describe("ChannelReadinessService", () => {
     });
   });
 
-  test("phone readiness accepts Twilio-specific ingress without generic public ingress", async () => {
+  test("phone readiness accepts configured public ingress", async () => {
     mockHasTwilioCredentials = true;
     mockTwilioPhoneNumber = "+15550123";
     mockRawConfig = {

package/src/__tests__/cli-memory-v2-reembed-skills.test.ts

@@ -4,9 +4,8 @@
  *
  * The CLI half mocks `cliIpcCall` and asserts the subcommand dispatches
  * to `memory_v2_reembed_skills` with an empty body. The route half uses
- * the real `loadConfig` + flag resolver — flags are toggled via
- * `_setOverridesForTesting` and `memory.v2.enabled` is toggled via a
- * per-test `config.json` fixture in the temp workspace. We mock only
+ * the real `loadConfig` — `memory.v2.enabled` is toggled via a per-test
+ * `config.json` fixture in the temp workspace. We mock only
  * `seedV2SkillEntries` so we can assert it was invoked without actually
  * embedding skills.
  */
@@ -17,20 +16,14 @@ import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
 import { Command } from "commander";
 
-import {
-  _setOverridesForTesting,
-  clearFeatureFlagOverridesCache,
-} from "../config/assistant-feature-flags.js";
 import { invalidateConfigCache } from "../config/loader.js";
 import { getWorkspaceDir } from "../util/platform.js";
 
 // ---------------------------------------------------------------------------
-// Module-level mocks — kept minimal. `loadConfig`,
-// `isAssistantFeatureFlagEnabled`, and `getLogger` use their real
-// implementations because we already have first-class test hooks
-// (`_setOverridesForTesting` for flags, a per-test workspace `config.json`
-// for config) that exercise the same code paths the route handler runs in
-// production.
+// Module-level mocks — kept minimal. `loadConfig` and `getLogger` use their
+// real implementations because we have first-class test hooks (a per-test
+// workspace `config.json` for config) that exercise the same code paths
+// the route handler runs in production.
 // ---------------------------------------------------------------------------
 
 let lastIpcCall: { method: string; params?: Record<string, unknown> } | null =
@@ -60,7 +53,7 @@ mock.module("../memory/v2/skill-store.js", () => ({
 
 const { registerMemoryV2Command } =
   await import("../cli/commands/memory-v2.js");
-const { ROUTES: memoryV2Routes } =
+const { ROUTES: memoryV2Routes, MEMORY_V2_DISABLED_CODE } =
   await import("../runtime/routes/memory-v2-routes.js");
 const { RouteError } = await import("../runtime/routes/errors.js");
 
@@ -128,17 +121,15 @@ beforeEach(() => {
   seedCallCount = 0;
   process.exitCode = 0;
 
-  // Real flag + config defaults: enable both so happy-path tests pass.
-  _setOverridesForTesting({ "memory-v2-enabled": true });
+  // Default: v2 enabled so happy-path tests pass.
   writeWorkspaceConfig({ memory: { v2: { enabled: true } } });
 });
 
 afterEach(() => {
-  // Roll back the workspace config + flag overrides between cases so a
-  // gate-off test does not leak into the next case's setup.
+  // Roll back the workspace config between cases so a gate-off test does
+  // not leak into the next case's setup.
   rmSync(join(getWorkspaceDir(), "config.json"), { force: true });
   invalidateConfigCache();
-  clearFeatureFlagOverridesCache();
 });
 
 // ---------------------------------------------------------------------------
@@ -188,15 +179,6 @@ describe("memory_v2_reembed_skills route", () => {
     expect(seedCallCount).toBe(0);
   });
 
-  test("throws RouteError when feature flag is off", async () => {
-    _setOverridesForTesting({ "memory-v2-enabled": false });
-
-    await expect(
-      reembedSkillsRoute!.handler({ body: {} }),
-    ).rejects.toBeInstanceOf(RouteError);
-    expect(seedCallCount).toBe(0);
-  });
-
   test("throws RouteError when config.memory.v2.enabled is off", async () => {
     writeWorkspaceConfig({ memory: { v2: { enabled: false } } });
 
@@ -206,3 +188,51 @@ describe("memory_v2_reembed_skills route", () => {
     expect(seedCallCount).toBe(0);
   });
 });
+
+// ---------------------------------------------------------------------------
+// All v2 routes share the same gate
+// ---------------------------------------------------------------------------
+
+describe("all memory v2 routes — MEMORY_V2_DISABLED gate", () => {
+  // Minimal bodies that satisfy each route's schema. The gate runs before
+  // schema validation so any body would surface the gate error, but using
+  // valid shapes keeps the assertion precise: we're confirming the gate
+  // (not zod) is what blocks the call.
+  const MINIMAL_BODIES: Record<string, Record<string, unknown>> = {
+    memory_v2_backfill: { op: "migrate" },
+    memory_v2_validate: {},
+    memory_v2_get_concept_page: { slug: "any" },
+    memory_v2_list_concept_pages: {},
+    memory_v2_rebuild_corpus_stats: {},
+    memory_v2_explain_similarity: { userText: "hello" },
+    memory_v2_concept_frequency: {},
+    memory_v2_fit_anisotropy: {},
+  };
+
+  const GATE_OFF_CASES = [
+    {
+      label: "config is off",
+      apply: () => writeWorkspaceConfig({ memory: { v2: { enabled: false } } }),
+    },
+  ];
+
+  for (const [operationId, body] of Object.entries(MINIMAL_BODIES)) {
+    for (const { label, apply } of GATE_OFF_CASES) {
+      test(`${operationId} throws MEMORY_V2_DISABLED when ${label}`, async () => {
+        apply();
+        const route = memoryV2Routes.find((r) => r.operationId === operationId);
+        expect(route).toBeDefined();
+
+        try {
+          await route!.handler({ body });
+          throw new Error("expected handler to throw");
+        } catch (err) {
+          expect(err).toBeInstanceOf(RouteError);
+          expect((err as InstanceType<typeof RouteError>).code).toBe(
+            MEMORY_V2_DISABLED_CODE,
+          );
+        }
+      });
+    }
+  }
+});