@vellumai/assistant 0.10.8 → 0.10.9-dev.202607152225.ec6fdbf

package/src/runtime/routes/__tests__/plugins-routes.test.ts

@@ -14,7 +14,7 @@
  *   - A catalog fetch failure degrades `category` to null without erroring
  *
  * GET /v1/plugins/search (catalog search):
- *   - Forwards `?q=` and `?ref=` to the `searchPlugins` lib
+ *   - Resolves the catalog for `?ref=` and filters it by `?q=`
  *   - Empty / missing `?q=` is passed through as the empty-regex
  *     ("match-all") query — the lib's documented contract
  *   - Wraps `InvalidSearchPatternError` into a 400 (BadRequestError)
@@ -70,6 +70,7 @@ import {
   type InstallPluginOptions,
   type InstallPluginResult,
   InvalidPluginNameError,
+  isFullCommitSha,
   PluginAlreadyInstalledError,
   PluginNotFoundError,
   PluginSourceUnavailableError,
@@ -111,6 +112,24 @@ import {
   type UpgradePluginOptions,
 } from "../../../cli/lib/upgrade-plugin.js";
 
+// Spy on the route logger so tests can assert that a platform-catalog outage
+// is recorded before it is mapped to a client 503. The catalog fetcher and the
+// transport adapters swallow the failure otherwise (`RouteError` → wire error,
+// no capture), so the log line is the only trace an operator gets — assert it.
+const logErrorSpy = mock((..._args: unknown[]) => {});
+const logWarnSpy = mock((..._args: unknown[]) => {});
+
+mock.module("../../../util/logger.js", () => ({
+  getLogger: () => ({
+    info: () => {},
+    warn: logWarnSpy,
+    error: logErrorSpy,
+    debug: () => {},
+    trace: () => {},
+    fatal: () => {},
+  }),
+}));
+
 // Mutable list returned by the mocked library function. Tests reassign
 // `installedFixture` before invoking the handler.
 let installedFixture: InstalledPluginInfo[] = [];
@@ -181,6 +200,9 @@ mock.module("../../../cli/lib/install-from-github.js", () => ({
   // path from `:name` rather than delegating to a lib that sanitizes), so pass
   // the real `sanitizePluginName` through — a traversal name must still 400.
   sanitizePluginName,
+  // The (unmocked) catalog resolver enforces the full-SHA pin invariant via the
+  // real `isFullCommitSha`, so pass it through rather than the default undefined.
+  isFullCommitSha,
   installPlugin: installSpy,
 }));
 
@@ -298,6 +320,11 @@ const broadcastMessageSpy = mock((_msg: unknown): void => {});
 
 mock.module("../../assistant-event-hub.js", () => ({
   broadcastMessage: broadcastMessageSpy,
+  // Stub the hub singleton so the (now dynamically imported) plugins-routes
+  // dependency graph links — some transitive importer statically imports this
+  // binding. No tested path calls it; publishing goes through the mocked
+  // `broadcastMessage` above.
+  assistantEventHub: {},
 }));
 
 // Make the valid-slug source deterministic: the real `getLocalCategorySlugs`
@@ -331,11 +358,15 @@ import {
   NotFoundError,
   ServiceUnavailableError,
 } from "../errors.js";
-import {
+// `plugins-routes.js` is dynamically imported AFTER the logger mock above so
+// its module-level `const log = getLogger(...)` binds to the mocked logger. A
+// static import evaluates before any `mock.module` runs and would capture the
+// real logger at module init (same reason as `request-logger.test.ts`).
+const {
   loadCategoryMapBounded,
   normalizeMarketplaceCategory,
-  ROUTES as PLUGINS_ROUTES,
-} from "../plugins-routes.js";
+  ROUTES: PLUGINS_ROUTES,
+}: typeof import("../plugins-routes.js") = await import("../plugins-routes.js");
 import type { RouteDefinition, RouteHandlerArgs } from "../types.js";
 import { RouteResponse } from "../types.js";
 
@@ -993,6 +1024,32 @@ describe("GET /v1/plugins/search", () => {
     });
   });
 
