@vellumai/assistant 0.10.2 → 0.10.3-dev.202606252046.9075fd5

package/src/daemon/event-loop-watchdog.ts

@@ -33,6 +33,7 @@
 
 import * as Sentry from "@sentry/node";
 
+import { recordWatchdogEvent } from "../memory/watchdog-events-store.js";
 import { getLogger } from "../util/logger.js";
 
 const log = getLogger("event-loop-watchdog");
@@ -74,11 +75,37 @@ export function evaluateTick(
   return { blockedMs, exceeded: blockedMs >= thresholdMs };
 }
 
+/**
+ * Check name emitted for event-loop block events. The platform's
+ * `watchdog__event_loop_blocking_daily` admin query filters `check_name` to
+ * this exact string, so it is the primary group-by dimension downstream —
+ * keep it stable.
+ */
+export const EVENT_LOOP_BLOCKED_CHECK_NAME = "event_loop_blocked";
+
 function reportBlock(blockedMs: number, thresholdMs: number): void {
   log.warn(
     { blockedMs, thresholdMs, tickIntervalMs: TICK_INTERVAL_MS },
     "event loop blocked",
   );
+  // Persist a `watchdog` telemetry event so the platform can surface
+  // event-loop blocking in the infrastructure admin chart. `recordWatchdogEvent`
+  // no-ops when usage-data collection is disabled (the event is dropped to
+  // honor the opt-out), so the watchdog runs unconditionally without leaking
+  // health data for opted-out owners. Never let a telemetry failure escape
+  // the timer callback — wrap it alongside the Sentry capture below.
+  try {
+    recordWatchdogEvent({
+      checkName: EVENT_LOOP_BLOCKED_CHECK_NAME,
+      value: blockedMs,
+      detail: {
+        threshold_ms: thresholdMs,
+        tick_interval_ms: TICK_INTERVAL_MS,
+      },
+    });
+  } catch {
+    // Never let a telemetry failure escape the timer callback.
+  }
   try {
     Sentry.withScope((scope) => {
       scope.setLevel("warning");
@@ -88,7 +115,7 @@ function reportBlock(blockedMs: number, thresholdMs: number): void {
         threshold_ms: thresholdMs,
         tick_interval_ms: TICK_INTERVAL_MS,
       });
-      Sentry.captureMessage("event_loop_blocked");
+      Sentry.captureMessage(EVENT_LOOP_BLOCKED_CHECK_NAME);
     });
   } catch {
     // Never let a telemetry failure escape the timer callback.

package/src/daemon/external-plugins-bootstrap.ts

@@ -19,24 +19,20 @@
  *    dropped from the registry via {@link unregisterPlugin} so none of its
  *    hooks participate in the turn lifecycle. This is the primary mechanism for
  *    shipping experimental plugins behind a feature flag.
- * 4. Resolves the plugin's `manifest.requiresCredential` entries via the
- *    credential store helper ({@link getSecureKeyAsync}). In Docker mode
- *    that helper goes through the CES HTTP API transparently; in local mode
- *    it hits the encrypted file store / CES RPC backend.
- * 5. Validates the config block under `plugins.<name>` against
+ * 4. Validates the config block under `plugins.<name>` against
  *    `manifest.config` if the manifest supplies a parser-like validator
  *    (Zod schemas with `.parse()` are supported; anything else is passed
  *    through untouched).
- * 6. Creates `<workspaceDir>/plugins-data/<plugin>/` on demand for per-plugin
- *    writable state and exposes it via {@link PluginInitContext.pluginStorageDir}.
- * 7. For each surviving plugin, registers its contributed tools and routes
+ * 5. Creates `<workspaceDir>/plugins-data/<plugin>/` on demand for per-plugin
+ *    writable state and exposes it via {@link InitContext.pluginStorageDir}.
+ * 6. For each surviving plugin, registers its contributed tools and routes
  *    into their global registries via {@link registerPluginTools} and
  *    {@link registerSkillRoute}. Contributions land BEFORE `init()` so
  *    the plugin's hook can observe a registry where its own model-visible
  *    surface is already wired — useful for plugins that want to attach
  *    metadata, warm caches, or otherwise interact with their own
  *    contributions during initialization.
- * 8. Awaits `plugin.init(ctx)` sequentially. An init failure is contained to
+ * 7. Awaits `plugin.init(ctx)` sequentially. An init failure is contained to
  *    the offending plugin: its already-registered tools and routes are rolled
  *    back, it is dropped from the registry, the failure is logged, and
  *    bootstrap continues with the remaining plugins. A single plugin's failure
@@ -68,7 +64,7 @@ import { getRegisteredPlugins, unregisterPlugin } from "../plugins/registry.js";
 import {
   type Plugin,
   PluginExecutionError,
-  type PluginShutdownContext,
+  type ShutdownContext,
 } from "../plugins/types.js";
 import { loadUserPlugins } from "../plugins/user-loader.js";
 import {
@@ -76,7 +72,6 @@ import {
   type SkillRouteHandle,
   unregisterSkillRoute,
 } from "../runtime/skill-route-registry.js";
-import { getSecureKeyAsync } from "../security/secure-keys.js";
 import {
   registerPluginTools,
   unregisterPluginTools,
@@ -88,25 +83,6 @@ import { registerShutdownHook } from "./shutdown-registry.js";
 
 const log = getLogger("plugins-bootstrap");
 
-/**
- * Resolve one credential value. Returns the raw secret string or throws a
- * {@link PluginExecutionError} tagged with the plugin name so the caller can
- * fail startup with clear attribution.
- */
-async function resolveCredentialOrThrow(
-  pluginName: string,
-  credentialKey: string,
-): Promise<string> {
-  const value = await getSecureKeyAsync(credentialKey);
-  if (value === undefined || value === "") {
-    throw new PluginExecutionError(
-      `plugin ${pluginName} requires credential "${credentialKey}" but the credential store returned no value`,
-      pluginName,
-    );
-  }
-  return value;
-}
-
 /**
  * Validate a plugin config block. If the manifest supplies a parser-like
  * validator (Zod schemas expose `.parse()`), use it. Otherwise pass the
@@ -246,8 +222,8 @@ export async function bootstrapPlugins(): Promise<void> {
   // Shutdown context is identical for every plugin in this boot — construct
   // once and reuse across the per-plugin teardown and the normal shutdown
   // hook below. Only `assistantVersion` is exposed today; future additions
-  // live on {@link PluginShutdownContext}.
-  const shutdownContext: PluginShutdownContext = {
+  // live on {@link ShutdownContext}.
+  const shutdownContext: ShutdownContext = {
     assistantVersion: APP_VERSION,
   };
 
@@ -271,7 +247,14 @@ export async function bootstrapPlugins(): Promise<void> {
     // out-of-band kill switch — the operator creates a directory named
     // after the plugin's manifest name (e.g. `plugins/default-advisor/`)
     // and drops a `.disabled` file inside it. Runs before init so no
-    // hooks, tools, or routes from the disabled plugin are ever wired.
+    // tools or routes from the disabled plugin are ever wired.
+    //
+    // Unlike the feature-flag path above, we do NOT call
+    // `unregisterPlugin(name)` here. The plugin's hooks stay in the hook
+    // registry and are filtered at read time by `isPluginDisabled` in
+    // `getHooksFor`. This means `assistant plugins enable <name>` takes
+    // effect on the next turn without a restart — the hooks are already
+    // registered, they just need the sentinel removed to be included.
     const disabledSentinelPath = join(
       getWorkspacePluginsDir(),
       name,
@@ -282,7 +265,6 @@ export async function bootstrapPlugins(): Promise<void> {
         { plugin: name, sentinel: disabledSentinelPath },
         `skipping plugin ${name}: disabled via .disabled sentinel`,
       );
-      unregisterPlugin(name);
       continue;
     }
 
@@ -346,11 +328,6 @@ async function initializePlugin(
   let initCompleted = false;
 
   try {
-    const credentials: Record<string, string> = {};
-    for (const key of plugin.manifest.requiresCredential ?? []) {
-      credentials[key] = await resolveCredentialOrThrow(name, key);
-    }
-
     const config = validatePluginConfig(
       name,
       plugin.manifest.config,
@@ -359,7 +336,6 @@ async function initializePlugin(
 
     const initContext = {
       config,
-      credentials,
       logger: log.child({ plugin: name }),
       pluginStorageDir: ensurePluginStorageDir(name),
       assistantVersion: APP_VERSION,
@@ -437,7 +413,7 @@ async function initializePlugin(
 async function teardownPlugin(
   active: ActivePlugin,
   reason: string,
-  shutdownContext: PluginShutdownContext,
+  shutdownContext: ShutdownContext,
 ): Promise<void> {
   const { plugin, routeHandles } = active;
   const name = plugin.manifest.name;

package/src/daemon/handlers/__tests__/config-a2a-accept.test.ts

@@ -174,7 +174,6 @@ describe("acceptA2AInvite", () => {
     expect(contact).not.toBeNull();
     expect(contact!.channels).toHaveLength(1);
     expect(contact!.channels[0]!.type).toBe("a2a");
-    expect(contact!.channels[0]!.status).toBe("active");
 
     // Verify assistant metadata
     const metadata = getAssistantContactMetadata(result.contactId!);

package/src/daemon/handlers/__tests__/config-a2a-complete.test.ts

@@ -100,8 +100,6 @@ describe("completeA2AInvite", () => {
     expect(contact!.displayName).toBe("Acceptor Bot");
     expect(contact!.channels).toHaveLength(1);
     expect(contact!.channels[0]!.type).toBe("a2a");
-    expect(contact!.channels[0]!.status).toBe("active");
-    expect(contact!.channels[0]!.policy).toBe("allow");
   });
 
   test("contact channel address is acceptor.assistantId.toLowerCase()", () => {

package/src/daemon/handlers/__tests__/config-a2a-redeem.test.ts

@@ -71,8 +71,6 @@ describe("redeemA2AInvite", () => {
     expect(contact!.displayName).toBe("Sender Bot");
     expect(contact!.channels).toHaveLength(1);
     expect(contact!.channels[0]!.type).toBe("a2a");
-    expect(contact!.channels[0]!.status).toBe("active");
-    expect(contact!.channels[0]!.policy).toBe("allow");
   });
 
   test("idempotency: already-connected sender returns alreadyConnected", () => {
@@ -129,4 +127,29 @@ describe("redeemA2AInvite", () => {
     const result = redeemA2AInvite({ sender: SENDER });
     expect(result.success).toBe(true);
   });
+
+  test("activeConnections counts a2a channel existence, not status", () => {
+    const result = redeemA2AInvite({ sender: SENDER });
+    expect(result.success).toBe(true);
+
+    expect(getA2AConfig().activeConnections).toBe(1);
+
+    // Readiness is existence-based: a non-active stored status still counts.
+    const sqlite = getSqlite();
+    sqlite.run("UPDATE contact_channels SET status = 'unverified'");
+    invalidateConfigCache();
+    expect(getA2AConfig().activeConnections).toBe(1);
+  });
+
+  test("already-connected guard fires regardless of stored channel status", () => {
+    const first = redeemA2AInvite({ sender: SENDER });
+    expect(first.success).toBe(true);
+
+    const sqlite = getSqlite();
+    sqlite.run("UPDATE contact_channels SET status = 'revoked'");
+
+    const second = redeemA2AInvite({ sender: SENDER });
+    expect(second.alreadyConnected).toBe(true);
+    expect(second.contactId).toBe(first.contactId);
+  });
 });

package/src/daemon/handlers/__tests__/config-channels.test.ts

@@ -0,0 +1,220 @@
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+import type { GuardianDelivery } from "@vellumai/gateway-client";
+
+import type { ContactChannel } from "../../../contacts/types.js";
+
+let mockGuardians: GuardianDelivery[] | null = null;
+let mockBinding: { guardianExternalUserId: string; guardianDeliveryChatId: string } | null = null;
+let mockContactChannel: { channel: ContactChannel } | null = null;
+let mockChannel: ContactChannel | null = null;
+let mockGwContactChannels: Array<{ id: string; status: string; verifiedAt: number | null }> | null =
+  null;
+let ipcCalls: Array<{ method: string; payload: unknown }> = [];
+
+mock.module("../../../contacts/guardian-delivery-reader.js", () => ({
+  getGuardianDelivery: async (input?: { channelTypes?: string[] }) => {
+    if (mockGuardians == null) return null;
+    if (!input?.channelTypes) return mockGuardians;
+    return mockGuardians.filter((g) =>
+      input.channelTypes!.includes(g.channelType),
+    );
+  },
+  guardianForChannel: (
+    list: GuardianDelivery[],
+    channelType: string,
+  ) => list.find((g) => g.channelType === channelType && g.status === "active"),
+}));
+
+mock.module("../../../contacts/contact-store.js", () => ({
+  findContactChannel: () => mockContactChannel,
+  getChannelById: () => mockChannel,
+  getContact: () => ({ id: "contact-1", displayName: "Pat" }),
+}));
+
+mock.module("../../../contacts/contact-events.js", () => ({
+  emitContactChange: () => {},
+  onContactChange: () => {},
+}));
+
+mock.module("../../../ipc/gateway-client.js", () => ({
+  ipcCallPersistent: async (method: string, payload: unknown) => {
+    ipcCalls.push({ method, payload });
+    if (method === "contacts_get_rich") {
+      if (mockGwContactChannels == null) return { ok: true, contact: null };
+      return {
+        ok: true,
+        contact: {
+          id: "contact-1",
+          displayName: "Pat",
+          role: "contact",
+          interactionCount: 0,
+          createdAt: 0,
+          updatedAt: 0,
+          channels: mockGwContactChannels.map((c) => ({
+            id: c.id,
+            contactId: "contact-1",
+            type: "telegram",
+            address: "user-123",
+            isPrimary: true,
+            externalUserId: null,
+            status: c.status,
+            policy: "allow",
+            verifiedAt: c.verifiedAt,
+            verifiedVia: null,
+            lastSeenAt: null,
+            interactionCount: 0,
+            lastInteraction: null,
+            revokedReason: null,
+            blockedReason: null,
+          })),
+        },
+      };
+    }
+    return {
+      ok: true,
+      didWrite: true,
+      channel: {
+        id: "ch-1",
+        contactId: "contact-1",
+        type: "telegram",
+        address: "user-123",
+        status: "revoked",
+        revokedReason: "guardian_binding_revoked",
+      },
+    };
+  },
+  ipcCall: async () => null,
+}));
+
+mock.module("../../../runtime/channel-verification-service.js", () => ({
+  getGuardianBinding: () => mockBinding,
+  revokeBinding: () => true,
+  revokePendingSessions: () => {},
+  createOutboundSession: () => ({
+    sessionId: "sess",
+    secret: "code",
+    expiresAt: Date.now() + 1000,
+  }),
+  countRecentSendsToDestination: () => 0,
+  isGuardianBoundForChannel: async () => false,
+  updateSessionDelivery: () => {},
+}));
+
+mock.module("../../../runtime/verification-outbound-actions.js", () => ({
+  cancelOutbound: () => {},
+  deliverVerificationEmail: () => {},
+  deliverVerificationSlack: () => {},
+  deliverVerificationTelegram: () => {},
+  DESTINATION_RATE_WINDOW_MS: 1000,
+  MAX_SENDS_PER_DESTINATION_WINDOW: 5,
+  normalizeTelegramDestination: (d: string) => d,
+  resendOutbound: () => ({}),
+  startOutbound: async () => ({}),
+}));
+
+import {
+  revokeVerificationForChannel,
+  verifyTrustedContact,
+} from "../config-channels.js";
+
+function channel(overrides: Partial<ContactChannel> = {}): ContactChannel {
+  return {
+    id: "ch-1",
+    contactId: "contact-1",
+    type: "telegram",
+    address: "user-123",
+    isPrimary: true,
+    externalChatId: "chat-123",
+    inviteId: null,
+    lastSeenAt: null,
+    interactionCount: 0,
+    lastInteraction: null,
+    updatedAt: null,
+    createdAt: 0,
+    ...overrides,
+  };
+}
+
+function delivery(overrides: Partial<GuardianDelivery> = {}): GuardianDelivery {
+  return {
+    channelType: "telegram",
+    contactId: "contact-1",
+    address: "user-123",
+    externalChatId: "chat-123",
+    status: "active",
+    verifiedAt: 1700000000,
+    ...overrides,
+  };
+}
+
+describe("revokeVerificationForChannel", () => {
+  beforeEach(() => {
+    mockGuardians = null;
+    mockBinding = { guardianExternalUserId: "user-123", guardianDeliveryChatId: "chat-123" };
+    mockContactChannel = { channel: channel() };
+    ipcCalls = [];
+  });
+
+  test("relays mark_channel_revoked when the gateway delivery is live", async () => {
+    mockGuardians = [delivery({ status: "active" })];
+    await revokeVerificationForChannel("telegram");
+    expect(ipcCalls.map((c) => c.method)).toContain("mark_channel_revoked");
+  });
+
+  test("skips a redundant revoke when the gateway delivery is already revoked", async () => {
+    // The gateway (SoT) says revoked — the gate must follow the gateway and
+    // not relay regardless of local state.
+    mockContactChannel = { channel: channel() };
+    mockGuardians = [delivery({ status: "revoked" })];
+    await revokeVerificationForChannel("telegram");
+    expect(ipcCalls.map((c) => c.method)).not.toContain("mark_channel_revoked");
+  });
+
+  test("skips the relay when the gateway has no delivery for the channel", async () => {
+    mockGuardians = [];
+    await revokeVerificationForChannel("telegram");
+    expect(ipcCalls.map((c) => c.method)).not.toContain("mark_channel_revoked");
+  });
+
+  test("skips the relay when the gateway is unreachable", async () => {
+    mockGuardians = null;
+    await revokeVerificationForChannel("telegram");
+    expect(ipcCalls.map((c) => c.method)).not.toContain("mark_channel_revoked");
+  });
+});
+
+describe("verifyTrustedContact already-verified gate", () => {
+  beforeEach(() => {
+    mockGuardians = null;
+    mockGwContactChannels = null;
+    mockChannel = channel();
+  });
+
+  test("short-circuits when the gateway contact channel is active and verified", async () => {
+    // Arbitrary trusted contact (non-guardian) — read from the contact-channel
+    // gateway read, which covers all contacts.
+    mockGwContactChannels = [
+      { id: "ch-1", status: "active", verifiedAt: 1700000000 },
+    ];
+    const result = await verifyTrustedContact("ch-1", "assistant-1");
+    expect(result.success).toBe(false);
+    expect(result.error).toBe("already_verified");
+  });
+
+  test("does not short-circuit when the gateway channel has no verifiedAt", async () => {
+    // The gateway channel is unverified — proceed regardless of local state.
+    mockChannel = channel();
+    mockGwContactChannels = [
+      { id: "ch-1", status: "pending", verifiedAt: null },
+    ];
+    const result = await verifyTrustedContact("ch-1", "assistant-1");
+    expect(result.error).not.toBe("already_verified");
+  });
+
+  test("does not short-circuit when the gateway has no matching channel", async () => {
+    mockGwContactChannels = [];
+    const result = await verifyTrustedContact("ch-1", "assistant-1");
+    expect(result.error).not.toBe("already_verified");
+  });
+});

package/src/daemon/handlers/config-a2a.ts

@@ -96,13 +96,11 @@ export function getA2AConfig(): A2AConfigResult {
   const config = getConfig();
   const enabled = config.a2a?.enabled ?? false;
 
+  // a2a is peer binding outside the human-trust ACL model — the gateway has no
+  // canonical a2a channel status, so channel existence is the readiness signal.
   const contacts = searchContacts({ channelType: "a2a" });
   const activeConnections = contacts.reduce((count, c) => {
-    return (
-      count +
-      c.channels.filter((ch) => ch.type === "a2a" && ch.status === "active")
-        .length
-    );
+    return count + c.channels.filter((ch) => ch.type === "a2a").length;
   }, 0);
 
   return { success: true, enabled, activeConnections };
@@ -270,12 +268,9 @@ export function redeemA2AInvite(params: {
     setA2AConfig();
   }
 
-  // 2. Check for existing active contact with this sender
+  // 2. Check for existing contact with this sender (a2a binding existence)
   const existing = findContactByAddress("a2a", params.sender.assistantId);
-  if (
-    existing &&
-    existing.channels.some((ch) => ch.type === "a2a" && ch.status === "active")
-  ) {
+  if (existing && existing.channels.some((ch) => ch.type === "a2a")) {
     return { success: true, alreadyConnected: true, contactId: existing.id };
   }
 
@@ -373,10 +368,7 @@ export async function acceptA2AInvite(params: {
   // 2. Short-circuit if already connected — avoids a network round-trip
   //    and consuming a token on the sender side.
   const existing = findContactByAddress("a2a", params.senderAssistantId);
-  if (
-    existing &&
-    existing.channels.some((ch) => ch.type === "a2a" && ch.status === "active")
-  ) {
+  if (existing && existing.channels.some((ch) => ch.type === "a2a")) {
     return { success: true, alreadyConnected: true, contactId: existing.id };
   }