@vellumai/assistant 0.10.4 → 0.10.5-dev.202607022329.d89bf2f

package/src/config/schemas/calls.ts

@@ -62,6 +62,14 @@ const CallsVoiceConfigSchema = z
       .describe(
         "How aggressively the STT provider detects the start of caller speech — low reduces false interrupts from background noise",
       ),
+    telephonyStreaming: z
+      .boolean({
+        error: "calls.voice.telephonyStreaming must be a boolean",
+      })
+      .default(true)
+      .describe(
+        "Whether phone-call audio is streamed to the STT provider in real time; disable to fall back to per-turn batch transcription",
+      ),
   })
   .describe("Voice and speech settings for phone calls");
 

package/src/config/schemas/elevenlabs.ts

@@ -1,5 +1,5 @@
 // Default ElevenLabs voice — "Amelia" (expressive, enthusiastic, British English).
-// Used by both in-app TTS and phone calls (via Twilio ConversationRelay).
+// Used by both in-app TTS and phone calls.
 export const DEFAULT_ELEVENLABS_VOICE_ID = "ZF6FPAbjXT4488VcRRnw";
 
 /** Valid conversation timeout values (seconds). Shared with voice-config-update tool. */

package/src/config/schemas/llm.ts

@@ -76,8 +76,6 @@ export const LLMCallSiteEnum = z.enum([
   "styleAnalyzer",
   "inviteInstructionGenerator",
   "skillCategoryInference",
-  "meetConsentMonitor",
-  "meetChatOpportunity",
   "inference",
   "vision",
   "trustRuleSuggestion",

package/src/config/schemas/memory-v2.ts

@@ -190,7 +190,7 @@ export const MemoryV2ConfigSchema = z
       .positive(
         "memory.v2.consolidation_interval_hours must be a positive integer",
       )
-      .default(4)
+      .default(8)
       .describe(
         "Hours between scheduled consolidation runs that synthesize buffered memories into concept pages",
       ),

package/src/config/schemas/memory-v3.ts

@@ -249,6 +249,87 @@ export const MemoryV3EntitySchema = z
     "Memory v3 entity-lane (heading-anchored named-entity match) tuning.",
   );
 
+/**
+ * Per-turn injection-gate tuning: thresholds the retrieval signals must clear
+ * for the gate to open and run the selector. The gate runs only when the
+ * `memory-v3-injection-gate` feature flag (the rollout switch) AND the
+ * `enabled` kill-switch below are both on.
+ */
+export const MemoryV3GateSchema = z
+  .object({
+    enabled: z
+      .boolean({ error: "memory.v3.gate.enabled must be a boolean" })
+      .default(true)
+      .describe(
+        "Whether the injection gate may run at all. false forces the full selection process every turn regardless of the `memory-v3-injection-gate` feature flag; true (default) defers to the flag.",
+      ),
+    denseThreshold: z
+      .number({ error: "memory.v3.gate.denseThreshold must be a number" })
+      .min(0)
+      .max(1)
+      .default(0.66)
+      .describe(
+        "Top-1 dense cosine similarity must clear this for a dense pass.",
+      ),
+    sparseThreshold: z
+      .number({ error: "memory.v3.gate.sparseThreshold must be a number" })
+      .min(0)
+      .max(1)
+      .default(0.35)
+      .describe(
+        "Normalized top-1 BM25F must clear this for any sparse signal.",
+      ),
+    sparseOnlyThreshold: z
+      .number({ error: "memory.v3.gate.sparseOnlyThreshold must be a number" })
+      .min(0)
+      .max(1)
+      .default(0.75)
+      .describe(
+        "Higher normalized-BM25F bar to pass on sparse signal alone when dense fails.",
+      ),
+    denseClusterThreshold: z
+      .number({
+        error: "memory.v3.gate.denseClusterThreshold must be a number",
+      })
+      .min(0)
+      .max(1)
+      .default(0.6)
+      .describe(
+        "Floor every top-3 dense score must clear for a borderline-cluster pass.",
+      ),
+    denseClusterMaxDelta: z
+      .number({ error: "memory.v3.gate.denseClusterMaxDelta must be a number" })
+      .min(0)
+      .max(1)
+      .default(0.02)
+      .describe(
+        "Maximum spread (max-min) within the top-3 dense cluster for a cluster pass.",
+      ),
+    topK: z
+      .number({ error: "memory.v3.gate.topK must be a number" })
+      .int("memory.v3.gate.topK must be an integer")
+      .positive("memory.v3.gate.topK must be a positive integer")
+      .default(5)
+      .describe(
+        "Number of top candidates examined per retriever (dense, sparse).",
+      ),
+    bm25NormK: z
+      .union([z.number().positive(), z.null()])
+      .default(null)
+      .describe(
+        "BM25F normalization constant k in norm = raw/(raw+k). null = built-in default (auto-calibration pending).",
+      ),
+    bypassForCore: z
+      .boolean({ error: "memory.v3.gate.bypassForCore must be a boolean" })
+      .default(false)
+      .describe(
+        "When the gate closes, still run selectPool over only the stable prefix (core/hot/fresh/skills) instead of skipping entirely. Off by default — the gate is a hard skip.",
+      ),
+  })
+  .describe(
+    "Memory v3 per-turn injection gate tuning (thresholds; the gate runs when the `memory-v3-injection-gate` feature flag AND `enabled` are both on).",
+  );
+
 // NOTE: a retired `workingSet` sub-config (maxPages/evictWindow for the old
 // per-turn carry set) used to live here. Existing user config files may still
 // contain the key; zod default unknown-key stripping accepts and ignores it,
@@ -317,6 +398,7 @@ export const MemoryV3ConfigSchema = z
       ),
     edge: MemoryV3EdgeSchema.default(MemoryV3EdgeSchema.parse({})),
     entity: MemoryV3EntitySchema.default(MemoryV3EntitySchema.parse({})),
