@vellumai/assistant 0.10.0 → 0.10.1-staging.1

package/src/__tests__/helpers/channel-test-adapter.ts

@@ -61,6 +61,12 @@ mock.module("../../daemon/approval-generators.js", () => ({
   createApprovalConversationGenerator: () => undefined,
 }));
 
+import type { TrustClass, TrustVerdict } from "@vellumai/gateway-client";
+
+import {
+  findContactChannel,
+  findGuardianForChannel,
+} from "../../contacts/contact-store.js";
 import type {
   ApprovalConversationGenerator,
   ApprovalCopyGenerator,
@@ -112,9 +118,101 @@ export async function handleChannelInbound(
   _approvalConversationGenerator?: ApprovalConversationGenerator,
 ): Promise<Response> {
   const body = await req.json();
+  stampTrustVerdict(body);
   return wrapHandler(() => _handleChannelInbound({ body }));
 }
 
+/**
+ * Mirror the gateway: stamp a per-actor {@link TrustVerdict} onto inbound
+ * `sourceMetadata` from the local contact store, so the daemon's ACL stage
+ * (which now reads the verdict and fail-closed-denies when it is absent) sees
+ * the same verdict the gateway would resolve in production.
+ *
+ * Skipped when a test already supplies `trustVerdict` (or sets `sourceMetadata`
+ * to null) so absent-verdict / explicit-verdict tests keep their setup.
+ */
+function stampTrustVerdict(body: Record<string, unknown>): void {
+  const meta = body.sourceMetadata as Record<string, unknown> | undefined;
+  if (meta && "trustVerdict" in meta) return;
+
+  const channelType = String(body.sourceChannel ?? "");
+  const actorExternalId =
+    typeof body.actorExternalId === "string" ? body.actorExternalId : undefined;
+  const externalChatId =
+    typeof body.conversationExternalId === "string"
+      ? body.conversationExternalId
+      : undefined;
+  if (!channelType) return;
+
+  const verdict = resolveLocalTrustVerdict({
+    channelType,
+    actorExternalId,
+    externalChatId,
+  });
+  body.sourceMetadata = { ...(meta ?? {}), trustVerdict: verdict };
+}
+
+/** Local mirror of the gateway resolver, reading the daemon contact store. */
+export function resolveLocalTrustVerdict(input: {
+  channelType: string;
+  actorExternalId?: string;
+  externalChatId?: string;
+}): TrustVerdict {
+  const canonicalSenderId = input.actorExternalId ?? null;
+
+  const member = input.actorExternalId
+    ? findContactChannel({
+        channelType: input.channelType,
+        address: input.actorExternalId,
+        externalChatId: input.externalChatId,
+      })
+    : null;
+  const guardian = findGuardianForChannel(input.channelType);
+
+  const isGuardian =
+    !!guardian &&
+    !!canonicalSenderId &&
+    guardian.channel.address.toLowerCase() === canonicalSenderId.toLowerCase();
+
+  let trustClass: TrustClass;
+  if (isGuardian) {
+    trustClass = "guardian";
+  } else if (member) {
+    const status = member.channel.status;
+    if (status === "active") trustClass = "trusted_contact";
+    else if (status === "unverified" || status === "pending")
+      trustClass = "unverified_contact";
+    else trustClass = "unknown";
+  } else {
+    trustClass = "unknown";
+  }
+
+  const verdict: TrustVerdict = { trustClass, canonicalSenderId };
+
+  if (guardian) {
+    verdict.guardianExternalUserId = guardian.channel.address;
+    verdict.guardianDeliveryChatId = guardian.channel.externalChatId;
+    if (guardian.contact.principalId)
+      verdict.guardianPrincipalId = guardian.contact.principalId;
+    verdict.guardianDisplayName = guardian.contact.displayName;
+  }
+
+  if (member) {
+    verdict.contactId = member.channel.contactId;
+    verdict.channelId = member.channel.id;
+    verdict.type = member.channel.type;
+    verdict.address = member.channel.address;
+    verdict.externalChatId = member.channel.externalChatId;
+    verdict.status = member.channel.status;
+    verdict.policy = member.channel.policy;
+    verdict.verifiedAt = member.channel.verifiedAt;
+    verdict.verifiedVia = member.channel.verifiedVia;
+    verdict.memberDisplayName = member.contact.displayName;
+  }
+
+  return verdict;
+}
+
 // ---------------------------------------------------------------------------
 // handleDeleteConversation adapter
 // ---------------------------------------------------------------------------

package/src/__tests__/http-conversation-lineage.test.ts

@@ -41,7 +41,7 @@ import { rawRun } from "../memory/raw-query.js";
 import { RuntimeHttpServer } from "../runtime/http-server.js";
 import { resetDbForTesting } from "./db-test-helpers.js";
 
-initializeDb();
+await initializeDb();
 
 type ConversationSummary = {
   id: string;

package/src/__tests__/image-recovery-hook.test.ts

@@ -51,7 +51,7 @@ import {
 } from "../plugins/registry.js";
 import type { ContentBlock, Message } from "../providers/types.js";
 
-initializeDb();
+await initializeDb();
 
 /** Provider rejection text matched by `isImageDimensionsTooLargeError`. */
 const IMAGE_ERROR_MESSAGE =

package/src/__tests__/inbound-invite-redemption.test.ts

@@ -74,7 +74,7 @@ import { initializeDb } from "../memory/db-init.js";
 import { createInvite, revokeInvite } from "../memory/invite-store.js";
 import { handleChannelInbound } from "./helpers/channel-test-adapter.js";
 
-initializeDb();
+await initializeDb();
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -93,7 +93,6 @@ function resetState(): void {
   db.run("DELETE FROM assistant_ingress_invites");
   db.run("DELETE FROM channel_inbound_events");
   db.run("DELETE FROM conversations");
-  db.run("DELETE FROM channel_guardian_approval_requests");
   db.run("DELETE FROM notification_events");
   db.run("DELETE FROM contact_channels");
   db.run("DELETE FROM contacts");

package/src/__tests__/inbound-trust-verdict.test.ts

@@ -0,0 +1,254 @@
+/**
+ * The inbound text path builds `trustCtx` from the gateway-stamped
+ * `sourceMetadata.trustVerdict` via `trustContextFromVerdict`. Admission follows
+ * the trust class + floor, and the Slack requester timezone attaches to the
+ * resulting context.
+ */
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+mock.module("../config/env.js", () => ({ isHttpAuthDisabled: () => true }));
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+// Enable the channel-trust-floors flag so the admission-policy stage runs.
+mock.module("../config/assistant-feature-flags.js", () => ({
+  isAssistantFeatureFlagEnabled: (key: string) => key === "channel-trust-floors",
+}));
+
+mock.module("../runtime/gateway-client.js", () => ({
+  deliverChannelReply: async () => {},
+}));
+
+import type { TrustVerdict } from "@vellumai/gateway-client";
+
+import type { TrustContext } from "../daemon/trust-context.js";
+import { getDb } from "../memory/db-connection.js";
+import { initializeDb } from "../memory/db-init.js";
+import { messages } from "../memory/schema.js";
+import {
+  handleChannelInbound,
+  setAdapterProcessMessage,
+} from "./helpers/channel-test-adapter.js";
+
+await initializeDb();
+
+function resetTables(): void {
+  const db = getDb();
+  db.run("DELETE FROM channel_inbound_events");
+  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");
+}
+
+/** Capture the `trustContext` the handler dispatches to the agent loop. */
+function captureTrustContextProcessor(captured: { ctx?: TrustContext }) {
+  return async (
+    conversationId: string,
+    _content: string,
+    options?: Record<string, unknown>,
+  ) => {
+    captured.ctx = options?.trustContext as TrustContext | undefined;
+    const messageId = `msg-${Date.now()}-${Math.random()
+      .toString(36)
+      .slice(2, 8)}`;
+    getDb()
+      .insert(messages)
+      .values({
+        id: messageId,
+        conversationId,
+        role: "user",
+        content: JSON.stringify([{ type: "text", text: "hello" }]),
+        createdAt: Date.now(),
+      })
+      .run();
+    return { messageId };
+  };
+}
+
+function makeInboundRequest(
+  sourceMetadata: Record<string, unknown>,
+  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: "user-1",
+      replyCallbackUrl: "https://gateway.test/deliver/telegram",
+      sourceMetadata,
+      ...overrides,
+    }),
+  });
+}
+
+/** A full member verdict (ACL passes) for the given trust class. */
+function memberVerdict(
+  trustClass: TrustVerdict["trustClass"],
+  overrides: Partial<TrustVerdict> = {},
+): TrustVerdict {
+  return {
+    trustClass,
+    canonicalSenderId: "user-1",
+    contactId: "contact-1",
+    channelId: "channel-1",
+    type: "telegram",
+    address: "user-1",
+    externalChatId: "chat-123",
+    status: "active",
+    policy: "allow",
+    memberDisplayName: "Member One",
+    ...overrides,
+  } satisfies TrustVerdict;
+}
+
+describe("inbound trust verdict → TrustContext", () => {
+  beforeEach(() => {
+    resetTables();
+    setAdapterProcessMessage(undefined);
+  });
+
+  test("guardian verdict admits with guardian-class trustCtx and guardian fields", async () => {
+    const verdict = memberVerdict("guardian", {
+      guardianExternalUserId: "user-1",
+      guardianDeliveryChatId: "guardian-chat-1",
+      guardianPrincipalId: "vellum-principal-1",
+    });
+
+    const captured: { ctx?: TrustContext } = {};
+    setAdapterProcessMessage(captureTrustContextProcessor(captured));
+    const res = await handleChannelInbound(
+      makeInboundRequest({
+        trustVerdict: verdict,
+        admissionPolicy: "trusted_contacts",
+      }),
+    );
+    const body = (await res.json()) as Record<string, unknown>;
+    expect(body.accepted).toBe(true);
+    expect(body.denied).toBeUndefined();
+
+    await new Promise((resolve) => setTimeout(resolve, 300));
+
+    expect(captured.ctx?.trustClass).toBe("guardian");
+    expect(captured.ctx?.guardianExternalUserId).toBe("user-1");
+    expect(captured.ctx?.guardianChatId).toBe("guardian-chat-1");
+    expect(captured.ctx?.guardianPrincipalId).toBe("vellum-principal-1");
+  });
+
+  test("trusted_contact admitted under a trusted_contacts floor", async () => {
+    const captured: { ctx?: TrustContext } = {};
+    setAdapterProcessMessage(captureTrustContextProcessor(captured));
+    const res = await handleChannelInbound(
+      makeInboundRequest({
+        trustVerdict: memberVerdict("trusted_contact"),
+        admissionPolicy: "trusted_contacts",
+      }),
+    );
+    const body = (await res.json()) as Record<string, unknown>;
+    expect(body.accepted).toBe(true);
+    expect(body.denied).toBeUndefined();
+
+    await new Promise((resolve) => setTimeout(resolve, 300));
+    expect(captured.ctx?.trustClass).toBe("trusted_contact");
+  });
+
+  test("trusted_contact denied under a guardian_only floor", async () => {
+    const res = await handleChannelInbound(
+      makeInboundRequest({
+        trustVerdict: memberVerdict("trusted_contact"),
+        admissionPolicy: "guardian_only",
+      }),
+    );
+    const body = (await res.json()) as Record<string, unknown>;
+    expect(body.accepted).toBe(true);
+    expect(body.denied).toBe(true);
+    expect(body.reason).toBe("admission_policy_guardian_only");
+  });
+
+  test("present unknown (stranger) verdict admitted under a strangers floor", async () => {
+    const captured: { ctx?: TrustContext } = {};
+    setAdapterProcessMessage(captureTrustContextProcessor(captured));
+    const res = await handleChannelInbound(
+      makeInboundRequest({
+        trustVerdict: {
+          trustClass: "unknown",
+          canonicalSenderId: "user-1",
+        } satisfies TrustVerdict,
+        admissionPolicy: "strangers",
+      }),
+    );
+    const body = (await res.json()) as Record<string, unknown>;
+    expect(body.accepted).toBe(true);
+    expect(body.denied).toBeUndefined();
+
+    await new Promise((resolve) => setTimeout(resolve, 300));
+    expect(captured.ctx?.trustClass).toBe("unknown");
+  });
+
+  test("present unknown (stranger) verdict denied under a trusted_contacts floor", async () => {
+    const res = await handleChannelInbound(
+      makeInboundRequest({
+        trustVerdict: {
+          trustClass: "unknown",
+          canonicalSenderId: "user-1",
+        } satisfies TrustVerdict,
+        admissionPolicy: "trusted_contacts",
+      }),
+    );
+    const body = (await res.json()) as Record<string, unknown>;
+    expect(body.accepted).toBe(true);
+    expect(body.denied).toBe(true);
+    expect(body.reason).toBe("not_a_member");
+  });
+
+  test("slack requester timezone is attached to the verdict-sourced trustCtx", async () => {
+    const captured: { ctx?: TrustContext } = {};
+    setAdapterProcessMessage(captureTrustContextProcessor(captured));
+    const res = await handleChannelInbound(
+      makeInboundRequest(
+        {
+          trustVerdict: memberVerdict("trusted_contact", {
+            type: "slack",
+            externalChatId: "slack-chan-1",
+          }),
+          admissionPolicy: "trusted_contacts",
+          timezone: "America/New_York",
+          timezoneLabel: "ET",
+          timezoneOffsetSeconds: -18000,
+        },
+        {
+          sourceChannel: "slack",
+          interface: "slack",
+          conversationExternalId: "slack-chan-1",
+          replyCallbackUrl: "https://gateway.test/deliver/slack",
+        },
+      ),
+    );
+    const body = (await res.json()) as Record<string, unknown>;
+    expect(body.accepted).toBe(true);
+
+    await new Promise((resolve) => setTimeout(resolve, 300));
+    expect(captured.ctx?.trustClass).toBe("trusted_contact");
+    expect(captured.ctx?.requesterTimezone).toBe("America/New_York");
+    expect(captured.ctx?.requesterTimezoneLabel).toBe("ET");
+    expect(captured.ctx?.requesterTimezoneOffsetSeconds).toBe(-18000);
+  });
+});

