@vellumai/assistant 0.10.3-dev.202606301940.da6000c → 0.10.3-dev.202606302045.155be34

package/openapi.yaml

@@ -22668,7 +22668,7 @@ paths:
     post:
       operationId: schedules_post
       summary: Create schedule
-      description: Create a new recurring schedule. Currently restricted to mode='execute'.
+      description: Create a new recurring schedule (execute, script, or workflow mode).
       tags:
         - schedules
       requestBody:
@@ -22702,12 +22702,20 @@ paths:
                   description: Whether the schedule starts active (default true)
                 mode:
                   type: string
-                  description: "'execute' (default) or 'workflow' (flag-gated)"
+                  description: "'execute' (default), 'script', or 'workflow' (flag-gated)"
                 workflowName:
                   type: string
                   description: Saved workflow to trigger (required for workflow mode)
                 workflowArgs:
                   description: Args passed to the workflow run (workflow mode)
+                script:
+                  type: string
+                  description: Shell command run on each fire (required for script mode)
+                timeoutMs:
+                  anyOf:
+                    - type: number
+                    - type: "null"
+                  description: Script execution timeout override in ms (script mode)
                 inferenceProfile:
                   anyOf:
                     - type: string

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.10.3-dev.202606301940.da6000c",
+  "version": "0.10.3-dev.202606302045.155be34",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/__tests__/anthropic-provider.test.ts

@@ -3245,11 +3245,14 @@ describe("AnthropicProvider — deprecated sampling params (temperature / top_p
     lastStreamParams = null;
   });
 
