@vellumai/assistant 0.11.3 → 0.11.4-staging.1

package/src/__tests__/skills.test.ts

@@ -825,6 +825,38 @@ describe("always-candidate frontmatter parsing", () => {
       .map(({ id, chars }) => `${id}: ${chars}`);
     expect(overrun).toEqual([]);
   });
+
+  test("the bundled acp skill's card fits the default budget", async () => {
+    // `acp` owns Claude Code and Codex setup, sign-in, and delegation, and the
+    // terms that route those turns to it live in this card. The card is
+    // hard-truncated at the default budget, so an overrun drops the trailing
+    // hints and the whole avoid-when list from what the selector sees.
+    const { DEFAULT_CARD_CHARS, buildSkillContent } =
+      await import("../plugins/defaults/memory/substrate/skill-content.js");
+    const acp = loadSkillCatalog().find((skill) => skill.id === "acp");
+    expect(acp).toBeDefined();
+
+    // A card that overran is cut to exactly the budget, so staying under it is
+    // what proves nothing was dropped. `avoid-when` is appended last and is
+    // therefore the first content a truncation eats.
+    const card = buildSkillContent(acp!);
+    expect(card.length).toBeLessThan(DEFAULT_CARD_CHARS);
+    expect(card).toContain("Avoid when:");
+  });
+
+  test("the bundled acp card carries its setup and sign-in vocabulary", async () => {
+    // A "configure Claude Code" or "let's do the auth" turn only reaches this
+    // skill if the card actually says it covers setup and authentication;
+    // delegation-only wording routes those turns to a terminal skill instead.
+    const { buildSkillContent } =
+      await import("../plugins/defaults/memory/substrate/skill-content.js");
+    const acp = loadSkillCatalog().find((skill) => skill.id === "acp");
+    const card = buildSkillContent(acp!).toLowerCase();
+
+    for (const term of ["set up", "install", "authenticate", "connect"]) {
+      expect(card).toContain(term);
+    }
+  });
 });
 
 describe("bundled skill categories", () => {

package/src/__tests__/slack-edit-ordering-characterization.test.ts

@@ -59,7 +59,6 @@ async function applyEdit(eventId: string, content: string): Promise<void> {
     conversationExternalId: CHANNEL,
     externalMessageId: eventId,
     sourceMessageId: ORIGINAL_TS,
-    canonicalAssistantId: "self",
     assistantId: "self",
     content,
   });

package/src/__tests__/subagent-call-site-routing.test.ts

@@ -184,8 +184,11 @@ import {
   clearConversations,
   setConversation,
 } from "../daemon/conversation-registry.js";
+import type { TrustContext } from "../daemon/trust-context-types.js";
 import { CallSiteRoutingProvider } from "../providers/call-site-routing.js";
 import { SubagentManager } from "../subagent/manager.js";
+import { mockAuthContext } from "./helpers/mock-actor-context.js";
+import { asConversation } from "./helpers/mock-conversation.js";
 
 // Seed the workspace `llm` config per-case. The real loader schema-merges the
 // raw fragment over defaults exactly as the code path reads it.
@@ -304,26 +307,29 @@ describe("SubagentManager — provider call-site routing", () => {
   test("copies parent guardian and auth context into spawned conversation", async () => {
     setLlmConfig(makeLlmFixture());
 
-    const parentTrustContext = {
+    const parentTrustContext: TrustContext = {
       sourceChannel: "vellum",
       trustClass: "guardian",
       guardianPrincipalId: "guardian-1",
       guardianExternalUserId: "guardian-1",
     };
-    const parentAuthContext = {
+    const parentAuthContext = mockAuthContext({
       subject: "local:self:parent-perms",
       actorPrincipalId: "guardian-1",
-    };
+    });
 
     capturedConversations.length = 0;
     clearConversations();
     const manager = new SubagentManager();
-    setConversation("parent-perms", {
-      trustContext: parentTrustContext,
-      getAuthContext: () => parentAuthContext,
-      assistantId: "self",
-      getCurrentSystemPrompt: () => "parent system",
-    } as any);
+    setConversation(
+      "parent-perms",
+      asConversation({
+        trustContext: parentTrustContext,
+        getAuthContext: () => parentAuthContext,
+        assistantId: "self",
+        getCurrentSystemPrompt: () => "parent system",
+      }),
+    );
 
     await manager.spawn(
       {
@@ -354,11 +360,14 @@ describe("SubagentManager — provider call-site routing", () => {
     capturedConversations.length = 0;
     clearConversations();
     const manager = new SubagentManager();
-    setConversation("parent-scoped", {
-      enabledPlugins: parentScope,
-      getAuthContext: () => undefined,
-      getCurrentSystemPrompt: () => "parent system",
-    } as any);
+    setConversation(
+      "parent-scoped",
+      asConversation({
+        enabledPlugins: parentScope,
+        getAuthContext: () => undefined,
+        getCurrentSystemPrompt: () => "parent system",
+      }),
+    );
 
     await manager.spawn(
       {
@@ -383,11 +392,14 @@ describe("SubagentManager — provider call-site routing", () => {
     capturedConversations.length = 0;
     clearConversations();
     const manager = new SubagentManager();
-    setConversation("parent-unscoped", {
-      enabledPlugins: null,
-      getAuthContext: () => undefined,
-      getCurrentSystemPrompt: () => "parent system",
-    } as any);
+    setConversation(
+      "parent-unscoped",
+      asConversation({
+        enabledPlugins: null,
+        getAuthContext: () => undefined,
+        getCurrentSystemPrompt: () => "parent system",
+      }),
+    );
 
     await manager.spawn(
       {

package/src/__tests__/subagent-spawn-and-await.test.ts

@@ -207,6 +207,7 @@ import {
   setConversation,
 } from "../daemon/conversation-registry.js";
 import { SubagentAbortedError, SubagentManager } from "../subagent/manager.js";
+import { asConversation } from "./helpers/mock-conversation.js";
 
 function makeConfig(overrides: Record<string, unknown> = {}) {
   return {
@@ -229,16 +230,19 @@ function registerFakeParent(parentConversationId: string): {
   enqueuedCount: () => number;
 } {
   let enqueued = 0;
-  setConversation(parentConversationId, {
-    // Accessors read by setUpSubagent when copying trust/auth context.
-    trustContext: undefined,
-    getAuthContext: () => undefined,
-    assistantId: undefined,
-    enqueueMessage: () => {
-      enqueued += 1;
-      return { rejected: false, queued: true };
-    },
-  } as never);
+  setConversation(
+    parentConversationId,
+    asConversation({
+      // Accessors read by setUpSubagent when copying trust/auth context.
+      trustContext: undefined,
+      getAuthContext: () => undefined,
+      assistantId: undefined,
+      enqueueMessage: () => {
+        enqueued += 1;
+        return { rejected: false, queued: true, requestId: "req-fake" };
+      },
+    }),
+  );
   return { enqueuedCount: () => enqueued };
 }
 

package/src/__tests__/turn-events-store.test.ts

@@ -331,3 +331,46 @@ describe("queryUnreportedTurnEvents", () => {
     expect(() => stampTurnOutcome("no-such-message", "failed")).not.toThrow();
   });
 });
+
+describe("unfinalized rows and turn accounting", () => {
+  test("an in-flight grouped tool-result row is not a real user turn", async () => {
+    const conv = createConversation({ conversationType: "standard" });
+    const first = await insertUserMessageAt(conv.id, "real question", 1000);
+    // The grouped tool-result row: user-role, reserved unfinalized while
+    // tool output streams, content a { ref } that does not contain the
+    // tool_result text the content exclusions match. Without the finalized
+    // predicate it counts as a phantom user turn until the fold.
+    const inflight = await insertUserMessageAt(
+      conv.id,
+      JSON.stringify({ ref: "conversations/conv/inflight/x.jsonl" }),
+      2000,
+    );
+    getDb().run(`UPDATE messages SET finalized = 0 WHERE id = '${inflight}'`);
+    const second = await insertUserMessageAt(conv.id, "second question", 3000);
+
+    const events = queryUnreportedTurnEvents(0, undefined, 100);
+    const ids = events
+      .filter((e) => e.conversationId === conv.id)
+      .map((e) => e.id);
+
+    expect(ids).toEqual([first, second]);
+    const byId = Object.fromEntries(events.map((e) => [e.id, e]));
+    expect(byId[first].turnIndex).toBe(1);
+    expect(byId[second].turnIndex).toBe(2);
+  });
+
+  test("a persisted empty-display user row still counts as a turn", async () => {
+    const conv = createConversation({ conversationType: "standard" });
+    const real = await insertUserMessageAt(conv.id, "real question", 1000);
+    // A hidden send persists its user row with [] content (displayContent "")
+    // and still runs a turn, so [] rows must stay in turn accounting.
+    const hidden = await insertUserMessageAt(conv.id, "[]", 2000);
+
+    const events = queryUnreportedTurnEvents(0, undefined, 100);
+    const ids = events
+      .filter((e) => e.conversationId === conv.id)
+      .map((e) => e.id);
+
+    expect(ids).toEqual([real, hidden]);
+  });
+});

package/src/__tests__/user-plugin-loader.test.ts

@@ -23,9 +23,9 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { beforeEach, describe, expect, test } from "bun:test";
 
+import { getUserHooksFor } from "../hooks/registry.js";
 import {
   getCachedUserTools,
-  getUserHooksFor,
   resetPluginCacheForTests,
 } from "../plugins/mtime-cache.js";
 import { loadUserPlugins } from "../plugins/user-loader.js";

package/src/__tests__/visible-app-context.test.ts

@@ -25,6 +25,7 @@ import {
 import { registerDefaultPluginInjectors } from "../plugins/defaults/index.js";
 import type { Message } from "../providers/types.js";
 import { getWorkspacePluginsDir } from "../util/platform.js";
+import { asConversation } from "./helpers/mock-conversation.js";
 
 // The injector chain is registered by the daemon bootstrap in production; do
 // the same here so `applyRuntimeInjections` walks a non-empty chain.
@@ -151,15 +152,21 @@ describe("visible_app injection", () => {
   ];
 
   function seedConversation(currentTurnVisibleAppId: string | undefined): void {
-    setConversation(CONVERSATION_ID, {
-      conversationId: CONVERSATION_ID,
-      workingDir: "/sandbox",
-      workspaceTopLevelContext: "",
-      workspaceTopLevelDirty: false,
-      surfaceState: new Map(),
-      currentTurnVisibleAppId,
-      currentTurnTemporalSnapshot: { clientTimezone: null },
-    } as never);
+    setConversation(
+      CONVERSATION_ID,
+      asConversation({
+        conversationId: CONVERSATION_ID,
+        workingDir: "/sandbox",
+        workspaceTopLevelContext: "",
+        workspaceTopLevelDirty: false,
+        surfaceState: new Map(),
+        currentTurnVisibleAppId,
+        currentTurnTemporalSnapshot: {
+          clientTimezone: null,
+          timeSinceLastMessage: null,
+        },
+      }),
+    );
   }
 
   afterEach(() => {

package/src/__tests__/worker-entrypoint-guards.test.ts

@@ -18,10 +18,18 @@ import { Glob } from "bun";
  * - start the PID-file identity guard — the PID file is a worker's sole
  *   tracking handle, so a worker the file stops naming can never be
  *   stopped externally and must evict itself.
+ *
+ * The subset that hosts real agent conversations
+ * ({@link CONVERSATION_RUNNING_ENTRYPOINTS}) must additionally register the
+ * default plugins' hooks and injectors, since hook dispatch is process-global
+ * and a worker that skips it runs conversations with no plugin behavior at all
+ * (no image captioning or vision-rejection recovery, no tool-result
+ * truncation, no runtime injections).
  */
 
 const DISABLE_CALL = "disableStreamSeqStamping()";
 const PID_GUARD_CALL = "startWorkerPidFileGuard(";
+const PLUGIN_SURFACE_CALL = "registerWorkerPluginSurface(";
 
 /** Shape of a shutdown that schedules `process.exit` instead of calling it. */
 const DEFERRED_EXIT = ".finally(() => process.exit";
@@ -44,6 +52,16 @@ const WORK_START_MARKERS: Record<string, string> = {
   "routes/worker.ts": 'server.on("connection"',
 };
 
+/**
+ * The entrypoints whose work wakes real agent conversations. `monitoring` (a
+ * resource sampler) and `routes` (an HTTP route host) run no conversations, so
+ * they carry no plugin surface.
+ */
+const CONVERSATION_RUNNING_ENTRYPOINTS: ReadonlySet<string> = new Set([
+  "schedule/worker.ts",
+  "plugins/defaults/memory/worker.ts",
+]);
+
 function findWorkerEntrypoints(): string[] {
   const srcRoot = join(process.cwd(), "src");
   const glob = new Glob("**/worker.ts");
@@ -137,4 +155,40 @@ describe("worker entrypoint guards", () => {
         "worker superseded at startup before it runs orphaned work.",
     ).toEqual([]);
   });
+
+  test("the conversation-running entrypoints are all discovered workers", () => {
+    const discovered = new Set(findWorkerEntrypoints());
+    const unknown = [...CONVERSATION_RUNNING_ENTRYPOINTS].filter(
+      (file) => !discovered.has(file),
+    );
+    expect(
+      unknown,
+      "CONVERSATION_RUNNING_ENTRYPOINTS names an entrypoint the glob does " +
+        "not find — the worker moved or was renamed.",
+    ).toEqual([]);
+  });
+
+  test("every conversation-running entrypoint registers the default plugin surface before starting work", () => {
+    const offenders = [...CONVERSATION_RUNNING_ENTRYPOINTS]
+      .sort()
+      .filter((file) => {
+        const source = readFileSync(join(process.cwd(), "src", file), "utf8");
+        const marker = WORK_START_MARKERS[file];
+        if (marker == null) {
+          return true;
+        }
+        const registerAt = source.indexOf(PLUGIN_SURFACE_CALL);
+        const workAt = source.indexOf(marker);
+        return registerAt < 0 || workAt < 0 || registerAt > workAt;
+      });
+    expect(
+      offenders,
+      `A worker that wakes agent conversations must call ` +
+        `${PLUGIN_SURFACE_CALL}) before its work-start call (see ` +
+        "WORK_START_MARKERS). Hook dispatch is process-global, so without it " +
+        "the conversations this process runs get no default plugin behavior: " +
+        "no vision-rejection recovery, no tool-result truncation, no runtime " +
+        "injections.",
+    ).toEqual([]);
+  });
 });

package/src/__tests__/worker-plugin-surface.test.ts

@@ -0,0 +1,77 @@
+/**
+ * Tests for {@link registerWorkerPluginSurface}, the default-plugin surface
+ * that sidecar worker processes install at startup.
+ *
+ * A worker that wakes real agent conversations shares the daemon's
+ * process-global hook and injector registries, so registering the defaults is
+ * what gives those conversations the same behavior as daemon conversations.
+ * Registration must populate both tables and stay idempotent, and it must do so
+ * without running any plugin `init` hook (the memory plugin's init starts the
+ * memory jobs worker process itself).
+ */
+
+import { beforeEach, describe, expect, test } from "bun:test";
+
+import { getHookEntriesFor } from "../hooks/registry.js";
+import {
+  clearInjectorRegistry,
+  getRegisteredInjectors,
+} from "../plugins/injector-registry.js";
+import { resetPluginRegistryForTests } from "../plugins/registry.js";
+import { registerWorkerPluginSurface } from "../plugins/worker-plugin-surface.js";
+
+async function hookOwnersFor(name: string): Promise<string[]> {
+  const entries = await getHookEntriesFor(name);
+  return entries.map((entry) => entry.owner.id);
+}
+
+describe("registerWorkerPluginSurface", () => {
+  beforeEach(() => {
+    resetPluginRegistryForTests();
+    clearInjectorRegistry();
+  });
+
+  test("serves the default plugins' hooks from the process-global registry", async () => {
+    expect(await hookOwnersFor("post-model-call")).not.toContain(
+      "default-image-fallback",
+    );
+
+    registerWorkerPluginSurface();
+
+    // The vision-rejection recovery that a worker without this surface never
+    // ran, plus an oversized-tool-result guard on the other hook surface.
+    expect(await hookOwnersFor("post-model-call")).toContain(
+      "default-image-fallback",
+    );
+    expect(await hookOwnersFor("post-tool-use")).toContain(
+      "default-tool-result-truncate",
+    );
+  });
+
+  test("registers the injector-only defaults' runtime injectors", () => {
+    expect(
+      getRegisteredInjectors().some((i) => i.name === "unified-turn-context"),
+    ).toBe(false);
+
+    registerWorkerPluginSurface();
+
+    // `default-turn-context` contributes no hooks, so its injections only reach
+    // a worker's conversations through the injector registry.
+    expect(
+      getRegisteredInjectors().some((i) => i.name === "unified-turn-context"),
+    ).toBe(true);
+  });
+
+  test("is idempotent: a second call neither throws nor duplicates", async () => {
+    registerWorkerPluginSurface();
+    const hooksAfterFirst = await hookOwnersFor("post-model-call");
+    const injectorsAfterFirst = getRegisteredInjectors().map((i) => i.name);
+
+    expect(() => registerWorkerPluginSurface()).not.toThrow();
+
+    expect(await hookOwnersFor("post-model-call")).toEqual(hooksAfterFirst);
+    expect(getRegisteredInjectors().map((i) => i.name)).toEqual(
+      injectorsAfterFirst,
+    );
+  });
+});

package/src/__tests__/workspace-migration-142-consolidate-voice-front-door.test.ts

@@ -0,0 +1,158 @@
+import {
+  existsSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import { consolidateVoiceFrontDoorMigration } from "../workspace/migrations/142-consolidate-voice-front-door.js";
+import { WORKSPACE_MIGRATIONS } from "../workspace/migrations/registry.js";
+
+let workspaceDir: string;
+let configPath: string;
+let previousDefaultWorkspaceConfigPath: string | undefined;
+
+beforeEach(() => {
+  previousDefaultWorkspaceConfigPath =
+    process.env.VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH;
+  delete process.env.VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH;
+  workspaceDir = mkdtempSync(join(tmpdir(), "vellum-migration-142-test-"));
+  configPath = join(workspaceDir, "config.json");
+});
+
+afterEach(() => {
+  if (previousDefaultWorkspaceConfigPath === undefined) {
+    delete process.env.VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH;
+  } else {
+    process.env.VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH =
+      previousDefaultWorkspaceConfigPath;
+  }
+  if (existsSync(workspaceDir)) {
+    rmSync(workspaceDir, { recursive: true, force: true });
+  }
+});
+
+function writeConfig(config: Record<string, unknown>): void {
+  writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+}
+
+function readConfig(): Record<string, unknown> {
+  return JSON.parse(readFileSync(configPath, "utf-8"));
+}
+
+describe("142-consolidate-voice-front-door migration", () => {
+  test("is registered in order", () => {
+    expect(consolidateVoiceFrontDoorMigration.id).toBe(
+      "142-consolidate-voice-front-door",
+    );
+    // getLastWorkspaceMigrationId() reports the final entry as the registry
+    // ceiling, so ordering matters: this must be registered, and everything
+    // after it must carry a higher id. Asserting it stays literally last
+    // would break on every migration appended after it.
+    const index = WORKSPACE_MIGRATIONS.findIndex(
+      (migration) => migration.id === "142-consolidate-voice-front-door",
+    );
+    expect(index).toBeGreaterThan(-1);
+    for (const later of WORKSPACE_MIGRATIONS.slice(index + 1)) {
+      expect(later.id > "142").toBe(true);
+    }
+  });
+
+  test("moves progress overrides and removes generated-ack tuning", () => {
+    writeConfig({
+      llm: {
+        callSites: {
+          voiceFrontDecision: { profile: "cost-optimized", effort: "low" },
+          voiceFrontDoor: { profile: "latency-optimized" },
+        },
+      },
+      liveVoice: {
+        frontModel: {
+          endpointDecisionTimeoutMs: 900,
+          ackFirstDeltaTimeoutMs: 2500,
+          ackGenerationTimeoutMs: 600,
+          progress: { enabled: true },
+        },
+      },
+    });
+
+    consolidateVoiceFrontDoorMigration.run(workspaceDir);
+
+    const config = readConfig();
+    const llm = config.llm as Record<string, unknown>;
+    const callSites = llm.callSites as Record<string, unknown>;
+    expect(callSites.voiceProgressNarration).toEqual({
+      profile: "cost-optimized",
+      effort: "low",
+    });
+    expect(callSites).not.toHaveProperty("voiceFrontDecision");
+    expect(callSites.voiceFrontDoor).toEqual({ profile: "latency-optimized" });
+
+    const liveVoice = config.liveVoice as Record<string, unknown>;
+    const frontModel = liveVoice.frontModel as Record<string, unknown>;
+    expect(frontModel).not.toHaveProperty("ackFirstDeltaTimeoutMs");
+    expect(frontModel).not.toHaveProperty("ackGenerationTimeoutMs");
+    expect(frontModel.endpointDecisionTimeoutMs).toBe(900);
+    expect(frontModel.progress).toEqual({ enabled: true });
+  });
+
+  test("keeps an existing progress override when both keys exist", () => {
+    writeConfig({
+      llm: {
+        callSites: {
+          voiceFrontDecision: { profile: "cost-optimized" },
+          voiceProgressNarration: { profile: "latency-optimized" },
+        },
+      },
+    });
+
+    consolidateVoiceFrontDoorMigration.run(workspaceDir);
+
+    const config = readConfig();
+    const llm = config.llm as Record<string, unknown>;
+    const callSites = llm.callSites as Record<string, unknown>;
+    expect(callSites.voiceProgressNarration).toEqual({
+      profile: "latency-optimized",
+    });
+    expect(callSites).not.toHaveProperty("voiceFrontDecision");
+  });
+
+  test("migrates saved overrides when a default config overlay is configured", () => {
+    process.env.VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH = "/tmp/overlay.json";
+    writeConfig({
+      llm: {
+        callSites: {
+          voiceFrontDecision: { profile: "cost-optimized" },
+        },
+      },
+    });
+
+    consolidateVoiceFrontDoorMigration.run(workspaceDir);
+
+    const config = readConfig();
+    const llm = config.llm as Record<string, unknown>;
+    const callSites = llm.callSites as Record<string, unknown>;
+    expect(callSites.voiceProgressNarration).toEqual({
+      profile: "cost-optimized",
+    });
+    expect(callSites).not.toHaveProperty("voiceFrontDecision");
+  });
+
+  test("is idempotent", () => {
+    writeConfig({
+      llm: {
+        callSites: { voiceFrontDecision: { profile: "cost-optimized" } },
+      },
+    });
+
+    consolidateVoiceFrontDoorMigration.run(workspaceDir);
+    const first = readFileSync(configPath, "utf-8");
+    consolidateVoiceFrontDoorMigration.run(workspaceDir);
+
+    expect(readFileSync(configPath, "utf-8")).toBe(first);
+  });
+});