package/src/__tests__/inference-profile-reaper.test.ts

@@ -27,7 +27,7 @@ import {
 } from "../runtime/routes/inference-profile-session-reaper.js";
 import { resetDbForTesting } from "./db-test-helpers.js";
 
-initializeDb();
+await initializeDb();
 
 function clearTables(): void {
   const db = getDb();

package/src/__tests__/inference-profile-session-handler.test.ts

@@ -65,7 +65,7 @@ import {
 import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 
-initializeDb();
+await initializeDb();
 
 import {
   closeInferenceProfileSession,

package/src/__tests__/inference-profile-session-ipc.test.ts

@@ -43,7 +43,7 @@ import { initializeDb } from "../memory/db-init.js";
 import { ROUTES } from "../runtime/routes/inference-profile-session-routes.js";
 import { resetDbForTesting } from "./db-test-helpers.js";
 
-initializeDb();
+await initializeDb();
 
 const openRoute = ROUTES.find(
   (r) => r.operationId === "inference_profile_open",

package/src/__tests__/injector-chain.test.ts

@@ -84,7 +84,7 @@ import { getWorkspacePromptPath } from "../util/platform.js";
 // `applyRuntimeInjections` self-resolves the Slack active-thread focus block
 // from the persisted message rows, so the schema must exist for Slack-channel
 // turns; with no seeded rows the focus loader resolves to null.
-initializeDb();
+await initializeDb();
 
 // `makeTurnContext` and the workspace registry seed share this id so the
 // `workspace-context` injector resolves the seeded block for the turn.

package/src/__tests__/injector-disk-pressure.test.ts

@@ -42,7 +42,7 @@ import type { Message } from "../providers/types.js";
 // `applyRuntimeInjections` self-resolves the Slack active-thread focus block
 // from the persisted message rows, so the schema must exist for Slack-channel
 // turns; with no seeded rows the focus loader resolves to null.
-initializeDb();
+await initializeDb();
 
 // `makeContext` and the workspace registry seed share this id so the
 // `workspace-context` injector resolves the seeded block for the turn.
@@ -204,7 +204,7 @@ describe("disk-pressure-warning injector", () => {
       .run();
   });
 
-  test("emits the exact cleanup prompt during disk pressure cleanup mode", async () => {
+  test("emits the concise cleanup skill prompt during disk pressure cleanup mode", async () => {
     seedDiskPressure(true);
     const block = await diskPressureInjector.produce(makeContext());
 
@@ -217,14 +217,19 @@ describe("disk-pressure-warning injector", () => {
       DEFAULT_INJECTOR_ORDER.diskPressureWarning,
     );
     expect(DISK_PRESSURE_WARNING_PROMPT).toBe(`<disk_pressure_warning>
-Disk usage is critically low: this assistant is in storage cleanup mode because the workspace volume is critically full.
+Storage is critically low and normal work is suspended until space is freed.
 
-In your first paragraph, warn the user that storage is critically low and that normal work is suspended until space is freed.
+Your first user-visible paragraph must warn the user that storage is critically low and normal work is suspended.
 
-Then help the user clean up storage. Prefer safe inspection steps first, such as checking available space and finding large directories. Ask before deleting files or caches unless the user has already clearly approved the specific cleanup action.
+Before taking cleanup actions, call \`skill_load\` with \`skill: "system-storage-cleanup"\` and follow the cleanup skill.
 
-Do not work on unrelated tasks until enough space is freed to clear the lock or the user explicitly overrides it. Background processes and messages from trusted contacts are blocked while this cleanup mode is active.
+Unrelated work remains blocked until disk usage drops below the critical threshold or the guardian explicitly overrides the lock. Background processes and trusted-contact messages remain blocked while this cleanup mode is active.
 </disk_pressure_warning>`);
+    expect(DISK_PRESSURE_WARNING_PROMPT).toContain("skill_load");
+    expect(DISK_PRESSURE_WARNING_PROMPT).toContain("system-storage-cleanup");
+    expect(DISK_PRESSURE_WARNING_PROMPT).not.toContain(
+      "Prefer safe inspection steps first",
+    );
   });
 
   test("omits the prompt when no cleanup context is registered or it is inactive", async () => {

package/src/__tests__/internal-telemetry-routes.test.ts

@@ -27,7 +27,7 @@ import { RouteError } from "../runtime/routes/errors.js";
 import { ROUTES } from "../runtime/routes/internal-telemetry-routes.js";
 import type { RouteHandlerArgs } from "../runtime/routes/types.js";
 
-initializeDb();
+await initializeDb();
 
 const route = ROUTES.find(
   (r) => r.operationId === "internal_telemetry_auth_fallback",