-  // opus-4-7 / opus-4-8 (and, conservatively, fable) reject `temperature`,
-  // `top_p`, and `top_k` with a 400; the provider must strip all three.
+  // opus-4-7 / opus-4-8 / sonnet-5 (and, conservatively, fable) reject
+  // `temperature`, `top_p`, and `top_k` with a 400; the provider must strip
+  // all three. The OpenRouter `anthropic/...` form delegates here too.
   for (const model of [
     "claude-opus-4-8",
     "claude-opus-4-7",
+    "claude-sonnet-5",
+    "anthropic/claude-sonnet-5",
     "claude-fable-5",
   ]) {
     test(`strips temperature, top_p, and top_k for ${model}`, async () => {

package/src/__tests__/conversation-initial-prompt.test.ts

@@ -0,0 +1,110 @@
+/**
+ * Tests for construction-time system-prompt resolution.
+ *
+ * A conversation's system prompt is built once at construction and frozen for
+ * every turn (the agent loop never re-resolves it), so the persona slot must
+ * resolve correctly here. With no construction-time identity the default-build
+ * path must warm the gateway guardian binding BEFORE building (else a cold cache
+ * pins `users/default.md`); a channel-routed conversation that already carries
+ * the requester's trust context must build with it so the requester's profile
+ * resolves instead of the guardian/default one.
+ *
+ * Dependency seams are injected so this exercises the sequencing without mocking
+ * the widely-imported guardian-delivery / system-prompt modules (those global
+ * module mocks leak across files in the shared-process test runner).
+ */
+import { describe, expect, test } from "bun:test";
+
+import {
+  resolveInitialSystemPrompt,
+  warmGuardianBindings,
+} from "../daemon/conversation-initial-prompt.js";
+import type { ConversationCreateOptions } from "../daemon/handlers/shared.js";
+import type { TrustContext } from "../daemon/trust-context.js";
+
+function spyDeps() {
+  const calls: string[] = [];
+  const builtWith: Array<TrustContext | undefined> = [];
+  return {
+    calls,
+    builtWith,
+    deps: {
+      warm: async () => {
+        calls.push("warm");
+      },
+      build: (trustContext: TrustContext | undefined) => {
+        calls.push("build");
+        builtWith.push(trustContext);
+        return "BUILD";
+      },
+    },
+  };
+}
+
+const REQUESTER_TRUST = {
+  sourceChannel: "slack",
+  trustClass: "trusted_contact",
+  requesterExternalUserId: "user-123",
+} as unknown as TrustContext;
+
+describe("warmGuardianBindings", () => {
+  test("warms both the vellum-channel key and the unfiltered fallback key", async () => {
+    const keys: string[] = [];
+    await warmGuardianBindings(async (input) => {
+      keys.push(input?.channelTypes?.join(",") ?? "ALL");
+      return null;
+    });
+    // Both keys the persona resolver reads — peekGuardianForChannel("vellum")
+    // and its peekAnyGuardian() fallback — must be warmed.
+    expect(keys.sort()).toEqual(["ALL", "vellum"]);
+  });
+});
+
+describe("resolveInitialSystemPrompt", () => {
+  test("no construction-time identity: warms the guardian binding, then builds with no trust context", async () => {
+    const { calls, builtWith, deps } = spyDeps();
+    const result = await resolveInitialSystemPrompt(undefined, deps);
+
+    expect(result).toBe("BUILD");
+    // The warm MUST precede the build so the persona slot resolves the
+    // guardian's users/<slug>.md instead of users/default.md on a cold cache.
+    expect(calls).toEqual(["warm", "build"]);
+    expect(builtWith).toEqual([undefined]);
+  });
+
+  test("channel-routed: threads the requester trust context and skips the guardian warm", async () => {
+    const { calls, builtWith, deps } = spyDeps();
+    const result = await resolveInitialSystemPrompt(
+      { trustContext: REQUESTER_TRUST } as ConversationCreateOptions,
+      deps,
+    );
+
+    expect(result).toBe("BUILD");
+    // The requester's identity resolves the persona via a DB lookup, so no
+    // guardian-cache warm is needed and the trust context must reach the build.
+    expect(calls).toEqual(["build"]);
+    expect(builtWith).toEqual([REQUESTER_TRUST]);
+  });
+
+  test("an explicit override is used verbatim and skips the warm and build", async () => {
+    const { calls, deps } = spyDeps();
+    const result = await resolveInitialSystemPrompt(
+      { systemPromptOverride: "CUSTOM PROMPT" } as ConversationCreateOptions,
+      deps,
+    );
+
+    expect(result).toBe("CUSTOM PROMPT");
+    expect(calls).toEqual([]);
+  });
+
+  test("an explicit empty-string override is honored verbatim (not treated as absent)", async () => {
+    const { calls, deps } = spyDeps();
+    const result = await resolveInitialSystemPrompt(
+      { systemPromptOverride: "" } as ConversationCreateOptions,
+      deps,
+    );
+
+    expect(result).toBe("");
+    expect(calls).toEqual([]);
+  });
+});

package/src/__tests__/conversation-loop-db-lock-resilience.test.ts

@@ -0,0 +1,191 @@
+/**
+ * Regression tests for SQLite write-contention resilience in the agent loop.
+ *
+ * When another writer holds the SQLite write lock long enough that
+ * `busy_timeout` elapses, an in-loop content write throws `SQLITE_BUSY`
+ * ("database is locked"). The turn-finalizing write at `message_complete` is on
+ * `dispatchAgentEvent`'s re-throw allowlist, so before this resilience layer a
+ * single transient lock aborted the whole turn and surfaced to the user as
+ * "Processing failed: database is locked".
+ *
+ * These tests pin the two guarantees:
+ *  1. A transient `SQLITE_BUSY` is retried and the row is finalized normally.
+ *  2. A persistent `SQLITE_BUSY` is swallowed (logged) so the turn continues
+ *     instead of throwing — a later write (this turn or the next) overwrites
+ *     the dropped content.
+ */
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+// ── Mock platform (must precede imports that read it) ─────────────────────────
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+mock.module("../config/loader.js", () => ({
+  getConfig: () => ({ memory: {} }),
+  loadConfig: () => ({}),
+}));
+
+// `updateMessageContent` throws `SQLITE_BUSY` for the first
+// `updateContentFailuresRemaining` calls, then records the content written.
+let updateContentFailuresRemaining = 0;
+const writtenContentById = new Map<string, string>();
+const updateMessageContentMock = mock((id: string, content: string) => {
+  if (updateContentFailuresRemaining > 0) {
+    updateContentFailuresRemaining -= 1;
+    throw Object.assign(new Error("database is locked"), {
+      code: "SQLITE_BUSY",
+    });
+  }
+  writtenContentById.set(id, content);
+});
+
+// Stand-in for the `conversations.seq` column, mirroring the monotonic,
+// ignore-non-positive semantics of the real `recordConversationPersistedSeq`.
+const persistedSeqByConversation = new Map<string, number>();
+
+mock.module("../persistence/conversation-crud.js", () => ({
+  setConversationProcessingStartedAt: () => {},
+  isConversationProcessing: () => false,
+  getConversation: () => null,
+  getMessageById: () => null,
+  updateMessageContent: updateMessageContentMock,
+  provenanceFromTrustContext: () => ({}),
+  reserveMessage: async (_conversationId: string, role: string) => ({
+    id: role === "user" ? "tool-result-row" : "assistant-row",
+  }),
+  recordConversationPersistedSeq: (id: string, seq: number) => {
+    if (!Number.isFinite(seq) || seq <= 0) return;
+    const prev = persistedSeqByConversation.get(id);
+    if (prev == null || prev < seq) persistedSeqByConversation.set(id, seq);
+  },
+  getConversationPersistedSeq: (id: string) =>
+    persistedSeqByConversation.get(id) ?? null,
+}));
+
+mock.module("../persistence/conversation-disk-view.js", () => ({
+  syncMessageToDisk: () => {},
+}));
+
+mock.module("../persistence/llm-request-log-store.js", () => ({
+  recordRequestLog: () => {},
+  backfillMessageIdOnLogs: () => {},
+}));
+
+mock.module("../plugins/defaults/memory/memory-recall-log-store.js", () => ({
+  backfillMemoryRecallLogMessageId: () => {},
+}));
+
+mock.module(
+  "../plugins/defaults/memory/memory-v2-activation-log-store.js",
+  () => ({
+    backfillMemoryV2ActivationMessageId: () => {},
+  }),
+);
+
+// ── Imports (after mocks) ─────────────────────────────────────────────────────
+import type { AgentEvent } from "../agent/loop.js";
+import type {
+  EventHandlerDeps,
+  EventHandlerState,
+} from "../daemon/conversation-agent-loop-handlers.js";
+import {
+  createEventHandlerState,
+  handleMessageComplete,
+} from "../daemon/conversation-agent-loop-handlers.js";
+import type { ServerMessage } from "../daemon/message-protocol.js";
+import { getConversationPersistedSeq } from "../persistence/conversation-crud.js";
+
+const CONVERSATION_ID = "test-session-id";
+
+function createMockDeps(): EventHandlerDeps {
+  return {
+    ctx: {
+      conversationId: CONVERSATION_ID,
+      provider: { name: "anthropic" },
+      traceEmitter: { emit: () => {} },
+      streamThinking: false,
+      emitActivityState: () => {},
+      markWorkspaceTopLevelDirty: () => {},
+      currentTurnSurfaces: [],
+    } as unknown as EventHandlerDeps["ctx"],
+    onEvent: (_msg: ServerMessage) => {},
+    reqId: "test-req-id",
+    isFirstMessage: false,
+    shouldGenerateTitle: false,
+    rlog: new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }) as unknown as EventHandlerDeps["rlog"],
+    turnChannelContext: {
+      userMessageChannel: "vellum",
+      assistantMessageChannel: "vellum",
+    } as EventHandlerDeps["turnChannelContext"],
+    turnInterfaceContext: {
+      userMessageInterface: "macos",
+      assistantMessageInterface: "macos",
+    } as EventHandlerDeps["turnInterfaceContext"],
+  } as EventHandlerDeps;
+}
+
+const MESSAGE_COMPLETE_EVENT = {
+  type: "message_complete",
+  message: { role: "assistant", content: [{ type: "text", text: "done" }] },
+} as Extract<AgentEvent, { type: "message_complete" }>;
+
+describe("agent loop SQLite write-contention resilience", () => {
+  let state: EventHandlerState;
+
+  beforeEach(() => {
+    state = createEventHandlerState();
+    // A row was reserved at llm_call_started; message_complete finalizes it.
+    state.lastAssistantMessageId = "assistant-row";
+    state.assistantRowAwaitingFinalization = true;
+    state.lastPersistedContentSeq = 5;
+    updateContentFailuresRemaining = 0;
+    writtenContentById.clear();
+    persistedSeqByConversation.clear();
+    updateMessageContentMock.mockClear();
+  });
+
+  test("retries a transient SQLITE_BUSY and finalizes the assistant row", async () => {
+    // GIVEN the finalize write loses the write-lock race twice before winning
+    updateContentFailuresRemaining = 2;
+
+    // WHEN message_complete drains
+    await handleMessageComplete(
+      state,
+      createMockDeps(),
+      MESSAGE_COMPLETE_EVENT,
+    );
+
+    // THEN it retried until the write committed (2 failures + 1 success) ...
+    expect(updateMessageContentMock).toHaveBeenCalledTimes(3);
+    expect(writtenContentById.get("assistant-row")).toContain("done");
+    // ... the finalization completed ...
+    expect(state.assistantRowAwaitingFinalization).toBe(false);
+    // ... and the persisted seq advanced because the content is durable.
+    expect(getConversationPersistedSeq(CONVERSATION_ID)).toBe(5);
+  });
+
+  test("swallows a persistent SQLITE_BUSY without aborting the turn", async () => {
+    // GIVEN every finalize attempt loses the race (lock held past every retry)
+    updateContentFailuresRemaining = Number.POSITIVE_INFINITY;
+
+    // WHEN message_complete drains, it must resolve rather than throw — a thrown
+    // SQLITE_BUSY here is on dispatchAgentEvent's re-throw allowlist and would
+    // kill the turn.
+    await expect(
+      handleMessageComplete(state, createMockDeps(), MESSAGE_COMPLETE_EVENT),
+    ).resolves.toBeUndefined();
+
+    // THEN the write was attempted (initial try + the retries) ...
+    expect(updateMessageContentMock.mock.calls.length).toBeGreaterThan(1);
+    // ... no content landed ...
+    expect(writtenContentById.has("assistant-row")).toBe(false);
+    // ... and the seq was NOT advanced past content that never became durable.
+    expect(getConversationPersistedSeq(CONVERSATION_ID)).toBeNull();
+  });
+});

package/src/__tests__/schedule-routes.test.ts

@@ -1241,7 +1241,7 @@ describe("POST /schedules — create", () => {
     expect(job.description).toBe("Description fallback");
   });
 
-  test("rejects modes other than execute/workflow", async () => {
+  test("rejects modes other than execute/workflow/script", async () => {
     await expect(
       postCreate({
         name: "x",
@@ -1250,7 +1250,9 @@ describe("POST /schedules — create", () => {
         message: "hi",
         mode: "notify",
       }),
-    ).rejects.toThrow("Only 'execute' and 'workflow' modes are supported");
+    ).rejects.toThrow(
+      "Only 'execute', 'script', and 'workflow' modes are supported",
+    );
   });
 
   test("rejects an unparseable expression", async () => {

package/src/cli/commands/__tests__/schedules.test.ts

@@ -748,6 +748,58 @@ describe("schedules create", () => {
     expect(exitFromIpcResultCalls).toEqual([mockIpcResult]);
     expect(errorLines).toEqual([]);
   });
+
+  test("creates a script-mode schedule with --mode script --script", async () => {
+    mockIpcResult = { ok: true, result: { schedules: [] } };
+
+    const { exitCode } = await runCommand([
+      "schedules",
+      "create",
+      "GitHub watcher",
+      "--mode",
+      "script",
+      "--script",
+      'cd "$VELLUM_WORKSPACE_DIR/schedules/$__SCHEDULE_ID" && bun poll.ts',
+      "--expression",
+      "*/15 * * * *",
+      "--description",
+      "Polls GitHub notifications",
+    ]);
+
+    expect(exitCode).toBe(0);
+    expect(ipcCalls).toEqual([
+      {
+        method: "createSchedule",
+        params: {
+          body: {
+            name: "GitHub watcher",
+            expression: "*/15 * * * *",
+            description: "Polls GitHub notifications",
+            enabled: true,
+            mode: "script",
+            script:
+              'cd "$VELLUM_WORKSPACE_DIR/schedules/$__SCHEDULE_ID" && bun poll.ts',
+          },
+        },
+      },
+    ]);
+  });
+
+  test("exits 1 when --mode script is missing --script", async () => {
+    const { exitCode } = await runCommand([
+      "schedules",
+      "create",
+      "Broken",
+      "--mode",
+      "script",
+      "--expression",
+      "*/15 * * * *",
+      "--description",
+      "no script",
+    ]);
+
+    expect(exitCode).toBe(1);
+  });
 });
 
 describe("schedules update", () => {

package/src/cli/commands/schedules.ts

@@ -416,9 +416,21 @@ Examples:
           "-d, --description <text>",
           "Authored description explaining what the schedule is for",
         )
-        .requiredOption(
+        .option(
           "-m, --message <text>",
-          "Message body sent to the assistant on each fire",
+          "Message body sent to the assistant on each fire (required for execute mode)",
+        )
+        .option(
+          "--mode <mode>",
+          "Schedule mode: 'execute' (default), 'script', or 'workflow'",
+        )
+        .option(
+          "--script <command>",
+          "Shell command to run on each fire (required for --mode script)",
+        )
+        .option(
+          "--timeout-ms <ms>",
+          "Script execution timeout override in ms (--mode script)",
         )
         .option(
           "-t, --timezone <tz>",
@@ -436,7 +448,10 @@ Examples:
 Options:
   -e, --expression <expr>   Cron (e.g. '*/30 * * * *') or RRULE expression.
   -d, --description <text>  Authored description explaining what the schedule is for.
-  -m, --message <text>      Message body sent on each fire.
+  -m, --message <text>      Message body sent on each fire (execute mode).
+  --mode <mode>             execute (default), script, or workflow.
+  --script <command>        Shell command for --mode script.
+  --timeout-ms <ms>         Script timeout override in ms (--mode script).
   -t, --timezone <tz>       IANA timezone applied to the expression.
   --profile <name>          Inference profile (llm.profiles key) the schedule's
                             runs use. When omitted, runs use the default —
@@ -448,11 +463,17 @@ Arguments:
   <name>   Display name for the schedule.
 
 Behavior:
-  Creates a recurring schedule in 'execute' mode. The IPC endpoint is
-  currently locked to execute mode; notify/script/wake schedules remain
-  reachable only through the in-assistant schedule_create LLM tool.
+  Defaults to 'execute' mode (requires --message). Pass --mode script with
+  --script to run a shell command on each fire with no LLM call; the script's
+  env includes $VELLUM_WORKSPACE_DIR and $__SCHEDULE_ID (this schedule's id).
+  notify/wake schedules remain reachable only through the schedule_create tool.
 
 Examples:
+  $ assistant schedules create "GitHub watcher" \\
+      --mode script \\
+      --script 'cd "$VELLUM_WORKSPACE_DIR/schedules/$__SCHEDULE_ID" && bun poll.ts' \\
+      --expression '*/15 * * * *' \\
+      --description 'Polls GitHub notifications' --json
   $ assistant schedules create "Heartbeat" \\
       --expression '*/30 * * * *' \\
       --description 'Checks service heartbeat every 30 minutes' \\
@@ -474,7 +495,10 @@ Examples:
             opts: {
               expression: string;
               description: string;
-              message: string;
+              message?: string;
+              mode?: string;
+              script?: string;
+              timeoutMs?: string;
               timezone?: string;
               profile?: string;
               enabled: boolean;
@@ -506,13 +530,33 @@ Examples:
               return;
             }
 
+            const mode = opts.mode ?? "execute";
+            if (mode === "script" && !opts.script) {
+              const error = "--script is required for --mode script";
+              if (opts.json) writeOutput(cmd, { ok: false, error });
+              else log.error(error);
+              process.exitCode = 1;
+              return;
+            }
+            if (mode === "execute" && !opts.message) {
+              const error = "--message is required for execute mode";
+              if (opts.json) writeOutput(cmd, { ok: false, error });
+              else log.error(error);
+              process.exitCode = 1;
+              return;
+            }
+
             const body: Record<string, unknown> = {
               name: scheduleName,
               expression: opts.expression,
               description,
-              message: opts.message,
               enabled: opts.enabled,
             };
+            // Omit mode for the default; the route treats absent as 'execute'.
+            if (mode !== "execute") body.mode = mode;
+            if (opts.message != null) body.message = opts.message;
+            if (opts.script != null) body.script = opts.script;
+            if (opts.timeoutMs != null) body.timeoutMs = Number(opts.timeoutMs);
             if (opts.timezone != null) body.timezone = opts.timezone;
             if (opts.profile != null) body.inferenceProfile = opts.profile;
 

package/src/config/call-site-defaults.ts

@@ -66,8 +66,6 @@ export const CALL_SITE_DEFAULTS: Record<LLMCallSite, CallSiteDefaultConfig> = {
   approvalConversation: { profile: "cost-optimized" },
   trustRuleSuggestion: { profile: "cost-optimized" },
   styleAnalyzer: { profile: "cost-optimized" },
-  meetConsentMonitor: { profile: "cost-optimized" },
-  meetChatOpportunity: { profile: "cost-optimized" },
   inference: { profile: "cost-optimized" },
   // Vision captioning for the image-fallback plugin. No pinned profile — the
   // plugin resolves a vision-capable profile itself via `doesSupportVision` and

package/src/config/feature-flag-registry.json

@@ -218,14 +218,6 @@
       "description": "Replace the knowledge graph top-level tab with a new Home page showing relationship progression, facts, and capability tiers",
       "defaultEnabled": false
     },
-    {
-      "id": "meet",
-      "scope": "assistant",
-      "key": "meet",
-      "label": "Google Meet",
-      "description": "Enables the Google Meet joining bot and the meet-join skill.",
-      "defaultEnabled": false
-    },
     {
       "id": "scroll-debug-overlay",
       "scope": "client",

package/src/config/schemas/call-site-catalog.ts

@@ -282,18 +282,6 @@ const CATALOG_RECORD: CatalogRecord = {
     description: "Infers the category of a skill from its description.",
     domain: "skills",
   },
-  meetConsentMonitor: {
-    id: "meetConsentMonitor",
-    displayName: "Meet Consent Monitor",
-    description: "Monitors meeting consent signals during live calls.",
-    domain: "skills",
-  },
-  meetChatOpportunity: {
-    id: "meetChatOpportunity",
-    displayName: "Meet Chat Opportunity",
-    description: "Identifies opportunities to engage in meeting chat.",
-    domain: "skills",
-  },
   inference: {
     id: "inference",
     displayName: "Inference",

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/daemon/__tests__/daemon-skill-host.test.ts

@@ -135,9 +135,9 @@ mock.module("../../runtime/skill-route-registry.js", () => ({
   registerSkillRoute: registerSkillRouteSpy,
 }));
 
-const registerShutdownHookSpy = mock(() => {});
-mock.module("../shutdown-registry.js", () => ({
-  registerShutdownHook: registerShutdownHookSpy,
+const registerPluginHooksSpy = mock(() => {});
+mock.module("../../hooks/registry.js", () => ({
+  registerPluginHooks: registerPluginHooksSpy,
 }));
 
 class StubSpeakerTracker {}
@@ -261,10 +261,16 @@ describe("createDaemonSkillHost", () => {
     expect(registerSkillRouteSpy).toHaveBeenCalled();
     const hook = async () => {};
     host.registries.registerShutdownHook("test-hook", hook);
-    expect(registerShutdownHookSpy).toHaveBeenCalledWith(
-      "meet-join:test-hook",
-      hook,
-    );
+    // The skill's shutdown hook is registered into the unified hook registry
+    // under the skillId-namespaced owner, as a `shutdown` hook that fires via
+    // `runHook(HOOKS.SHUTDOWN)` at daemon shutdown.
+    expect(registerPluginHooksSpy).toHaveBeenCalledTimes(1);
+    const [owner, hooks] = registerPluginHooksSpy.mock.calls[0]! as unknown as [
+      string,
+      Record<string, unknown>,
+    ];
+    expect(owner).toBe("meet-join:test-hook");
+    expect(typeof hooks.shutdown).toBe("function");
   });
 
   test("speakers.createTracker yields a concrete tracker instance", () => {