+  test("projects the marketplace `icon` onto the wire match, omitting it when absent", async () => {
+    getCatalogSpy.mockImplementation(async (ref) =>
+      catalog(ref, [
+        {
+          name: "calendar-sync",
+          path: "github:acme/calendar-sync@v1",
+          icon: "📅",
+          category: null,
+          source: { kind: "github", repo: "acme/calendar-sync", ref: "v1" },
+        },
+        {
+          name: "plain-plugin",
+          path: "github:acme/plain-plugin@v1",
+          category: null,
+          source: { kind: "github", repo: "acme/plain-plugin", ref: "v1" },
+        },
+      ]),
+    );
+
+    const result = await invokeSearch();
+    const byName = new Map(result.matches.map((m) => [m.name, m]));
+    expect(byName.get("calendar-sync")?.icon).toBe("📅");
+    // Absent icon is omitted from the wire object, not set to null/undefined.
+    expect("icon" in byName.get("plain-plugin")!).toBe(false);
+  });
+
   test("normalizes match categories to the Skills taxonomy (`developer` → `development`, `hobby` → null)", async () => {
     getCatalogSpy.mockImplementation(async (ref) =>
       catalog(ref, [
@@ -1069,6 +1126,7 @@ describe("GET /v1/plugins/search", () => {
   });
 
   test("PluginCatalogUnavailableError → ServiceUnavailableError (503)", async () => {
+    logErrorSpy.mockClear();
     getCatalogSpy.mockImplementation(async () => {
       throw new PluginCatalogUnavailableError(
         "GitHub contents listing failed for plugins @ main: HTTP 403",
@@ -1081,6 +1139,14 @@ describe("GET /v1/plugins/search", () => {
     await expect(
       invokeSearch({ queryParams: { q: "memory" } }),
     ).rejects.toBeInstanceOf(ServiceUnavailableError);
+
+    // The outage must be logged before it is mapped to a 503 — otherwise the
+    // transport adapters return the RouteError with no capture and the incident
+    // is invisible. The log carries the true upstream status the 503 collapses.
+    expect(logErrorSpy).toHaveBeenCalledTimes(1);
+    const [fields, msg] = logErrorSpy.mock.calls[0]!;
+    expect(msg).toBe("Platform plugin catalog unavailable");
+    expect(fields).toMatchObject({ operation: "search", upstreamStatus: 403 });
   });
 
   test("unknown errors → InternalError with original message preserved", async () => {
@@ -1362,6 +1428,18 @@ describe("GET /v1/plugins/:name", () => {
     ).rejects.toBeInstanceOf(NotFoundError);
   });
 
+  test("PluginCatalogUnavailableError → ServiceUnavailableError (503)", async () => {
+    // A catalog outage blocking a remote-only detail view is transient — the
+    // handler surfaces it as retryable rather than a misleading 404/500.
+    detailsSpy.mockImplementation(async () => {
+      throw new PluginCatalogUnavailableError("HTTP 503", 503);
+    });
+
+    await expect(
+      invokeGet({ pathParams: { name: "caveman" } }),
+    ).rejects.toBeInstanceOf(ServiceUnavailableError);
+  });
+
   test("unknown errors → InternalError with original message preserved", async () => {
     detailsSpy.mockImplementation(async () => {
       throw new Error("ENOTFOUND api.github.com");
@@ -1394,50 +1472,91 @@ async function invokeInstall(args: RouteHandlerArgs = {}): Promise<{
   };
 }
 
+// A gated-catalog match for `caveman` pinned to an immutable full commit SHA —
+// the shape the resolver projects onto trusted install coordinates. Mirrors the
+// bundled manifest: platform-first live, or the bundled pin when platform
+// features are off.
+const CAVEMAN_PIN = "63a91ecadbf4c4719a4602a5abb00883f9966034";
+const CAVEMAN_CATALOG_MATCH: PluginSearchMatch = {
+  name: "caveman",
+  path: `github:JuliusBrussee/caveman@${CAVEMAN_PIN}`,
+  description: "Ultra-compressed communication mode.",
+  category: null,
+  source: { kind: "github", repo: "JuliusBrussee/caveman", ref: CAVEMAN_PIN },
+};
+
+// installPlugin result for a trustedSource install: the returned `ref` is the
+// trusted pin (the external content commit), not the default branch.
+function trustedInstallResult(opts: InstallPluginOptions): InstallPluginResult {
+  return {
+    name: opts.name,
+    target: `/workspace/.vellum/plugins/${opts.name}`,
+    fileCount: 7,
+    ref: opts.trustedSource?.ref ?? opts.ref ?? "main",
+    commit: opts.trustedSource?.ref ?? null,
+    committedAt: null,
+  };
+}
+
 describe("POST /v1/plugins/install", () => {
   beforeEach(() => {
     installSpy.mockReset();
     resolvePinSpy.mockReset();
     broadcastMessageSpy.mockReset();
+    getCatalogSpy.mockReset();
+    // Default: the gated catalog resolves `caveman` to its bundled full-SHA pin.
+    getCatalogSpy.mockImplementation(async (ref) =>
+      catalog(ref, [CAVEMAN_CATALOG_MATCH]),
+    );
   });
 
-  test("forwards name/force and shapes the result, pinning ref to the default", async () => {
-    installSpy.mockImplementation(async (opts) => ({
-      name: opts.name,
-      target: `/workspace/.vellum/plugins/${opts.name}`,
-      fileCount: 7,
-      ref: opts.ref ?? "main",
-      commit: null,
-      committedAt: null,
-    }));
-
-    const result = await invokeInstall({
-      body: { name: "caveman", force: true },
-    });
-
-    expect(result).toEqual({
-      ok: true,
-      name: "caveman",
-      target: "/workspace/.vellum/plugins/caveman",
-      fileCount: 7,
-      ref: "main",
-    });
-    expect(installSpy.mock.calls[0]?.[0]).toEqual({
-      name: "caveman",
-      ref: "main",
-      force: true,
-    });
+  test("no-pin install resolves from the gated catalog and installs via trustedSource", async () => {
+    // The default (no-pin) path reads the same gated catalog `search`
+    // advertises and installs from a trusted pre-resolved source — no direct
+    // `plugins/marketplace.json` fetch (the pin/marketplace path is untouched).
+    const prev = process.env.VELLUM_DISABLE_PLATFORM;
+    process.env.VELLUM_DISABLE_PLATFORM = "true";
+    try {
+      installSpy.mockImplementation(async (opts) => trustedInstallResult(opts));
+
+      const result = await invokeInstall({
+        body: { name: "caveman", force: true },
+      });
+
+      // Resolved through the gated catalog, not the pin/marketplace path.
+      expect(getCatalogSpy).toHaveBeenCalledTimes(1);
+      expect(resolvePinSpy).not.toHaveBeenCalled();
+      // installPlugin receives the pre-resolved trusted coordinates (owner/repo
+      // split from the catalog `repo`, `rootPath` from its path, the full-SHA
+      // pin as `ref`) — no caller-supplied `ref`.
+      expect(installSpy.mock.calls[0]?.[0]).toEqual({
+        name: "caveman",
+        force: true,
+        trustedSource: {
+          owner: "JuliusBrussee",
+          repo: "caveman",
+          rootPath: "",
+          ref: CAVEMAN_PIN,
+        },
+      });
+      expect(result).toEqual({
+        ok: true,
+        name: "caveman",
+        target: "/workspace/.vellum/plugins/caveman",
+        fileCount: 7,
+        ref: CAVEMAN_PIN,
+      });
+    } finally {
+      if (prev === undefined) {
+        delete process.env.VELLUM_DISABLE_PLATFORM;
+      } else {
+        process.env.VELLUM_DISABLE_PLATFORM = prev;
+      }
+    }
   });
 
   test("publishes sync_changed(plugins:list) on a successful install", async () => {
-    installSpy.mockImplementation(async (opts) => ({
-      name: opts.name,
-      target: `/workspace/.vellum/plugins/${opts.name}`,
-      fileCount: 7,
-      ref: opts.ref ?? "main",
-      commit: null,
-      committedAt: null,
-    }));
+    installSpy.mockImplementation(async (opts) => trustedInstallResult(opts));
 
     await invokeInstall({ body: { name: "caveman" } });
 
@@ -1445,14 +1564,7 @@ describe("POST /v1/plugins/install", () => {
   });
 
   test("threads x-vellum-client-id into the published event's originClientId", async () => {
-    installSpy.mockImplementation(async (opts) => ({
-      name: opts.name,
-      target: `/workspace/.vellum/plugins/${opts.name}`,
-      fileCount: 7,
-      ref: opts.ref ?? "main",
-      commit: null,
-      committedAt: null,
-    }));
+    installSpy.mockImplementation(async (opts) => trustedInstallResult(opts));
 
     await invokeInstall({
       body: { name: "caveman" },
@@ -1466,46 +1578,86 @@ describe("POST /v1/plugins/install", () => {
     });
   });
 
-  test("ignores a caller-supplied ref and pins to the curated default", async () => {
+  test("ignores a caller-supplied ref and installs from the catalog-resolved source", async () => {
     // Security boundary: installing from an unreviewed ref (a PR branch,
-    // fork ref, ...) could load attacker-controlled marketplace code, so the
-    // HTTP route never honors a body `ref` — it always resolves
-    // against the curated default ref.
-    installSpy.mockImplementation(async (opts) => ({
-      name: opts.name,
-      target: `/workspace/.vellum/plugins/${opts.name}`,
-      fileCount: 7,
-      ref: opts.ref ?? "main",
-      commit: null,
-      committedAt: null,
-    }));
+    // fork ref, ...) could load attacker-controlled code, so the HTTP route
+    // never honors a body `ref` — the no-pin source comes only from the gated
+    // catalog.
+    installSpy.mockImplementation(async (opts) => trustedInstallResult(opts));
 
     const result = await invokeInstall({
       body: { name: "caveman", ref: "attacker-pr-branch" },
     });
 
-    expect(result.ref).toBe("main");
+    expect(result.ref).toBe(CAVEMAN_PIN);
     expect(installSpy.mock.calls[0]?.[0]).toEqual({
       name: "caveman",
-      ref: "main",
       force: undefined,
+      trustedSource: {
+        owner: "JuliusBrussee",
+        repo: "caveman",
+        rootPath: "",
+        ref: CAVEMAN_PIN,
+      },
     });
   });
 
+  test("an unknown name (no pin) → NotFoundError (404), no install", async () => {
+    // The catalog claims no such plugin, so the resolver returns null.
+    getCatalogSpy.mockImplementation(async (ref) => catalog(ref, []));
+
+    await expect(
+      invokeInstall({ body: { name: "ghost" } }),
+    ).rejects.toBeInstanceOf(NotFoundError);
+    expect(installSpy).not.toHaveBeenCalled();
+  });
+
+  test("a catalog outage on the no-pin path → ServiceUnavailableError (503)", async () => {
+    // A rate-limited or unavailable platform catalog (no stale fallback) is
+    // transient — the route surfaces it as retryable, not a misleading 500.
+    logErrorSpy.mockClear();
+    getCatalogSpy.mockImplementation(async () => {
+      throw new PluginCatalogUnavailableError("HTTP 403", 403);
+    });
+
+    await expect(
+      invokeInstall({ body: { name: "caveman" } }),
+    ).rejects.toBeInstanceOf(ServiceUnavailableError);
+    expect(installSpy).not.toHaveBeenCalled();
+
+    // The outage is logged (operation "install") before the 503 mapping, so
+    // an install-path catalog failure is diagnosable rather than invisible.
+    expect(logErrorSpy).toHaveBeenCalledTimes(1);
+    const [fields, msg] = logErrorSpy.mock.calls[0]!;
+    expect(msg).toBe("Platform plugin catalog unavailable");
+    expect(fields).toMatchObject({ operation: "install", upstreamStatus: 403 });
+  });
+
   test("a missing name short-circuits to BadRequestError without calling the lib", async () => {
     await expect(invokeInstall({ body: {} })).rejects.toBeInstanceOf(
       BadRequestError,
     );
     expect(installSpy).not.toHaveBeenCalled();
+    expect(getCatalogSpy).not.toHaveBeenCalled();
+  });
+
+  test("an invalid name (no pin) → BadRequestError before the catalog lookup", async () => {
+    // A malformed install name is validated up front via `sanitizePluginName`,
+    // so it's a deterministic 400 — never a 404/503 from resolving the catalog.
+    await expect(
+      invokeInstall({ body: { name: "../escape" } }),
+    ).rejects.toBeInstanceOf(BadRequestError);
+    expect(getCatalogSpy).not.toHaveBeenCalled();
+    expect(installSpy).not.toHaveBeenCalled();
   });
 
   test("InvalidPluginNameError → BadRequestError (400)", async () => {
     installSpy.mockImplementation(async () => {
-      throw new InvalidPluginNameError("../escape");
+      throw new InvalidPluginNameError("bad plugin name");
     });
 
     await expect(
-      invokeInstall({ body: { name: "../escape" } }),
+      invokeInstall({ body: { name: "caveman" } }),
     ).rejects.toBeInstanceOf(BadRequestError);
   });
 
@@ -1528,7 +1680,7 @@ describe("POST /v1/plugins/install", () => {
     });
 
     await expect(
-      invokeInstall({ body: { name: "ghost" } }),
+      invokeInstall({ body: { name: "caveman" } }),
     ).rejects.toBeInstanceOf(NotFoundError);
     // A failed install must not fan out a spurious invalidation.
     expect(broadcastMessageSpy).not.toHaveBeenCalled();
@@ -1587,7 +1739,9 @@ describe("POST /v1/plugins/install", () => {
     });
 
     // THEN the install reads the manifest at the resolving marketplace commit,
-    // not the default branch
+    // not the default branch, and the gated catalog resolver is bypassed — the
+    // pin path stays on the reviewed pin-history/GitHub route.
+    expect(getCatalogSpy).not.toHaveBeenCalled();
     expect(installSpy.mock.calls[0]?.[0]).toEqual({
       name: "caveman",
       ref: "f".repeat(40),

package/src/runtime/routes/__tests__/question-routes.test.ts

@@ -76,10 +76,8 @@ afterEach(() => {
 describe("POST /v1/question-response", () => {
   test("submit: resolves a one-question batch with an option entry", async () => {
     const resolved: QuestionPromptResult[] = [];
-    registerQuestion(
-      "req-1",
-      [{ id: "q1", options: ["yes", "no"] }],
-      (v) => resolved.push(v as QuestionPromptResult),
+    registerQuestion("req-1", [{ id: "q1", options: ["yes", "no"] }], (v) =>
+      resolved.push(v as QuestionPromptResult),
     );
 
     const result = await call({

package/src/runtime/routes/__tests__/retrospective-routes.test.ts

@@ -16,14 +16,7 @@
 import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
-
-mock.module("../../../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 
 import { invalidateConfigCache } from "../../../config/loader.js";
 import { createConversation } from "../../../persistence/conversation-crud.js";

package/src/runtime/routes/__tests__/sanity-routes.test.ts

@@ -25,13 +25,6 @@ mock.module("../../../security/secure-keys.js", () => ({
   getSecureKeyAsync: async (_key: string) => storedToken,
 }));
 
-mock.module("../../../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
-
 const FAKE_WORKSPACE = "/tmp/sanity-routes-test-workspace";
 
 mock.module("../../../util/platform.js", () => ({

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

@@ -35,7 +35,8 @@ describe("createSchedule route — script mode", () => {
     const { schedule } = await create({
       name: "wt-script-create",
       mode: "script",
-      script: 'cd "$VELLUM_WORKSPACE_DIR/schedules/$__SCHEDULE_ID" && bun poll.ts',
+      script:
+        'cd "$VELLUM_WORKSPACE_DIR/schedules/$__SCHEDULE_ID" && bun poll.ts',
       expression: "*/15 * * * *",
       description: "polls github",
       timeoutMs: 120000,

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

@@ -1,18 +1,15 @@
 /**
  * Tests for the schedule worker control routes (start / stop / status).
  *
- * The route handlers run inside the daemon and own the worker process. We mock
- * schedule worker-control and the config loader so the tests assert handler
- * behaviour:
- *   - start spawns as a daemon child (detached:false), enables the flag only on
- *     success, and throws on spawn failure (flag untouched).
- *   - stop disables the flag and signals the worker.
- *   - status reports the worker process, the flag, and the in-process runner.
+ * The route handlers run inside the daemon and manage the worker process. We
+ * mock schedule worker-control so the tests assert handler behaviour:
+ *   - start spawns as a daemon child (detached:false) and throws on failure.
+ *   - stop signals the worker and reports its prior state.
+ *   - status reports the worker process liveness.
  */
 
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
-import * as actualLoader from "../../../config/loader.js";
 import { getScheduleWorkerPidPath } from "../../../util/platform.js";
 
 class FakeSpawnError extends Error {}
@@ -20,12 +17,9 @@ class FakeSpawnError extends Error {}
 let spawnImpl: () => Promise<{ pid: number; alreadyRunning: boolean }>;
 let spawnArgs: Array<{ detached?: boolean; terminateOnTimeout?: boolean }> = [];
 let stopImpl: () => { status: "running" | "not_running"; pid?: number };
-/** Records the `schedules.worker.enabled` values written via saveRawConfig. */
-let enabledCalls: boolean[] = [];
 let workerProbe: { status: "running" | "not_running"; pid?: number } = {
   status: "not_running",
 };
-let configEnabled = false;
 
 mock.module("../../../schedule/worker-control.js", () => ({
   ScheduleWorkerSpawnError: FakeSpawnError,
@@ -40,17 +34,6 @@ mock.module("../../../schedule/worker-control.js", () => ({
   probeScheduleWorker: () => workerProbe,
 }));
 
-mock.module("../../../config/loader.js", () => ({
-  ...actualLoader,
-  getConfigReadOnly: () => ({
-    schedules: { worker: { enabled: configEnabled } },
-  }),
-  loadRawConfig: () => ({}),
-  saveRawConfig: (cfg: { schedules?: { worker?: { enabled?: boolean } } }) => {
-    enabledCalls.push(cfg.schedules?.worker?.enabled === true);
-  },
-}));
-
 const { ROUTES } = await import("../schedule-worker-routes.js");
 
 function handler(operationId: string) {
@@ -63,25 +46,21 @@ function handler(operationId: string) {
 
 beforeEach(() => {
   spawnArgs = [];
-  enabledCalls = [];
   spawnImpl = async () => ({ pid: 4242, alreadyRunning: false });
   stopImpl = () => ({ status: "not_running" });
   workerProbe = { status: "not_running" };
-  configEnabled = false;
 });
 
 describe("schedules_worker_start", () => {
-  test("spawns as a daemon child and enables the flag on success", async () => {
+  test("spawns as a daemon child and returns the PID", async () => {
     spawnImpl = async () => ({ pid: 4242, alreadyRunning: false });
 
     const res = await handler("schedules_worker_start")();
 
-    expect(spawnArgs).toEqual([{ detached: false, terminateOnTimeout: true }]);
-    expect(enabledCalls).toEqual([true]);
+    expect(spawnArgs).toEqual([{ detached: false }]);
     expect(res).toEqual({
       pid: 4242,
       alreadyRunning: false,
-      workerEnabled: true,
       pidPath: getScheduleWorkerPidPath(),
     });
   });
@@ -92,10 +71,9 @@ describe("schedules_worker_start", () => {
     const res = await handler("schedules_worker_start")();
 
     expect(res).toMatchObject({ pid: 99, alreadyRunning: true });
-    expect(enabledCalls).toEqual([true]);
   });
 
-  test("throws and leaves the flag untouched when the spawn fails", async () => {
+  test("throws when the spawn fails", async () => {
     spawnImpl = async () => {
       throw new FakeSpawnError("worker exited during startup");
     };
@@ -103,59 +81,41 @@ describe("schedules_worker_start", () => {
     await expect(handler("schedules_worker_start")()).rejects.toThrow(
       "worker exited during startup",
     );
-    expect(enabledCalls).toEqual([]);
   });
 });
 
 describe("schedules_worker_stop", () => {
-  test("disables the flag and reports a signalled running worker", async () => {
+  test("reports a signalled running worker", async () => {
     stopImpl = () => ({ status: "running", pid: 555 });
 
     const res = await handler("schedules_worker_stop")();
 
-    expect(enabledCalls).toEqual([false]);
-    expect(res).toEqual({
-      workerWasRunning: true,
-      pid: 555,
-      workerEnabled: false,
-    });
+    expect(res).toEqual({ workerWasRunning: true, pid: 555 });
   });
 
-  test("disables the flag and succeeds when no worker is running", async () => {
+  test("succeeds when no worker is running", async () => {
     stopImpl = () => ({ status: "not_running" });
 
     const res = await handler("schedules_worker_stop")();
 
-    expect(enabledCalls).toEqual([false]);
-    expect(res).toEqual({ workerWasRunning: false, workerEnabled: false });
+    expect(res).toEqual({ workerWasRunning: false });
   });
 });
 
 describe("schedules_worker_status", () => {
-  test("reports a running worker with the flag on and the in-process scheduler standing down", async () => {
+  test("reports a running worker with its PID", async () => {
     workerProbe = { status: "running", pid: 321 };
-    configEnabled = true;
 
     const res = await handler("schedules_worker_status")();
 
-    expect(res).toEqual({
-      status: "running",
-      pid: 321,
-      workerEnabled: true,
-      inProcessScheduler: { status: "not_running" },
-    });
+    expect(res).toEqual({ status: "running", pid: 321 });
   });
 
-  test("reports the daemon as the schedule runner when the flag is off", async () => {
+  test("reports not_running when the worker process is absent", async () => {
     workerProbe = { status: "not_running" };
-    configEnabled = false;
 
     const res = await handler("schedules_worker_status")();
 
-    expect(res).toEqual({
-      status: "not_running",
-      workerEnabled: false,
-      inProcessScheduler: { status: "running", pid: process.pid },
-    });
+    expect(res).toEqual({ status: "not_running" });
   });
 });

package/src/runtime/routes/__tests__/stt-routes.test.ts

@@ -8,16 +8,7 @@ import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 // ---------------------------------------------------------------------------
 // Module mocks — must appear before any imports of the modules under test
 // ---------------------------------------------------------------------------
-
-mock.module("../../../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
-
 // -- Transcriber mock -------------------------------------------------------
-
 import type { BatchTranscriber } from "../../../stt/types.js";
 import { SttError } from "../../../stt/types.js";
 

package/src/runtime/routes/__tests__/suggest-trust-rule-routes.test.ts

@@ -14,13 +14,6 @@ import { beforeEach, describe, expect, mock, test } from "bun:test";
 // Mocks — must be defined before importing the module under test
 // ---------------------------------------------------------------------------
 
-mock.module("../../../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
-
 let mockSendMessage = mock(async () => ({
   content: [
     {