@vellumai/assistant 0.11.3 → 0.11.4-dev.202608190019.b94dbf2

package/src/__tests__/init-feature-flag-overrides.test.ts

@@ -11,6 +11,7 @@ import {
   clearFeatureFlagOverridesCache,
   initFeatureFlagOverrides,
   isAssistantFeatureFlagEnabled,
+  refreshOverridesFromGateway,
 } from "../config/assistant-feature-flags.js";
 import { mockGatewayIpc, resetMockGatewayIpc } from "./mock-gateway-ipc.js";
 
@@ -110,3 +111,51 @@ describe("initFeatureFlagOverrides", () => {
     expect(isAssistantFeatureFlagEnabled("second-call", config)).toBe(false);
   });
 });
+
+describe("refreshOverridesFromGateway", () => {
+  it("replaces the cache with the new gateway values", async () => {
+    mockGatewayIpc({ "moving-flag": true });
+    await initFeatureFlagOverrides();
+
+    resetMockGatewayIpc();
+    mockGatewayIpc({ "moving-flag": false });
+
+    expect(await refreshOverridesFromGateway()).toBe(true);
+
+    const config = {} as any;
+    expect(isAssistantFeatureFlagEnabled("moving-flag", config)).toBe(false);
+  });
+
+  it("keeps the last known values when the refresh fails", async () => {
+    mockGatewayIpc({ "moving-flag": true });
+    await initFeatureFlagOverrides();
+
+    resetMockGatewayIpc();
+    mockGatewayIpc(null, { error: true });
+
+    expect(await refreshOverridesFromGateway()).toBe(false);
+
+    // A failed refresh must not drop the flag to its registry default: a
+    // value the assistant selects behavior from (an experiment arm, a kill
+    // switch) would otherwise flip on one timed-out IPC call.
+    const config = {} as any;
+    expect(isAssistantFeatureFlagEnabled("moving-flag", config)).toBe(true);
+  });
+
+  it("keeps the cache readable for the whole call", async () => {
+    mockGatewayIpc({ "moving-flag": true });
+    await initFeatureFlagOverrides();
+
+    resetMockGatewayIpc();
+    mockGatewayIpc({ "moving-flag": false });
+
+    const config = {} as any;
+    const inFlight = refreshOverridesFromGateway();
+    // A sync read landing mid-refresh sees the previous values, never an
+    // empty cache.
+    expect(isAssistantFeatureFlagEnabled("moving-flag", config)).toBe(true);
+
+    await inFlight;
+    expect(isAssistantFeatureFlagEnabled("moving-flag", config)).toBe(false);
+  });
+});

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

@@ -67,6 +67,7 @@ const { registerDefaultPluginInjectors } =
   await import("../plugins/defaults/index.js");
 import { eq } from "drizzle-orm";
 