+    gate: MemoryV3GateSchema.default(MemoryV3GateSchema.parse({})),
   })
   .describe("Memory v3 — section-grain lane retrieval");
 

package/src/config/schemas/monitoring.ts

@@ -0,0 +1,61 @@
+import { z } from "zod";
+
+/**
+ * Resource monitor configuration.
+ *
+ * The resource monitor runs as a separate OS process (a child of the assistant)
+ * that samples the container's own cgroup memory + workspace disk off the main
+ * event loop, so it keeps recording during a main-thread freeze and its samples
+ * survive an OOM SIGKILL. `assistant monitoring start`/`stop` flip
+ * `enabled` (and spawn/stop the process) to switch it on or off at runtime
+ * without a restart; when `enabled` is set the assistant also spawns it at
+ * startup.
+ */
+export const MonitoringConfigSchema = z
+  .object({
+    enabled: z
+      .boolean({ error: "monitoring.enabled must be a boolean" })
+      .default(false)
+      .describe(
+        "Whether the resource monitor process runs. When set, the assistant spawns it at startup and it samples cgroup memory + workspace disk into a ring buffer on the workspace volume. `assistant monitoring start`/`stop` flip this flag at runtime.",
+      ),
+    sampleIntervalMs: z
+      .number({ error: "monitoring.sampleIntervalMs must be a number" })
+      .int("monitoring.sampleIntervalMs must be an integer")
+      .min(50, "monitoring.sampleIntervalMs must be at least 50ms")
+      .max(10_000, "monitoring.sampleIntervalMs must be <= 10000ms")
+      .default(250)
+      .describe(
+        "How often the monitor samples memory + disk, in milliseconds. Fast (default 250ms) so vertical memory spikes are caught before an OOM kill.",
+      ),
+    ringBufferSize: z
+      .number({ error: "monitoring.ringBufferSize must be a number" })
+      .int("monitoring.ringBufferSize must be an integer")
+      .min(100, "monitoring.ringBufferSize must be at least 100")
+      .max(100_000, "monitoring.ringBufferSize must be <= 100000")
+      .default(4000)
+      .describe(
+        "How many recent samples the on-disk ring buffer retains. At the default 250ms interval, 4000 samples is ~16 minutes of history preserved across a crash.",
+      ),
+    highMemThresholdRatio: z
+      .number({
+        error: "monitoring.highMemThresholdRatio must be a number",
+      })
+      .min(0.1, "monitoring.highMemThresholdRatio must be >= 0.1")
+      .max(1, "monitoring.highMemThresholdRatio must be <= 1")
+      .default(0.75)
+      .describe(
+        "Fraction of the container memory limit at which a high-memory snapshot (cgroup stats + process tree) is captured to the workspace volume. Default 0.75 (e.g. ~6 GiB of an 8 GiB limit).",
+      ),
+    snapshotCooldownMs: z
+      .number({ error: "monitoring.snapshotCooldownMs must be a number" })
+      .int("monitoring.snapshotCooldownMs must be an integer")
+      .min(0, "monitoring.snapshotCooldownMs must be non-negative")
+      .default(30_000)
+      .describe(
+        "Minimum interval between high-memory snapshots, in milliseconds, so a sustained spike does not write a snapshot on every sample.",
+      ),
+  })
+  .describe("Resource monitor process configuration");
+
+export type MonitoringConfig = z.infer<typeof MonitoringConfigSchema>;

