@vellumai/assistant 0.6.4 → 0.6.6

package/src/__tests__/credential-health-service.test.ts

@@ -50,6 +50,21 @@ mock.module("../oauth/oauth-store.js", () => ({
   getProvider: (provider: string) =>
     mockProviders.find((p) => p.provider === provider),
   isProviderConnected: () => false,
+  // Needed by manual-token-connection.ts at import time — these aren't
+  // invoked in this test suite but must resolve so the module loads.
+  createConnection: () => {
+    throw new Error("createConnection not mocked");
+  },
+  deleteConnection: () => {
+    throw new Error("deleteConnection not mocked");
+  },
+  getConnectionByProvider: () => undefined,
+  updateConnection: () => {
+    throw new Error("updateConnection not mocked");
+  },
+  upsertApp: async () => {
+    throw new Error("upsertApp not mocked");
+  },
 }));
 
 mock.module("../util/logger.js", () => ({
@@ -63,11 +78,8 @@ mock.module("../util/logger.js", () => ({
 
 // ── Import under test ────────────────────────────────────────────────
 
-const {
-  checkAllCredentials,
-  checkCredentialForProvider,
-  _setFetchFn,
-} = await import("../credential-health/credential-health-service.js");
+const { checkAllCredentials, checkCredentialForProvider, _setFetchFn } =
+  await import("../credential-health/credential-health-service.js");
 
 // Inject mock fetch via the test helper (Bun's global fetch can't be
 // overridden via globalThis assignment).
@@ -125,10 +137,7 @@ function addConnection(
 }
 
 function setToken(connectionId: string, token = "mock-token") {
-  secureKeyValues.set(
-    `oauth_connection/${connectionId}/access_token`,
-    token,
-  );
+  secureKeyValues.set(`oauth_connection/${connectionId}/access_token`, token);
 }
 
 // ── Tests ────────────────────────────────────────────────────────────
@@ -322,6 +331,66 @@ describe("credential-health-service", () => {
     expect(slack!.status).toBe("healthy");
   });
 
+  describe("manual-token providers", () => {
+    // slack_channel and telegram store their primary access token at
+    // credential/<provider>/bot_token rather than at
+    // oauth_connection/<id>/access_token. The health check must resolve the
+    // provider-specific path via manualTokenAccessCredentialKey — otherwise
+    // every manual-token connection gets flagged as missing_token and ends
+    // up in the heartbeat <credential-status> block even when credentials
+    // are valid.
+
+    test("slack_channel is healthy when bot_token is present and ping succeeds", async () => {
+      addProvider("slack_channel", {
+        pingUrl: "https://slack.com/api/auth.test",
+      });
+      addConnection("slack_channel", "conn-slack", {
+        expiresAt: null,
+        hasRefreshToken: false,
+        grantedScopes: [],
+      });
+      secureKeyValues.set("credential/slack_channel/bot_token", "xoxb-valid");
+
+      const report = await checkAllCredentials();
+      expect(report.results).toHaveLength(1);
+      expect(report.results[0]!.status).toBe("healthy");
+      expect(report.unhealthy).toHaveLength(0);
+    });
+
+    test("slack_channel is missing_token when bot_token is absent, even if OAuth access-token path is populated", async () => {
+      addProvider("slack_channel", {
+        pingUrl: "https://slack.com/api/auth.test",
+      });
+      addConnection("slack_channel", "conn-slack", {
+        expiresAt: null,
+        hasRefreshToken: false,
+        grantedScopes: [],
+      });
+      // Write to the OAuth access-token path — this must be IGNORED for
+      // manual-token providers, otherwise the fix isn't routing correctly.
+      secureKeyValues.set(
+        "oauth_connection/conn-slack/access_token",
+        "should-be-ignored",
+      );
+
+      const report = await checkAllCredentials();
+      expect(report.results[0]!.status).toBe("missing_token");
+    });
+
+    test("telegram resolves to credential/telegram/bot_token", async () => {
+      addProvider("telegram");
+      addConnection("telegram", "conn-tg", {
+        expiresAt: null,
+        hasRefreshToken: false,
+        grantedScopes: [],
+      });
+      secureKeyValues.set("credential/telegram/bot_token", "telegram-token");
+
+      const report = await checkAllCredentials();
+      expect(report.results[0]!.status).toBe("healthy");
+    });
+  });
+
   describe("checkCredentialForProvider", () => {
     test("returns null when no connections exist", async () => {
       const result = await checkCredentialForProvider("google");

package/src/__tests__/credential-security-invariants.test.ts

@@ -186,6 +186,7 @@ describe("Invariant 2: no generic plaintext secret read API", () => {
       "messaging/providers/slack/adapter.ts", // Slack bot token lookup for Socket Mode connectivity check
       "credential-health/credential-health-service.ts", // proactive credential health monitoring
       "daemon/handlers/config-slack-channel.ts", // Slack channel config credential management
+      "daemon/handlers/slack-channel-oauth-install.ts", // Slack OAuth loopback reads client credentials for token exchange
       "providers/managed-proxy/context.ts", // managed proxy API key lookup for provider initialization
       "platform/client.ts", // platform client credential store fallback for standalone CLI auth
       "mcp/mcp-oauth-provider.ts", // MCP OAuth token/client/discovery persistence
@@ -200,12 +201,12 @@ describe("Invariant 2: no generic plaintext secret read API", () => {
       "oauth/oauth-store.ts", // OAuth provider disconnect (delete stored tokens)
       "oauth/manual-token-connection.ts", // manual-token provider backfill (credential store existence check)
       "workspace/provider-commit-message-generator.ts", // commit message generation provider key lookup
+      "cli/commands/image-generation.ts", // CLI image-generation command API key lookup
       "config/bundled-skills/image-studio/tools/media-generate-image.ts", // image generation tool API key lookup
       "config/bundled-skills/media-processing/tools/analyze-keyframes.ts", // keyframe analysis tool API key lookup
       "providers/registry.ts", // provider registry API key lookup for initialization
       "providers/provider-availability.ts", // provider availability API key check
-      "media/app-icon-generator.ts", // app icon generation API key lookup
-      "media/avatar-router.ts", // avatar generation API key lookup
+      "media/image-credentials.ts", // shared image-gen credential resolver (provider API key lookup)
       "memory/embedding-backend.ts", // embedding backend API key lookup
       "daemon/providers-setup.ts", // provider initialization API key lookup
       "workspace/migrations/006-services-config.ts", // services config migration reads provider API keys
@@ -214,9 +215,11 @@ describe("Invariant 2: no generic plaintext secret read API", () => {
       "daemon/handlers/config-model.ts", // masked provider key display
       "providers/speech-to-text/resolve.ts", // STT provider API key lookup
       "daemon/lifecycle.ts", // CES client injection into secure-keys at startup
+      "daemon/external-plugins-bootstrap.ts", // reads credentials at plugin init (manifest.requiresCredential) via the CES-mediated getSecureKeyAsync path
       "inbound/platform-callback-registration.ts", // managed credential lookup for platform base URL, assistant ID, and API key
       "tts/providers/elevenlabs-provider.ts", // ElevenLabs TTS API key lookup
       "tts/providers/deepgram-provider.ts", // Deepgram TTS API key lookup
+      "tts/providers/xai-provider.ts", // xAI TTS API key lookup
       "meet/session-manager.ts", // Meet bot container provisioning (provider API key lookup for Deepgram/TTS)
       "credential-health/credential-health-service.ts", // credential health check reads access tokens for liveness pings
     ]);

package/src/__tests__/credential-storage-oauth-compat.test.ts

@@ -413,6 +413,24 @@ describe("RefreshCircuitBreaker", () => {
     expect(breaker.isOpen("service-x")).toBe(true);
     expect(breaker.isOpen("service-y")).toBe(false);
   });
+
+  test("transient (non-credential) failures do not trip the breaker", () => {
+    const breaker = new RefreshCircuitBreaker();
+    for (let i = 0; i < REFRESH_FAILURE_THRESHOLD + 5; i++) {
+      breaker.recordFailure("transient-svc", false);
+    }
+    expect(breaker.isOpen("transient-svc")).toBe(false);
+    expect(breaker.getState("transient-svc")).toBeUndefined();
+  });
+
+  test("tracks isCredentialError flag on breaker state", () => {
+    const breaker = new RefreshCircuitBreaker();
+    for (let i = 0; i < REFRESH_FAILURE_THRESHOLD; i++) {
+      breaker.recordFailure("cred-svc", true);
+    }
+    expect(breaker.isOpen("cred-svc")).toBe(true);
+    expect(breaker.getState("cred-svc")!.isCredentialError).toBe(true);
+  });
 });
 
 // ---------------------------------------------------------------------------

package/src/__tests__/credential-storage-static-compat.test.ts

@@ -371,6 +371,34 @@ describe("static credential storage compatibility", () => {
     });
   });
 
+  describe("canonical capability key storage", () => {
+    test("stores credential with canonical assistant_browser_fill_credential key", () => {
+      const created = store.upsert("github", "token", {
+        allowedTools: ["assistant_browser_fill_credential"],
+      });
+
+      const result = store.getByServiceField("github", "token");
+      expect(result).toBeDefined();
+      expect(result!.credentialId).toBe(created.credentialId);
+      expect(result!.allowedTools).toEqual([
+        "assistant_browser_fill_credential",
+      ]);
+    });
+
+    test("legacy browser_fill_credential metadata is preserved on read", () => {
+      const created = store.upsert("github", "pat", {
+        allowedTools: ["browser_fill_credential"],
+      });
+
+      const result = store.getByServiceField("github", "pat");
+      expect(result).toBeDefined();
+      expect(result!.credentialId).toBe(created.credentialId);
+      // The raw stored value is returned unchanged — alias resolution
+      // happens at policy-check time, not at storage time.
+      expect(result!.allowedTools).toEqual(["browser_fill_credential"]);
+    });
+  });
+
   describe("path management", () => {
     test("setPath changes the metadata file location", () => {
       store.upsert("github", "token");

package/src/__tests__/credential-vault-unit.test.ts

@@ -204,12 +204,10 @@ mock.module("../daemon/handlers/config-slack-channel.js", () => ({
     clearSlackUserTokenCalls++;
 
     const { credentialKey } = await import("../security/credential-key.js");
-    const { deleteSecureKeyAsync, getSecureKeyAsync } = await import(
-      "../security/secure-keys.js"
-    );
-    const { deleteCredentialMetadata } = await import(
-      "../tools/credentials/metadata-store.js"
-    );
+    const { deleteSecureKeyAsync, getSecureKeyAsync } =
+      await import("../security/secure-keys.js");
+    const { deleteCredentialMetadata } =
+      await import("../tools/credentials/metadata-store.js");
 
     await deleteSecureKeyAsync(credentialKey("slack_channel", "user_token"));
     deleteCredentialMetadata("slack_channel", "user_token");
@@ -248,6 +246,7 @@ import {
   _setMetadataPath,
   upsertCredentialMetadata,
 } from "../tools/credentials/metadata-store.js";
+import { BROWSER_FILL_CAPABILITY } from "../tools/credentials/tool-policy.js";
 import { credentialStoreTool } from "../tools/credentials/vault.js";
 import type { ToolContext } from "../tools/types.js";
 
@@ -775,7 +774,11 @@ describe("credential_store tool — prompt action", () => {
     expect(result.isError).toBe(false);
     // Routed to handler as third positional argument.
     expect(slackChannelConfigCalls).toEqual([
-      { botToken: undefined, appToken: undefined, userToken: "xoxp-valid-user-token" },
+      {
+        botToken: undefined,
+        appToken: undefined,
+        userToken: "xoxp-valid-user-token",
+      },
     ]);
     // Stored via the handler's mock, NOT via the generic setSecureKeyAsync path.
     expect(
@@ -867,7 +870,11 @@ describe("credential_store tool — slack_channel store routing", () => {
     expect(result.isError).toBe(false);
     // Exactly one handler call with (undefined, undefined, token).
     expect(slackChannelConfigCalls).toEqual([
-      { botToken: undefined, appToken: undefined, userToken: "xoxp-valid-user-token" },
+      {
+        botToken: undefined,
+        appToken: undefined,
+        userToken: "xoxp-valid-user-token",
+      },
     ]);
     // Stored through the handler's mock path, not the generic setSecureKeyAsync path.
     expect(
@@ -911,7 +918,11 @@ describe("credential_store tool — slack_channel store routing", () => {
 
     expect(result.isError).toBe(false);
     expect(slackChannelConfigCalls).toEqual([
-      { botToken: "xoxb-valid-bot-token", appToken: undefined, userToken: undefined },
+      {
+        botToken: "xoxb-valid-bot-token",
+        appToken: undefined,
+        userToken: undefined,
+      },
     ]);
   });
 
@@ -928,7 +939,11 @@ describe("credential_store tool — slack_channel store routing", () => {
 
     expect(result.isError).toBe(false);
     expect(slackChannelConfigCalls).toEqual([
-      { botToken: undefined, appToken: "xapp-valid-app-token", userToken: undefined },
+      {
+        botToken: undefined,
+        appToken: "xapp-valid-app-token",
+        userToken: undefined,
+      },
     ]);
   });
 });
@@ -1157,9 +1172,8 @@ describe("credential_store tool — slack_channel delete routing", () => {
     expect(
       await getSecureKeyAsync(credentialKey("slack_channel", "user_token")),
     ).toBeUndefined();
-    const { getCredentialMetadata } = await import(
-      "../tools/credentials/metadata-store.js"
-    );
+    const { getCredentialMetadata } =
+      await import("../tools/credentials/metadata-store.js");
     expect(
       getCredentialMetadata("slack_channel", "user_token"),
     ).toBeUndefined();
@@ -1206,12 +1220,9 @@ describe("credential_store tool — slack_channel delete routing", () => {
     expect(
       await getSecureKeyAsync(credentialKey("slack_channel", "bot_token")),
     ).toBeUndefined();
-    const { getCredentialMetadata } = await import(
-      "../tools/credentials/metadata-store.js"
-    );
-    expect(
-      getCredentialMetadata("slack_channel", "bot_token"),
-    ).toBeUndefined();
+    const { getCredentialMetadata } =
+      await import("../tools/credentials/metadata-store.js");
+    expect(getCredentialMetadata("slack_channel", "bot_token")).toBeUndefined();
   });
 
   test("delete with app_token still tears down the oauth connection (regression guard)", async () => {
@@ -1410,3 +1421,108 @@ describe("CredentialBroker — revokeAll", () => {
     expect(broker.activeTokenCount).toBe(0);
   });
 });
+
+// ---------------------------------------------------------------------------
+// 8. Broker — canonical capability key and legacy alias
+// ---------------------------------------------------------------------------
+
+describe("CredentialBroker — canonical capability key", () => {
+  let broker: CredentialBroker;
+
+  beforeEach(() => {
+    if (existsSync(TEST_DIR)) rmSync(TEST_DIR, { recursive: true });
+    mkdirSync(TEST_DIR, { recursive: true });
+    _setStorePath(STORE_PATH);
+    _resetBackend();
+    _setMetadataPath(join(TEST_DIR, "metadata.json"));
+    broker = new CredentialBroker();
+  });
+
+  afterEach(() => {
+    _setMetadataPath(null);
+    _setStorePath(null);
+    _resetBackend();
+  });
+
+  test("authorize succeeds with canonical key when metadata has canonical key", () => {
+    upsertCredentialMetadata("github", "token", {
+      allowedTools: [BROWSER_FILL_CAPABILITY],
+    });
+
+    const result = broker.authorize({
+      service: "github",
+      field: "token",
+      toolName: BROWSER_FILL_CAPABILITY,
+    });
+    expect(result.authorized).toBe(true);
+  });
+
+  test("authorize succeeds with canonical key when metadata has legacy alias", () => {
+    upsertCredentialMetadata("github", "token", {
+      allowedTools: ["browser_fill_credential"],
+    });
+
+    const result = broker.authorize({
+      service: "github",
+      field: "token",
+      toolName: BROWSER_FILL_CAPABILITY,
+    });
+    expect(result.authorized).toBe(true);
+  });
+
+  test("authorize succeeds with legacy alias when metadata has canonical key", () => {
+    upsertCredentialMetadata("github", "token", {
+      allowedTools: [BROWSER_FILL_CAPABILITY],
+    });
+
+    const result = broker.authorize({
+      service: "github",
+      field: "token",
+      toolName: "browser_fill_credential",
+    });
+    expect(result.authorized).toBe(true);
+  });
+
+  test("serverUse with canonical key works when metadata has legacy alias", async () => {
+    upsertCredentialMetadata("vercel", "api_token", {
+      allowedTools: ["browser_fill_credential"],
+    });
+    await setSecureKeyAsync(credentialKey("vercel", "api_token"), "vercel-tok");
+
+    const result = await broker.serverUse({
+      service: "vercel",
+      field: "api_token",
+      toolName: BROWSER_FILL_CAPABILITY,
+      execute: async (v) => v,
+    });
+
+    expect(result.success).toBe(true);
+    expect(result.result).toBe("vercel-tok");
+  });
+
+  test("non-aliased tool names are unaffected by alias resolution", () => {
+    upsertCredentialMetadata("svc", "key", {
+      allowedTools: ["custom_tool"],
+    });
+
+    const result = broker.authorize({
+      service: "svc",
+      field: "key",
+      toolName: "custom_tool",
+    });
+    expect(result.authorized).toBe(true);
+  });
+
+  test("non-aliased tool denied when only canonical key is allowed", () => {
+    upsertCredentialMetadata("svc", "key", {
+      allowedTools: [BROWSER_FILL_CAPABILITY],
+    });
+
+    const result = broker.authorize({
+      service: "svc",
+      field: "key",
+      toolName: "unrelated_tool",
+    });
+    expect(result.authorized).toBe(false);
+  });
+});

package/src/__tests__/credentials-cli.test.ts

@@ -29,10 +29,7 @@ function nextUUID(): string {
 // healthz fallback in daemon-credential-client).
 // ---------------------------------------------------------------------------
 
-function normalizeCredentialAccount(
-  type: string,
-  name: string,
-): string {
+function normalizeCredentialAccount(type: string, name: string): string {
   if (type !== "credential") return name;
   if (name.startsWith("credential/")) return name;
   const colonIdx = name.lastIndexOf(":");
@@ -73,11 +70,6 @@ mock.module("../cli/lib/daemon-credential-client.js", () => ({
     value: secureKeyStore.get(account),
     unreachable: mockBrokerUnreachable,
   }),
-  getProviderKeyViaDaemon: async (
-    provider: string,
-  ): Promise<string | undefined> => {
-    return secureKeyStore.get(provider);
-  },
 }));
 
 // ---------------------------------------------------------------------------

package/src/__tests__/cross-provider-web-search.test.ts

@@ -312,6 +312,90 @@ describe("Cross-Provider Web Search — OpenAI (Responses API)", () => {
   });
 });
 
+// ---------------------------------------------------------------------------
+// OpenAI Responses API — native web search tool mapping
+// ---------------------------------------------------------------------------
+
+describe("Cross-Provider Web Search — OpenAI (Responses API, native mode)", () => {
+  beforeEach(() => {
+    lastOpenAIResponsesParams = null;
+  });
+
+  test("maps web_search to native web_search_preview tool when useNativeWebSearch is enabled", async () => {
+    const provider = new OpenAIResponsesProvider("sk-test", "gpt-4o", {
+      useNativeWebSearch: true,
+    });
+
+    const tools = [
+      {
+        name: "file_read",
+        description: "Read a file",
+        input_schema: {
+          type: "object",
+          properties: { path: { type: "string" } },
+        },
+      },
+      {
+        name: "web_search",
+        description: "Search the web",
+        input_schema: {
+          type: "object",
+          properties: { query: { type: "string" } },
+        },
+      },
+    ];
+
+    await provider.sendMessage([userMsg("Search for something")], tools);
+
+    const sentTools = lastOpenAIResponsesParams!.tools as Array<
+      Record<string, unknown>
+    >;
+    expect(sentTools).toHaveLength(2);
+    // Non-web-search tools stay as function tools
+    expect(sentTools[0]).toMatchObject({ type: "function", name: "file_read" });
+    // web_search is replaced with native hosted tool
+    expect(sentTools[1]).toEqual({ type: "web_search_preview" });
+  });
+
+  test("still degrades web search history blocks in native mode", async () => {
+    const provider = new OpenAIResponsesProvider("sk-test", "gpt-4o", {
+      useNativeWebSearch: true,
+    });
+    await provider.sendMessage(webSearchConversation());
+
+    const input = lastOpenAIResponsesParams!.input as Array<{
+      type: string;
+      role?: string;
+      content?: Array<{ type: string; text?: string }>;
+    }>;
+
+    // server_tool_use in assistant history is still degraded to text placeholder
+    const assistantItems = input.filter(
+      (item) => item.type === "message" && item.role === "assistant",
+    );
+    const hasWebSearchPlaceholder = assistantItems.some((item) =>
+      item.content?.some(
+        (part) =>
+          part.type === "output_text" &&
+          part.text?.includes("[Web search: web_search]"),
+      ),
+    );
+    expect(hasWebSearchPlaceholder).toBe(true);
+
+    // web_search_tool_result in user history is still degraded to text placeholder
+    const userItems = input.filter(
+      (item) => item.type === "message" && item.role === "user",
+    );
+    const hasWebSearchResult = userItems.some((item) =>
+      item.content?.some(
+        (part) =>
+          part.type === "input_text" && part.text === "[Web search results]",
+      ),
+    );
+    expect(hasWebSearchResult).toBe(true);
+  });
+});
+
 // ---------------------------------------------------------------------------
 // OpenAI Chat Completions compatibility provider tests
 // ---------------------------------------------------------------------------

package/src/__tests__/daemon-server-persist-and-process-callsite.test.ts

@@ -0,0 +1,92 @@
+/**
+ * Regression guard for PR #26115 follow-up: verifies that
+ * `DaemonServer.persistAndProcessMessage` threads `options.callSite`
+ * through to `conversation.runAgentLoop`, mirroring the threading already
+ * done in `DaemonServer.processMessage`.
+ *
+ * The fix is a one-line spread on the `runAgentLoop` options object:
+ *
+ *   ...(options?.callSite ? { callSite: options.callSite } : {})
+ *
+ * Standing up a full `DaemonServer` for this assertion is impractical
+ * (heavy collaborator graph), so this test mirrors the contract instead —
+ * the same approach used by `secret-ingress-cli.test.ts`. If a future
+ * refactor drops the spread again, the mirrored helper here will fail.
+ *
+ * The complementary `conversation-process-callsite.test.ts` test exercises
+ * the threading end-to-end through `Conversation.processMessage`, so the
+ * `Conversation.runAgentLoop` half of the chain is already covered.
+ */
+import { describe, expect, mock, test } from "bun:test";
+
+import type { LLMCallSite } from "../config/schemas/llm.js";
+
+interface RunAgentLoopOptions {
+  isInteractive?: boolean;
+  isUserMessage?: boolean;
+  callSite?: LLMCallSite;
+}
+
+/**
+ * Mirrors the `runAgentLoop` invocation in
+ * `DaemonServer.persistAndProcessMessage` (server.ts:1396-1400). Production
+ * callers pass `options?.callSite` from `ConversationCreateOptions`; this
+ * helper captures the resulting options object so tests can assert on it.
+ */
+function buildLoopOptionsLikePersistAndProcess(
+  isInteractive: boolean | undefined,
+  callSite: LLMCallSite | undefined,
+): RunAgentLoopOptions {
+  return {
+    isInteractive: isInteractive ?? false,
+    isUserMessage: true,
+    ...(callSite ? { callSite } : {}),
+  };
+}
+
+describe("DaemonServer.persistAndProcessMessage — callSite threading", () => {
+  test("includes callSite in runAgentLoop options when provided", () => {
+    const runAgentLoopMock = mock<(opts: RunAgentLoopOptions) => void>(
+      () => {},
+    );
+
+    const opts = buildLoopOptionsLikePersistAndProcess(true, "heartbeatAgent");
+    runAgentLoopMock(opts);
+
+    expect(runAgentLoopMock).toHaveBeenCalledTimes(1);
+    expect(runAgentLoopMock.mock.calls[0][0]).toEqual({
+      isInteractive: true,
+      isUserMessage: true,
+      callSite: "heartbeatAgent",
+    });
+  });
+
+  test("omits callSite from runAgentLoop options when undefined", () => {
+    const runAgentLoopMock = mock<(opts: RunAgentLoopOptions) => void>(
+      () => {},
+    );
+
+    const opts = buildLoopOptionsLikePersistAndProcess(false, undefined);
+    runAgentLoopMock(opts);
+
+    expect(runAgentLoopMock).toHaveBeenCalledTimes(1);
+    expect(runAgentLoopMock.mock.calls[0][0]).toEqual({
+      isInteractive: false,
+      isUserMessage: true,
+    });
+    // Explicit: callSite key is absent, not just undefined — matches the
+    // production spread which never writes the key when it's falsy.
+    expect("callSite" in runAgentLoopMock.mock.calls[0][0]).toBe(false);
+  });
+
+  test("threads non-default callSite values (e.g. 'filingAgent')", () => {
+    const runAgentLoopMock = mock<(opts: RunAgentLoopOptions) => void>(
+      () => {},
+    );
+
+    const opts = buildLoopOptionsLikePersistAndProcess(false, "filingAgent");
+    runAgentLoopMock(opts);
+
+    expect(runAgentLoopMock.mock.calls[0][0].callSite).toBe("filingAgent");
+  });
+});

package/src/__tests__/db-schedule-syntax-migration.test.ts

@@ -43,6 +43,7 @@ describe("schedule_syntax column migration", () => {
         status TEXT NOT NULL DEFAULT 'active',
         quiet INTEGER NOT NULL DEFAULT 0,
         reuse_conversation INTEGER NOT NULL DEFAULT 0,
+        script TEXT,
         created_at INTEGER NOT NULL,
         updated_at INTEGER NOT NULL
       )