+import type { InterfaceId } from "../channels/types.js";
 import {
   clearConversations,
   setConversation,
@@ -86,6 +87,7 @@ import type { Message } from "../providers/types.js";
 import { getSubagentManager } from "../subagent/index.js";
 import type { SubagentState } from "../subagent/types.js";
 import { getWorkspacePromptPath } from "../util/platform.js";
+import { asConversation } from "./helpers/mock-conversation.js";
 
 // `applyRuntimeInjections` self-resolves the Slack active-thread focus block
 // from the persisted message rows, so the schema must exist for Slack-channel
@@ -153,26 +155,30 @@ function seedWorkspaceContext(
   text: string,
   currentTurnTemporalSnapshot?: {
     clientTimezone: string | null;
+    timeSinceLastMessage: string | null;
   },
-  interfaceName?: string,
+  interfaceName?: InterfaceId,
 ): void {
-  setConversation(TEST_CONVERSATION_ID, {
-    conversationId: TEST_CONVERSATION_ID,
-    workingDir: "/sandbox",
-    workspaceTopLevelContext: text,
-    workspaceTopLevelDirty: false,
-    currentTurnTemporalSnapshot,
-    currentTurnInterfaceContext: interfaceName
-      ? {
-          userMessageInterface: interfaceName,
-          assistantMessageInterface: interfaceName,
-        }
-      : undefined,
-    // Mirrors Conversation.getSubagentChildren: the `<active_subagents>` block
-    // is sourced from the live conversation, which delegates to the manager.
-    getSubagentChildren: () =>
-      getSubagentManager().getChildrenOf(TEST_CONVERSATION_ID),
-  } as never);
+  setConversation(
+    TEST_CONVERSATION_ID,
+    asConversation({
+      conversationId: TEST_CONVERSATION_ID,
+      workingDir: "/sandbox",
+      workspaceTopLevelContext: text,
+      workspaceTopLevelDirty: false,
+      currentTurnTemporalSnapshot,
+      currentTurnInterfaceContext: interfaceName
+        ? {
+            userMessageInterface: interfaceName,
+            assistantMessageInterface: interfaceName,
+          }
+        : undefined,
+      // Mirrors Conversation.getSubagentChildren: the `<active_subagents>` block
+      // is sourced from the live conversation, which delegates to the manager.
+      getSubagentChildren: () =>
+        getSubagentManager().getChildrenOf(TEST_CONVERSATION_ID),
+    }),
+  );
 }
 
 // `applyRuntimeInjections` gates the `<turn_context>` block on the live
@@ -181,13 +187,19 @@ function seedWorkspaceContext(
 // fall back to the runtime-assembly fallback conversation, so seed the snapshot
 // there.
 function seedFallbackTemporalSnapshot(): void {
-  setConversation("runtime-assembly-fallback", {
-    conversationId: "runtime-assembly-fallback",
-    workingDir: "/sandbox",
-    workspaceTopLevelContext: "",
-    workspaceTopLevelDirty: false,
-    currentTurnTemporalSnapshot: { clientTimezone: null },
-  } as never);
+  setConversation(
+    "runtime-assembly-fallback",
+    asConversation({
+      conversationId: "runtime-assembly-fallback",
+      workingDir: "/sandbox",
+      workspaceTopLevelContext: "",
+      workspaceTopLevelDirty: false,
+      currentTurnTemporalSnapshot: {
+        clientTimezone: null,
+        timeSinceLastMessage: null,
+      },
+    }),
+  );
 }
 
 // Persist Slack-channel rows for the turn conversation so
@@ -484,7 +496,11 @@ describe("injector chain", () => {
     seedSubagentChild(TEST_CONVERSATION_ID, subagentChild);
     const subagentBlock = buildSubagentStatusBlock([subagentChild])!;
 
-    seedWorkspaceContext(workspaceText, { clientTimezone: null }, "macos");
+    seedWorkspaceContext(
+      workspaceText,
+      { clientTimezone: null, timeSinceLastMessage: null },
+      "macos",
+    );
     const result = await applyRuntimeInjections(runMessages, {
       ...makeTurnContext(),
     });
@@ -562,20 +578,23 @@ describe("injector chain", () => {
         createdAt: 1700000005_000,
       },
     ]);
-    setConversation(TEST_CONVERSATION_ID, {
-      conversationId: TEST_CONVERSATION_ID,
-      workingDir: "/sandbox",
-      workspaceTopLevelContext: "",
-      workspaceTopLevelDirty: false,
-      trustContext: { trustClass: "guardian" },
-      channelCapabilities: {
-        channel: "slack",
-        dashboardCapable: false,
-        supportsDynamicUi: false,
-        supportsVoiceInput: false,
-        chatType: "channel",
-      },
-    } as never);
+    setConversation(
+      TEST_CONVERSATION_ID,
+      asConversation({
+        conversationId: TEST_CONVERSATION_ID,
+        workingDir: "/sandbox",
+        workspaceTopLevelContext: "",
+        workspaceTopLevelDirty: false,
+        trustContext: { trustClass: "guardian", sourceChannel: "vellum" },
+        channelCapabilities: {
+          channel: "slack",
+          dashboardCapable: false,
+          supportsDynamicUi: false,
+          supportsVoiceInput: false,
+          chatType: "channel",
+        },
+      }),
+    );
     const result = await applyRuntimeInjections(originalRun, {
       ...makeTurnContext(),
     });
@@ -614,7 +633,10 @@ describe("injector chain", () => {
       timestamp: FIXED_TURN_TIMESTAMP,
       interfaceName: "web",
     });
-    seedWorkspaceContext("", { clientTimezone: null });
+    seedWorkspaceContext("", {
+      clientTimezone: null,
+      timeSinceLastMessage: null,
+    });
     seedSubagentChild(
       TEST_CONVERSATION_ID,
       makeSubagentState("sub-1", "worker", "running"),

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

@@ -14,6 +14,7 @@ mock.module("../daemon/date-context.js", () => ({
   formatTurnTimestamp: () => FIXED_TURN_TIMESTAMP,
 }));
 
+import type { Conversation } from "../daemon/conversation.js";
 import {
   clearConversations,
   setConversation,
@@ -39,6 +40,7 @@ import {
 } from "../plugins/defaults/workspace/injectors.js";
 import type { Injector, TurnContext } from "../plugins/types.js";
 import type { Message } from "../providers/types.js";
+import { asConversation } from "./helpers/mock-conversation.js";
 
 // `applyRuntimeInjections` self-resolves the Slack active-thread focus block
 // from the persisted message rows, so the schema must exist for Slack-channel
@@ -90,38 +92,23 @@ const diskPressureInjector = findInjector("disk-pressure-warning");
 // turn can exercise both; the seed helpers mutate and re-register the same
 // instance. An empty (non-dirty) workspace cache resolves to no block, so
 // disk-pressure-only tests don't trigger a directory scan.
-let liveConversation: {
-  conversationId: string;
-  workingDir: string;
-  workspaceTopLevelContext: string | null;
-  workspaceTopLevelDirty: boolean;
-  diskPressureCleanupModeActive: boolean;
-  channelCapabilities?: ChannelCapabilities;
-  trustContext?: { trustClass: string };
-  currentTurnTemporalSnapshot?: {
-    clientTimezone: string | null;
-  };
-  currentTurnInterfaceContext?: {
-    userMessageInterface: string;
-    assistantMessageInterface: string;
-  };
-};
+let liveConversation: Conversation;
 
 function resetLiveConversation(): void {
-  liveConversation = {
+  liveConversation = asConversation({
     conversationId: TEST_CONVERSATION_ID,
     workingDir: "/workspace",
     workspaceTopLevelContext: "",
     workspaceTopLevelDirty: false,
     diskPressureCleanupModeActive: false,
-    trustContext: { trustClass: "guardian" },
+    trustContext: { trustClass: "guardian", sourceChannel: "vellum" },
     // The unified-turn-context injector sources the interface label from the
     // live conversation's turn interface context; match the expected blocks.
     currentTurnInterfaceContext: {
       userMessageInterface: "macos",
       assistantMessageInterface: "macos",
     },
-  };
+  });
 }
 
 // `applyRuntimeInjections` gates the `<turn_context>` block on the live
@@ -130,24 +117,25 @@ function resetLiveConversation(): void {
 function seedTemporalSnapshot(): void {
   liveConversation.currentTurnTemporalSnapshot = {
     clientTimezone: null,
+    timeSinceLastMessage: null,
   };
-  setConversation(TEST_CONVERSATION_ID, liveConversation as never);
+  setConversation(TEST_CONVERSATION_ID, liveConversation);
 }
 
 function seedChannelCapabilities(caps: ChannelCapabilities): void {
   liveConversation.channelCapabilities = caps;
-  setConversation(TEST_CONVERSATION_ID, liveConversation as never);
+  setConversation(TEST_CONVERSATION_ID, liveConversation);
 }
 
 function seedDiskPressure(cleanupModeActive: boolean): void {
   liveConversation.diskPressureCleanupModeActive = cleanupModeActive;
-  setConversation(TEST_CONVERSATION_ID, liveConversation as never);
+  setConversation(TEST_CONVERSATION_ID, liveConversation);
 }
 
 function seedWorkspaceContext(text: string): void {
   liveConversation.workspaceTopLevelContext = text;
   liveConversation.workspaceTopLevelDirty = false;
-  setConversation(TEST_CONVERSATION_ID, liveConversation as never);
+  setConversation(TEST_CONVERSATION_ID, liveConversation);
 }
 
 // Persist Slack-channel rows for the turn conversation so

package/src/__tests__/inline-skill-load-permissions.test.ts

@@ -26,6 +26,7 @@ process.env.GATEWAY_SECURITY_DIR = join(testDir, "protected");
 
 import {
   installIpcMock,
+  lastIpcParams,
   mockIpcResponse,
 } from "./helpers/gateway-classify-mock.js";
 installIpcMock();
@@ -33,6 +34,7 @@ mockIpcResponse("classify_risk", {
   risk: "low",
   reason: "skill_load",
   matchType: "unknown",
+  scopeOptions: [],
 });
 mockIpcResponse("get_global_thresholds", {
   interactive: "low",
@@ -42,8 +44,7 @@ mockIpcResponse("get_global_thresholds", {
 
 // ── Imports (after mocks) ─────────────────────────────────────────────────
 
-import { check, generateAllowlistOptions } from "../permissions/checker.js";
-import { clearRiskCache } from "../permissions/checker.js";
+import { check, classifyRisk } from "../permissions/checker.js";
 import { _clearGlobalCacheForTesting } from "../permissions/gateway-threshold-reader.js";
 import { setOverridesForTesting } from "./feature-flag-test-helpers.js";
 
@@ -82,13 +83,34 @@ function writeDynamicSkill(
   );
 }
 
+/**
+ * What the gateway skill classifier answers for a load whose params carry
+ * `hasInlineExpansions` (gateway/src/risk/skill-risk-classifier.ts): High,
+ * registry-matched. The daemon does not elevate locally; the gateway is the
+ * one place a dynamic load becomes High.
+ */
+function mockDynamicSkillClassification(): void {
+  mockIpcResponse("classify_risk", {
+    risk: "high",
+    reason:
+      "Skill load with inline command expansions (executes shell commands at load time)",
+    matchType: "registry",
+    scopeOptions: [],
+  });
+}
+
 // ── Tests ─────────────────────────────────────────────────────────────────
 
 describe("inline-command skill_load permissions", () => {
   beforeEach(() => {
-    clearRiskCache();
     _clearGlobalCacheForTesting();
     setOverridesForTesting({});
+    mockIpcResponse("classify_risk", {
+      risk: "low",
+      reason: "skill_load",
+      matchType: "unknown",
+      scopeOptions: [],
+    });
     mockIpcResponse("get_global_thresholds", {
       interactive: "low",
       autonomous: "medium",
@@ -116,6 +138,7 @@ describe("inline-command skill_load permissions", () => {
     test("an uncovered dynamic skill prompts below Full access", async () => {
       ensureSkillsDir();
       writeDynamicSkill("dynamic-prompt", "Dynamic Prompt Skill");
+      mockDynamicSkillClassification();
 
       // interactive threshold "low" (beforeEach) is below the High risk of an
       // inline-command load, so it prompts.
@@ -131,6 +154,7 @@ describe("inline-command skill_load permissions", () => {
     test("an uncovered dynamic skill runs at Full access (high threshold)", async () => {
       ensureSkillsDir();
       writeDynamicSkill("dynamic-full", "Dynamic Full Access Skill");
+      mockDynamicSkillClassification();
       mockIpcResponse("get_global_thresholds", {
         interactive: "high",
         autonomous: "high",
@@ -155,6 +179,7 @@ describe("inline-command skill_load permissions", () => {
         risk: "low",
         reason: "user rule: skill_load_dynamic:dynamic-covered",
         matchType: "user_rule",
+        scopeOptions: [],
       });
 
       const result = await check(
@@ -163,17 +188,12 @@ describe("inline-command skill_load permissions", () => {
         "/tmp",
       );
       expect(result.decision).toBe("allow");
-
-      mockIpcResponse("classify_risk", {
-        risk: "low",
-        reason: "skill_load",
-        matchType: "unknown",
-      });
     });
 
     test("dynamic skill prompts in strict mode (no matching rule)", async () => {
       ensureSkillsDir();
       writeDynamicSkill("dynamic-strict", "Dynamic Strict Skill");
+      mockDynamicSkillClassification();
       mockIpcResponse("get_global_thresholds", {
         interactive: "none",
         autonomous: "none",
@@ -211,43 +231,34 @@ describe("inline-command skill_load permissions", () => {
 
   // ── Allowlist options ────────────────────────────────────────────────
 
-  describe("allowlist options", () => {
-    test("dynamic skill allowlist options use skill_load_dynamic: namespace", async () => {
+  describe("skill metadata sent to the gateway", () => {
+    // The gateway picks the `skill_load_dynamic:` namespace off these flags,
+    // so what the daemon reads from disk decides which rule namespace a user
+    // can save into.
+    test("a skill with inline expansions is sent as dynamic", async () => {
       ensureSkillsDir();
       writeDynamicSkill("dynamic-opts", "Dynamic Opts Skill");
 
-      const options = await generateAllowlistOptions("skill_load", {
-        skill: "dynamic-opts",
-      });
+      await classifyRisk("skill_load", { skill: "dynamic-opts" });
 
-      expect(options.length).toBeGreaterThanOrEqual(1);
-      // All options should use skill_load_dynamic: prefix
-      for (const option of options) {
-        expect(option.pattern).toMatch(/^skill_load_dynamic:/);
-      }
-
-      // Should have an any-version option
-      const anyVersionOption = options.find(
-        (o) => o.pattern === "skill_load_dynamic:dynamic-opts",
-      );
-      expect(anyVersionOption).toBeDefined();
-      expect(anyVersionOption!.description).toBe("This skill (any version)");
+      const metadata = lastIpcParams("classify_risk")?.skillMetadata as
+        | { hasInlineExpansions: boolean; isDynamic: boolean }
+        | undefined;
+      expect(metadata?.hasInlineExpansions).toBe(true);
+      expect(metadata?.isDynamic).toBe(true);
     });
 
-    test("plain skill allowlist options use skill_load: namespace", async () => {
+    test("a plain skill is not sent as dynamic", async () => {
       ensureSkillsDir();
       writePlainSkill("plain-opts", "Plain Opts Skill");
 
-      const options = await generateAllowlistOptions("skill_load", {
-        skill: "plain-opts",
-      });
+      await classifyRisk("skill_load", { skill: "plain-opts" });
 
-      expect(options.length).toBeGreaterThanOrEqual(1);
-      // Should use skill_load: prefix, not skill_load_dynamic:
-      for (const option of options) {
-        expect(option.pattern).toMatch(/^skill_load:/);
-        expect(option.pattern).not.toMatch(/^skill_load_dynamic:/);
-      }
+      const metadata = lastIpcParams("classify_risk")?.skillMetadata as
+        | { hasInlineExpansions: boolean; isDynamic: boolean }
+        | undefined;
+      expect(metadata?.hasInlineExpansions).toBe(false);
+      expect(metadata?.isDynamic).toBe(false);
     });
   });
 });

package/src/__tests__/llm-context-resolution.test.ts

@@ -1,4 +1,21 @@
-import { describe, expect, test } from "bun:test";
+import { describe, expect, mock, test } from "bun:test";
+
+// Entry-name providers resolve context limits through their row's kind, so
+// the tests control the row store directly. A dangling label (no row) falls
+// back to the model's catalog owner.
+const connectionRows = new Map<string, { name: string; provider: string }>([
+  ["openai-work", { name: "openai-work", provider: "openai" }],
+  ["my-endpoint", { name: "my-endpoint", provider: "openai-compatible" }],
+]);
+mock.module("../persistence/db-connection.js", () => ({
+  getDb: () => ({}),
+}));
+mock.module("../providers/inference/connections.js", () => ({
+  getConnection: (_db: unknown, name: string) =>
+    connectionRows.get(name) ?? null,
+  listConnections: () => [],
+  canonicalVellumConnection: () => null,
+}));
 
 import { resolveEffectiveContextWindow } from "../config/llm-context-resolution.js";
 import { LLMSchema } from "../config/schemas/llm.js";
@@ -131,6 +148,61 @@ describe("resolveEffectiveContextWindow", () => {
     expect(resolved.modelMaxInputTokens).toBe(1050000);
   });
 
+  test("an entry of a catalog kind resolves the model's own context limits", () => {
+    // The entries collapse stores connection names in the provider field;
+    // the row's kind carries the model's limits, so an entry label must not
+    // fall back to the 200k default when its kind serves the model.
+    const llm = LLMSchema.parse({
+      profiles: {
+        work: { provider: "openai-work", model: "gpt-5.5" },
+      },
+      activeProfile: "work",
+    });
+
+    const resolved = resolveEffectiveContextWindow({
+      llm,
+      callSite: "mainAgent",
+    });
+
+    expect(resolved.modelMaxInputTokens).toBe(1050000);
+    expect(resolved.maxOutputTokens).toBeDefined();
+  });
+
+  test("a custom-endpoint entry keeps the conservative default for a catalog-colliding model id", () => {
+    // An openai-compatible endpoint's "gpt-5.5" is not OpenAI's; inheriting
+    // the built-in 1.05M limit would let oversized requests through.
+    const llm = LLMSchema.parse({
+      profiles: {
+        custom: { provider: "my-endpoint", model: "gpt-5.5" },
+      },
+      activeProfile: "custom",
+    });
+
+    const resolved = resolveEffectiveContextWindow({
+      llm,
+      callSite: "mainAgent",
+    });
+
+    expect(resolved.modelMaxInputTokens).toBe(200000);
+    expect(resolved.maxOutputTokens).toBeUndefined();
+  });
+
+  test("a label with no row falls back to the model's catalog owner", () => {
+    const llm = LLMSchema.parse({
+      profiles: {
+        gone: { provider: "deleted-entry", model: "gpt-5.5" },
+      },
+      activeProfile: "gone",
+    });
+
+    const resolved = resolveEffectiveContextWindow({
+      llm,
+      callSite: "mainAgent",
+    });
+
+    expect(resolved.modelMaxInputTokens).toBe(1050000);
+  });
+
   test("unknown catalog model falls back safely to the default 200k cap", () => {
     const llm = LLMSchema.parse({
       callSites: {

package/src/__tests__/llm-schema.test.ts

@@ -123,11 +123,14 @@ describe("LLMSchema", () => {
     expect(parsed.profileOrder).toEqual(["fast", "stale"]);
   });
 
-  test("invalid provider rejected", () => {
+  test("an unknown provider parses (read tolerance for entry names)", () => {
+    // The open provider schema keeps the profile; write-time membership is
+    // enforced at the profiles route and the config-write choke point, and
+    // dispatch resolves the value as a connection entry name.
     const result = LLMSchema.safeParse({
       profiles: { mine: { provider: "bogus-provider" } },
     });
-    expect(result.success).toBe(false);
+    expect(result.success).toBe(true);
   });
 
   test("invalid temperature (negative) rejected", () => {

package/src/__tests__/managed-skill-lifecycle.test.ts

@@ -47,6 +47,9 @@ import { skillLoadTool } from "../tools/skills/load.js";
 import { executeScaffoldManagedSkill } from "../tools/skills/scaffold-managed.js";
 import type { ToolContext } from "../tools/types.js";
 
+/** scaffold_managed_skill requires activation hints; a fixed set for tests. */
+const HINTS = ["user asks to run the lifecycle test procedure"];
+
 function makeContext(): ToolContext {
   return {
     workingDir: "/tmp",
@@ -126,6 +129,7 @@ Run the custom lifecycle verification procedure.
         name: "Lifecycle Test",
         description: "Integration test skill.",
         body_markdown: "Run the lifecycle test procedure.",
+        activation_hints: HINTS,
         emoji: "🧪",
       },
       makeContext(),
@@ -185,6 +189,7 @@ Run the custom lifecycle verification procedure.
         name: "V1",
         description: "Version 1.",
         body_markdown: "Original body.",
+        activation_hints: HINTS,
       },
       ctx,
     );
@@ -196,6 +201,7 @@ Run the custom lifecycle verification procedure.
         name: "V2",
         description: "Version 2.",
         body_markdown: "Updated body.",
+        activation_hints: HINTS,
         overwrite: true,
       },
       ctx,
@@ -241,6 +247,7 @@ Run the custom lifecycle verification procedure.
         description: "Created from scaffold.",
         body_markdown:
           "This skill was dynamically created.\n\nRun: `echo chain-test-ok`",
+        activation_hints: HINTS,
       },
       ctx,
     );