package/src/config/schemas/schedules.ts

@@ -0,0 +1,35 @@
+import { z } from "zod";
+
+/**
+ * Schedule worker process configuration.
+ *
+ * The schedule worker runs scheduled jobs as a separate OS process — a child
+ * of the assistant — so expensive scheduled work executes off the assistant's
+ * main event loop and keeps running during a main-thread freeze. The
+ * assistant's scheduler re-reads the flag on every tick: while it is set, the
+ * in-process scheduler leaves schedule execution to the worker (spawned at
+ * startup when set); while it is unset, the in-process scheduler runs
+ * schedules itself. `assistant schedules worker start`/`stop` flip the flag
+ * (and spawn/stop the worker process) to switch modes at runtime without a
+ * restart.
+ */
+export const ScheduleWorkerConfigSchema = z
+  .object({
+    enabled: z
+      .boolean({ error: "schedules.worker.enabled must be a boolean" })
+      .default(false)
+      .describe(
+        "Whether scheduled jobs run in a separate schedule worker OS process instead of the assistant's in-process scheduler. When set, the assistant spawns the worker at startup and its own scheduler stands down from executing schedules. `assistant schedules worker start`/`stop` flip this flag at runtime.",
+      ),
+  })
+  .describe("Schedule worker process configuration");
+
+export const SchedulesConfigSchema = z
+  .object({
+    worker: ScheduleWorkerConfigSchema.default(
+      ScheduleWorkerConfigSchema.parse({}),
+    ),
+  })
+  .describe("Scheduler configuration");
+
+export type SchedulesConfig = z.infer<typeof SchedulesConfigSchema>;

package/src/config/seed-inference-profiles.ts

@@ -58,8 +58,8 @@ const MANAGED_PROFILE_TEMPLATES: Record<string, ManagedProfileTemplate> = {
     thinking: { enabled: true, streamThinking: true },
     contextWindow: { maxInputTokens: DEFAULT_CONTEXT_WINDOW_MAX_INPUT_TOKENS },
   },
-  // Served by Anthropic Opus via managed platform inference — the most capable
-  // managed profile. The `quality-optimized` intent resolves to Opus for the
+  // Served by Anthropic via managed platform inference — the most capable
+  // managed profile. The `quality-optimized` intent resolves to Fable for the
   // `anthropic` provider.
   "quality-optimized": {
     intent: "quality-optimized",

package/src/config/skills-plugin-filter.test.ts

@@ -0,0 +1,96 @@
+import { describe, expect, test } from "bun:test";
+
+import { filterSkillsByEnabledPlugins, type SkillSummary } from "./skills.js";
+
+function makeSkill(
+  id: string,
+  overrides: Partial<SkillSummary> = {},
+): SkillSummary {
+  return {
+    id,
+    name: id,
+    displayName: id,
+    description: `Skill ${id}`,
+    directoryPath: `/skills/${id}`,
+    skillFilePath: `/skills/${id}/SKILL.md`,
+    source: "managed",
+    ...overrides,
+  };
+}
+
+function makePluginSkill(id: string, pluginId: string): SkillSummary {
+  return makeSkill(id, {
+    source: "plugin",
+    owner: { kind: "plugin", id: pluginId },
+  });
+}
+
+describe("filterSkillsByEnabledPlugins", () => {
+  test("null set is a no-op: returns the same array reference unchanged", () => {
+    const skills = [
+      makeSkill("bundled-one", { source: "bundled" }),
+      makePluginSkill("from-a", "a"),
+      makePluginSkill("from-b", "b"),
+    ];
+
+    const result = filterSkillsByEnabledPlugins(skills, null);
+
+    expect(result).toBe(skills);
+    expect(result.map((s) => s.id)).toEqual([
+      "bundled-one",
+      "from-a",
+      "from-b",
+    ]);
+  });
+
+  test("drops plugin skills whose owning plugin is outside the set", () => {
+    const skills = [
+      makeSkill("bundled-one", { source: "bundled" }),
+      makePluginSkill("from-a", "a"),
+      makePluginSkill("from-b", "b"),
+    ];
+
+    const result = filterSkillsByEnabledPlugins(skills, new Set(["a"]));
+
+    expect(result.map((s) => s.id)).toEqual(["bundled-one", "from-a"]);
+  });
+
+  test("retains non-plugin skills even when the set is empty", () => {
+    const skills = [
+      makeSkill("bundled-one", { source: "bundled" }),
+      makeSkill("managed-one", { source: "managed" }),
+      makeSkill("workspace-one", { source: "workspace" }),
+      makePluginSkill("from-a", "a"),
+    ];
+
+    const result = filterSkillsByEnabledPlugins(skills, new Set());
+
+    expect(result.map((s) => s.id)).toEqual([
+      "bundled-one",
+      "managed-one",
+      "workspace-one",
+    ]);
+  });
+
+  test("keeps every plugin skill when all owners are in the set", () => {
+    const skills = [
+      makePluginSkill("from-a", "a"),
+      makePluginSkill("from-b", "b"),
+    ];
+
+    const result = filterSkillsByEnabledPlugins(skills, new Set(["a", "b"]));
+
+    expect(result.map((s) => s.id)).toEqual(["from-a", "from-b"]);
+  });
+
+  test("does not mutate the input array when filtering", () => {
+    const skills = [
+      makePluginSkill("from-a", "a"),
+      makePluginSkill("from-b", "b"),
+    ];
+
+    filterSkillsByEnabledPlugins(skills, new Set(["a"]));
+
+    expect(skills.map((s) => s.id)).toEqual(["from-a", "from-b"]);
+  });
+});

package/src/config/skills.ts

@@ -783,6 +783,32 @@ function discoverPluginResidentSkills(): SkillSummary[] {
 
 // ─── Catalog loading ─────────────────────────────────────────────────────────
 
+/**
+ * Scope a list of skills to a conversation's per-chat plugin selection.
+ *
+ * `effectiveEnabledPluginSet` is the conversation's effective set as produced
+ * by `getEffectiveEnabledPluginSet`: `null` means there is no per-chat
+ * restriction, so the input is returned unchanged (all globally-enabled
+ * plugins apply). When a set is given, a plugin-contributed skill
+ * (`owner.kind === "plugin"`) survives only if its owning plugin id is in the
+ * set; non-plugin skills (bundled/managed/workspace/extra) are always retained.
+ *
+ * Pure: returns the same array reference when there is no restriction, and a
+ * filtered copy otherwise, so callers can pass a cached catalog without
+ * mutating the cache.
+ */
+export function filterSkillsByEnabledPlugins(
+  skills: SkillSummary[],
+  effectiveEnabledPluginSet: Set<string> | null,
+): SkillSummary[] {
+  if (effectiveEnabledPluginSet === null) return skills;
+  return skills.filter((skill) => {
+    const owner = skill.owner;
+    if (owner?.kind !== "plugin") return true;
+    return effectiveEnabledPluginSet.has(owner.id);
+  });
+}
+
 function skillSummaryFromDefinition(
   skill: SkillDefinition,
   source: SkillSource,

package/src/contacts/__tests__/member-write-relay.test.ts

@@ -17,11 +17,32 @@ type IpcCall = { method: string; params?: Record<string, unknown> };
 let ipcCalls: IpcCall[] = [];
 let ipcVerified = true;
 let ipcThrows = false;
+let createContactChannelId = "gw-ch1";
+let revokeOk = true;
 
 const ipcCallPersistentMock = mock(
   async (method: string, params?: Record<string, unknown>) => {
     ipcCalls.push({ method, params });
-    if (ipcThrows) throw new Error("gateway unavailable");
+    if (ipcThrows) {
+      throw new Error("gateway unavailable");
+    }
+    if (method === "create_contact") {
+      return { contactId: "gw-c1", channelId: createContactChannelId };
+    }
+    if (method === "mark_channel_revoked") {
+      return {
+        ok: revokeOk,
+        didWrite: true,
+        channel: {
+          id: (params?.contactChannelId as string) ?? "gw-ch1",
+          contactId: "gw-c1",
+          type: "slack",
+          address: "addr",
+          status: "revoked",
+          revokedReason: (params?.reason as string) ?? null,
+        },
+      };
+    }
     return {
       ok: true,
       verified: ipcVerified,
@@ -57,13 +78,23 @@ const upsertContactChannelMock = mock(
     return localResult;
   },
 );
+const actualContactStore = await import("../contact-store.js");
+mock.module("../contact-store.js", () => ({
+  ...actualContactStore,
+  findContactChannel: () => null,
+}));
+
 const actualContactsWrite = await import("../contacts-write.js");
 mock.module("../contacts-write.js", () => ({
   ...actualContactsWrite,
   upsertContactChannel: upsertContactChannelMock,
 }));
 
-const { activateMemberChannel } = await import("../member-write-relay.js");
+const {
+  activateMemberChannel,
+  blockSenderChannel,
+  seedUnverifiedMemberChannel,
+} = await import("../member-write-relay.js");
 
 describe("activateMemberChannel gateway-first relay", () => {
   beforeEach(() => {
@@ -86,7 +117,6 @@ describe("activateMemberChannel gateway-first relay", () => {
       externalChatId: "chat-1",
       displayName: "Mom",
       contactId: "target-mom",
-      inviteId: "inv-1",
       verifiedVia: "invite",
     });
 
@@ -121,7 +151,6 @@ describe("activateMemberChannel gateway-first relay", () => {
       externalChatId: "chat-1",
       displayName: "Mom",
       username: undefined,
-      inviteId: "inv-1",
       contactId: "target-mom",
     });
     for (const aclKey of [
@@ -224,3 +253,126 @@ describe("activateMemberChannel gateway-first relay", () => {
     });
   });
 });
+
+describe("seedUnverifiedMemberChannel gateway-first relay", () => {
+  beforeEach(() => {
+    ipcCalls = [];
+    ipcThrows = false;
+    ipcCallPersistentMock.mockClear();
+  });
+
+  test("relays to the gateway create_contact IPC with channelType + address + displayName", async () => {
+    await seedUnverifiedMemberChannel({
+      sourceChannel: "telegram",
+      externalUserId: "user-1",
+      displayName: "Alice",
+    });
+
+    expect(ipcCalls).toEqual([
+      {
+        method: "create_contact",
+        params: {
+          channelType: "telegram",
+          address: "user-1",
+          displayName: "Alice",
+        },
+      },
+    ]);
+  });
+
+  test("omits displayName when not supplied", async () => {
+    await seedUnverifiedMemberChannel({
+      sourceChannel: "slack",
+      externalUserId: "U123",
+    });
+
+    expect(ipcCalls).toHaveLength(1);
+    expect(ipcCalls[0]!.method).toBe("create_contact");
+    expect(ipcCalls[0]!.params).toEqual({
+      channelType: "slack",
+      address: "U123",
+    });
+    expect("displayName" in (ipcCalls[0]!.params ?? {})).toBe(false);
+  });
+
+  test("swallows gateway errors (best-effort) so a deny is never blocked", async () => {
+    ipcThrows = true;
+
+    // Must not throw — the gateway owns the ACL verdict and a failed seed must
+    // not fail the guardian's deny decision.
+    await seedUnverifiedMemberChannel({
+      sourceChannel: "telegram",
+      externalUserId: "user-1",
+    });
+
+    expect(ipcCalls).toHaveLength(1);
+  });
+});
+
+describe("blockSenderChannel gateway-first relay", () => {
+  beforeEach(() => {
+    ipcCalls = [];
+    ipcThrows = false;
+    createContactChannelId = "gw-ch1";
+    revokeOk = true;
+  });
+
+  test("ensures a contact row exists, then revokes the gateway channel", async () => {
+    const result = await blockSenderChannel({
+      sourceChannel: "slack",
+      externalUserId: "U-BLOCKED",
+      displayName: "Mallory",
+      reason: "introduction_block",
+    });
+
+    expect(result.revoked).toBe(true);
+    expect(ipcCalls.map((c) => c.method)).toEqual([
+      "create_contact",
+      "mark_channel_revoked",
+    ]);
+    expect(ipcCalls[0]!.params).toEqual({
+      channelType: "slack",
+      address: "U-BLOCKED",
+      displayName: "Mallory",
+    });
+    expect(ipcCalls[1]!.params).toEqual({
+      contactChannelId: "gw-ch1",
+      reason: "introduction_block",
+    });
+  });
+
+  test("fails closed when the gateway returns no channel id", async () => {
+    createContactChannelId = "";
+
+    const result = await blockSenderChannel({
+      sourceChannel: "slack",
+      externalUserId: "U-BLOCKED",
+    });
+
+    expect(result.revoked).toBe(false);
+    // The revoke must not be attempted against an unknown channel.
+    expect(ipcCalls.map((c) => c.method)).toEqual(["create_contact"]);
+  });
+
+  test("fails closed when the gateway relay throws", async () => {
+    ipcThrows = true;
+
+    const result = await blockSenderChannel({
+      sourceChannel: "slack",
+      externalUserId: "U-BLOCKED",
+    });
+
+    expect(result.revoked).toBe(false);
+  });
+
+  test("fails closed when the revoke is refused", async () => {
+    revokeOk = false;
+
+    const result = await blockSenderChannel({
+      sourceChannel: "slack",
+      externalUserId: "U-BLOCKED",
+    });
+
+    expect(result.revoked).toBe(false);
+  });
+});

package/src/contacts/canonical-guardian-store.ts

@@ -64,6 +64,8 @@ export interface CanonicalGuardianRequest {
   riskLevel: string | null;
   activityText: string | null;
   executionTarget: string | null;
+  /** JSON-encoded requester identity signals (see introduction-policy.ts). */
+  requesterSignals: string | null;
   status: CanonicalRequestStatus;
   answerText: string | null;
   decidedByExternalUserId: string | null;
@@ -158,6 +160,7 @@ function rowToRequest(
     riskLevel: row.riskLevel,
     activityText: row.activityText,
     executionTarget: row.executionTarget,
+    requesterSignals: row.requesterSignals,
     status: row.status as CanonicalRequestStatus,
     answerText: row.answerText,
     decidedByExternalUserId: row.decidedByExternalUserId,
@@ -209,6 +212,7 @@ interface CreateCanonicalGuardianRequestParams {
   riskLevel?: string;
   activityText?: string;
   executionTarget?: string;
+  requesterSignals?: string;
   status?: CanonicalRequestStatus;
   answerText?: string;
   decidedByExternalUserId?: string;
@@ -267,6 +271,7 @@ export function createCanonicalGuardianRequest(
     riskLevel: params.riskLevel ?? null,
     activityText: params.activityText ?? null,
     executionTarget: params.executionTarget ?? null,
+    requesterSignals: params.requesterSignals ?? null,
     status: params.status ?? ("pending" as const),
     answerText: params.answerText ?? null,
     decidedByExternalUserId: params.decidedByExternalUserId ?? null,