@vellumai/assistant 0.12.1-staging.1 → 0.12.1

package/src/__tests__/computer-use-skill-proxy-bridge.test.ts

@@ -13,11 +13,8 @@ describe("forwardComputerUseProxyTool", () => {
     );
 
     expect(result.isError).toBe(true);
-    expect(result.content).toContain(
-      "The Vellum desktop app is needed to view or control your screen",
-    );
-    expect(result.content).toContain("https://www.vellum.ai/downloads");
-    expect(result.content).not.toContain("computer_use_click");
+    expect(result.content).toContain("no proxy resolver available");
+    expect(result.content).toContain("computer_use_click");
   });
 
   test("forwards to proxyToolResolver when present", async () => {

package/src/__tests__/computer-use-tools.test.ts

@@ -104,10 +104,7 @@ describe("computer_use_click (unified)", () => {
   test("execute returns isError when no proxy resolver is configured", async () => {
     const result = await computerUseClickTool.execute({}, ctx);
     expect(result.isError).toBe(true);
-    expect(result.content).toContain(
-      "The Vellum desktop app is needed to view or control your screen",
-    );
-    expect(result.content).toContain("https://www.vellum.ai/downloads");
+    expect(result.content).toMatch(/No proxy resolver/);
   });
 });
 
@@ -122,10 +119,7 @@ describe("computer_use_type_text", () => {
   test("execute returns isError when no proxy resolver is configured", async () => {
     const result = await computerUseTypeTextTool.execute({}, ctx);
     expect(result.isError).toBe(true);
-    expect(result.content).toContain(
-      "The Vellum desktop app is needed to view or control your screen",
-    );
-    expect(result.content).toContain("https://www.vellum.ai/downloads");
+    expect(result.content).toMatch(/No proxy resolver/);
   });
 });
 
@@ -140,10 +134,7 @@ describe("computer_use_key", () => {
   test("execute returns isError when no proxy resolver is configured", async () => {
     const result = await computerUseKeyTool.execute({}, ctx);
     expect(result.isError).toBe(true);
-    expect(result.content).toContain(
-      "The Vellum desktop app is needed to view or control your screen",
-    );
-    expect(result.content).toContain("https://www.vellum.ai/downloads");
+    expect(result.content).toMatch(/No proxy resolver/);
   });
 });
 
@@ -250,11 +241,8 @@ describe("forwardComputerUseProxyTool", () => {
     );
 
     expect(result.isError).toBe(true);
-    expect(result.content).toContain(
-      "The Vellum desktop app is needed to view or control your screen",
-    );
-    expect(result.content).toContain("https://www.vellum.ai/downloads");
-    expect(result.content).not.toContain("computer_use_click");
+    expect(result.content).toContain("no proxy resolver available");
+    expect(result.content).toContain("computer_use_click");
   });
 
   test("delegates to proxy resolver when available", async () => {

package/src/__tests__/config-schema-cmd.test.ts

@@ -130,7 +130,7 @@ describe("getSchemaAtPath", () => {
     expect(properties).toBeDefined();
     expect(properties.enabled).toBeDefined();
     expect(properties.voice).toBeDefined();
-    expect(properties.disclosure).toBeDefined();
+    expect(properties.safety).toBeDefined();
   });
 
   test("navigates through .transform() wrappers (ingress → object schema)", () => {
@@ -230,7 +230,7 @@ describe("z.toJSONSchema integration", () => {
     expect(properties).toBeDefined();
     expect(properties!.enabled).toBeDefined();
     expect(properties!.voice).toBeDefined();
-    expect(properties!.disclosure).toBeDefined();
+    expect(properties!.safety).toBeDefined();
   });
 
   test("sub-schema at a leaf like llm.profileSession.defaultTtlSeconds produces integer schema", () => {

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

@@ -952,7 +952,11 @@ describe("AssistantConfigSchema", () => {
         enabled: true,
         text: 'At the very beginning of the call, introduce yourself as an assistant calling on behalf of the person you represent. Do not say "AI assistant".',
       },
+      safety: {
+        denyCategories: [],
+      },
       voice: {
+        interruptSensitivity: "low",
         telephonyStreaming: true,
         utteranceEndMs: 1000,
       },
@@ -974,6 +978,7 @@ describe("AssistantConfigSchema", () => {
         maxDurationSeconds: 1800,
         userConsultTimeoutSeconds: 60,
         disclosure: { enabled: false, text: "Custom disclosure" },
+        safety: { denyCategories: ["spam"] },
       },
     });
     expect(result.calls.enabled).toBe(false);
@@ -981,6 +986,7 @@ describe("AssistantConfigSchema", () => {
     expect(result.calls.userConsultTimeoutSeconds).toBe(60);
     expect(result.calls.disclosure.enabled).toBe(false);
     expect(result.calls.disclosure.text).toBe("Custom disclosure");
+    expect(result.calls.safety.denyCategories).toEqual(["spam"]);
   });
 
   // ── Live voice config ───────────────────────────────────────────────
@@ -988,6 +994,7 @@ describe("AssistantConfigSchema", () => {
   test("applies liveVoice defaults", () => {
     const result = AssistantConfigSchema.parse({});
     expect(result.liveVoice).toEqual({
+      mode: "open-mic",
       vad: {
         speechEnergyThreshold: 800,
         noiseFloorMargin: 3,
@@ -998,18 +1005,6 @@ describe("AssistantConfigSchema", () => {
         echoEmaHalfLifeMs: 400,
         echoDrainSlackMs: 300,
       },
-      flux: {
-        turnEnd: { enabled: true },
-        eotThreshold: 0.7,
-        eotTimeoutMs: 5000,
-      },
-      archiveAudio: false,
-    });
-  });
-
-  test("applies voice defaults", () => {
-    const result = AssistantConfigSchema.parse({});
-    expect(result.voice).toEqual({
       frontModel: {
         endpointDecisionTimeoutMs: 1200,
         endpointExtensionMs: 1500,
@@ -1024,24 +1019,35 @@ describe("AssistantConfigSchema", () => {
           generationTimeoutMs: 1500,
         },
       },
+      flux: {
+        turnEnd: { enabled: true },
+        eotThreshold: 0.7,
+        eotTimeoutMs: 5000,
+      },
+      maxSessionDurationSeconds: 1800,
+      archiveAudio: false,
     });
   });
 
   test("accepts valid liveVoice config overrides", () => {
     const result = AssistantConfigSchema.parse({
       liveVoice: {
+        mode: "ptt",
         vad: {
           speechEnergyThreshold: 1500,
           silenceThresholdMs: 1000,
           bargeInMinSpeechMs: 120,
         },
+        maxSessionDurationSeconds: 900,
       },
     });
+    expect(result.liveVoice.mode).toBe("ptt");
     expect(result.liveVoice.vad.speechEnergyThreshold).toBe(1500);
     expect(result.liveVoice.vad.silenceThresholdMs).toBe(1000);
     expect(result.liveVoice.vad.bargeInMinSpeechMs).toBe(120);
     // Unspecified vad fields still get defaults
     expect(result.liveVoice.vad.maxTurnDurationMs).toBe(30000);
+    expect(result.liveVoice.maxSessionDurationSeconds).toBe(900);
     // A partial liveVoice override leaves Flux turn-end disabled by default.
     expect(result.liveVoice.flux.turnEnd.enabled).toBe(true);
   });
@@ -1130,10 +1136,18 @@ describe("AssistantConfigSchema", () => {
     expect(result.success).toBe(false);
   });
 
+  test("rejects non-array calls.safety.denyCategories", () => {
+    const result = AssistantConfigSchema.safeParse({
+      calls: { safety: { denyCategories: "spam" } },
+    });
+    expect(result.success).toBe(false);
+  });
+
   // ── Calls voice config ──────────────────────────────────────────────
 
   test("config without calls.voice parses correctly and produces defaults", () => {
     const result = AssistantConfigSchema.parse({});
+    expect(result.calls.voice.interruptSensitivity).toBe("low");
     expect(result.calls.voice.telephonyStreaming).toBe(true);
     expect(result.calls.voice.utteranceEndMs).toBe(1000);
   });
@@ -1151,23 +1165,9 @@ describe("AssistantConfigSchema", () => {
     expect(result.calls.voice.utteranceEndMs).toBe(2500);
   });
 
-  test("persisted calls configs carrying retired keys keep parsing", () => {
-    // Zod strips unrecognized keys, so a persisted config that still carries
-    // `calls.safety.denyCategories` or `calls.voice.interruptSensitivity`
-    // parses.
-    const result = AssistantConfigSchema.parse({
-      calls: {
-        safety: { denyCategories: ["spam"] },
-        voice: { interruptSensitivity: "high" },
-      },
-    });
-    expect(result.calls).not.toHaveProperty("safety");
-    expect(result.calls.voice).not.toHaveProperty("interruptSensitivity");
-  });
-
   test("language is no longer part of the voice config schema", () => {
-    // Zod strips the unrecognized key, so persisted configs that still carry
-    // it parse.
+    // The retired knob was read by nothing; Zod strips the unrecognized key
+    // so persisted configs that still carry it keep parsing.
     const result = AssistantConfigSchema.parse({
       calls: { voice: { language: "es-ES" } },
     });
@@ -2633,6 +2633,7 @@ describe("loadConfig with schema validation", () => {
     expect(config.calls.maxDurationSeconds).toBe(3600);
     expect(config.calls.userConsultTimeoutSeconds).toBe(120);
     expect(config.calls.disclosure.enabled).toBe(true);
+    expect(config.calls.safety.denyCategories).toEqual([]);
     expect(
       (config.calls.voice as Record<string, unknown>).language,
     ).toBeUndefined();

package/src/__tests__/config-watcher-skill-reseed.test.ts

@@ -0,0 +1,359 @@
+import { mkdirSync, mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+  afterAll,
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  mock,
+  test,
+} from "bun:test";
+
+const WORKSPACE_DIR = mkdtempSync(join(tmpdir(), "vellum-skills-watch-"));
+const SKILLS_DIR = join(WORKSPACE_DIR, "skills");
+process.env.VELLUM_WORKSPACE_DIR = WORKSPACE_DIR;
+
+type WatchCallback = (eventType: string, filename: string | null) => void;
+
+interface CapturedWatcher {
+  dir: string;
+  callback: WatchCallback;
+  closed: boolean;
+}
+
+const capturedWatchers: CapturedWatcher[] = [];
+let recursiveWatchAvailable = false;
+
+// The skills watcher reacts by calling these directly; count the calls so tests
+// can assert dispatch without driving real eviction or skill-memory reseeding.
+let evictCalls = 0;
+let skillsChangedCalls = 0;
+
+mock.module("node:fs", () => {
+  // eslint-disable-next-line @typescript-eslint/no-require-imports
+  const actual = require("node:fs");
+  return {
+    ...actual,
+    watch: (dir: string, ...args: unknown[]) => {
+      let callback: WatchCallback;
+
+      if (typeof args[0] === "function") {
+        callback = args[0] as WatchCallback;
+      } else {
+        if (
+          (args[0] as { recursive?: boolean } | undefined)?.recursive &&
+          !recursiveWatchAvailable
+        ) {
+          throw new Error("recursive watch unavailable");
+        }
+        callback = args[1] as WatchCallback;
+      }
+
+      const capturedWatcher: CapturedWatcher = {
+        dir,
+        callback,
+        closed: false,
+      };
+      capturedWatchers.push(capturedWatcher);
+      return {
+        close: () => {
+          capturedWatcher.closed = true;
+        },
+        on: () => {},
+      };
+    },
+  };
+});
+
+mock.module("../persistence/embeddings/embedding-backend.js", () => ({
+  clearEmbeddingBackendCache: () => {},
+}));
+
+mock.module("../persistence/cleanup-schedule-state.js", () => ({
+  resetCleanupScheduleThrottle: () => {},
+}));
+
+mock.module("../providers/registry.js", () => ({
+  initializeProviders: async () => {},
+}));
+
+mock.module("../daemon/mcp-reload-service.js", () => ({
+  reloadMcpServers: async () => {},
+}));
+
+mock.module("../signals/bash.js", () => ({
+  handleBashSignal: () => {},
+}));
+
+mock.module("../signals/cancel.js", () => ({
+  handleCancelSignal: () => {},
+}));
+
+mock.module("../signals/conversation-undo.js", () => ({
+  handleConversationUndoSignal: () => {},
+}));
+
+mock.module("../signals/emit-event.js", () => ({
+  handleEmitEventSignal: () => {},
+}));
+
+mock.module("../signals/user-message.js", () => ({
+  handleUserMessageSignal: () => {},
+}));
+
+mock.module("../daemon/conversation-store.js", () => ({
+  evictConversationsForReload: () => {
+    evictCalls++;
+  },
+}));
+
+mock.module("../daemon/skill-memory-refresh.js", () => ({
+  refreshSkillCapabilityMemories: () => {
+    skillsChangedCalls++;
+  },
+}));
+
+mock.module("../runtime/sync/resource-sync-events.js", () => ({
+  publishIdentityChanged: () => {},
+  publishConfigChanged: () => {},
+  publishSoundsConfigUpdated: () => {},
+  publishAvatarChanged: () => {},
+  publishWorkspaceThemeChanged: () => {},
+}));
+
+mock.module("../platform/sync-identity.js", () => ({
+  syncIdentityNameToPlatform: () => {},
+}));
+
+const { ConfigWatcher } = await import("../daemon/config-watcher.js");
+
+function findWatcher(dir: string): CapturedWatcher | undefined {
+  return capturedWatchers.find((w) => w.dir === dir && !w.closed);
+}
+
+function findCapturedWatcher(dir: string): CapturedWatcher | undefined {
+  return capturedWatchers.find((w) => w.dir === dir);
+}
+
+function capturedWatcherCount(dir: string): number {
+  return capturedWatchers.filter((w) => w.dir === dir).length;
+}
+
+describe("ConfigWatcher skills watcher reseeding", () => {
+  let watcher: InstanceType<typeof ConfigWatcher>;
+
+  beforeEach(() => {
+    capturedWatchers.length = 0;
+    recursiveWatchAvailable = false;
+    rmSync(SKILLS_DIR, { recursive: true, force: true });
+    mkdirSync(SKILLS_DIR, { recursive: true });
+    evictCalls = 0;
+    skillsChangedCalls = 0;
+    watcher = new ConfigWatcher();
+  });
+
+  afterEach(() => {
+    watcher.stop();
+  });
+
+  afterAll(() => {
+    rmSync(WORKSPACE_DIR, { recursive: true, force: true });
+  });
+
+  describe("recursive watcher", () => {
+    beforeEach(() => {
+      recursiveWatchAvailable = true;
+    });
+
+    test("reloads on SKILL.md changes", async () => {
+      watcher.start();
+
+      const skillsWatcher = findWatcher(SKILLS_DIR);
+      expect(skillsWatcher).toBeDefined();
+      skillsWatcher!.callback("change", "example-skill/SKILL.md");
+
+      await new Promise((resolve) => setTimeout(resolve, 300));
+
+      expect(evictCalls).toBe(1);
+      expect(skillsChangedCalls).toBe(1);
+    });
+
+    test("reloads on TOOLS.json changes", async () => {
+      watcher.start();
+
+      const skillsWatcher = findWatcher(SKILLS_DIR);
+      skillsWatcher!.callback("change", "example-skill/TOOLS.json");
+
+      await new Promise((resolve) => setTimeout(resolve, 300));
+
+      expect(evictCalls).toBe(1);
+      expect(skillsChangedCalls).toBe(1);
+    });
+
+    test("ignores non-catalog files (scripts, references, build output)", async () => {
+      watcher.start();
+
+      const skillsWatcher = findWatcher(SKILLS_DIR);
+      skillsWatcher!.callback("change", "example-skill/references/foo.md");
+      skillsWatcher!.callback("change", "example-skill/dist/index.js");
+      skillsWatcher!.callback("change", "example-skill/package.json");
+      skillsWatcher!.callback("change", "example-skill/scripts/run.py");
+
+      await new Promise((resolve) => setTimeout(resolve, 300));
+
+      expect(evictCalls).toBe(0);
+      expect(skillsChangedCalls).toBe(0);
+    });
+
+    test("ignores catalog files under skipped dependency and staging paths", async () => {
+      watcher.start();
+
+      const skillsWatcher = findWatcher(SKILLS_DIR);
+      skillsWatcher!.callback(
+        "change",
+        "example-skill/node_modules/pkg/SKILL.md",
+      );
+      skillsWatcher!.callback(
+        "change",
+        ".install-staging/example-skill/SKILL.md",
+      );
+
+      await new Promise((resolve) => setTimeout(resolve, 300));
+
+      expect(evictCalls).toBe(0);
+      expect(skillsChangedCalls).toBe(0);
+    });
+
+    test("coalesces multiple catalog changes into one reload", async () => {
+      watcher.start();
+
+      const skillsWatcher = findWatcher(SKILLS_DIR);
+      skillsWatcher!.callback("change", "example-skill/SKILL.md");
+      skillsWatcher!.callback("change", "example-skill/package.json");
+      skillsWatcher!.callback("change", "example-skill/TOOLS.json");
+      skillsWatcher!.callback("change", "other-skill/SKILL.md");
+
+      await new Promise((resolve) => setTimeout(resolve, 300));
+
+      expect(evictCalls).toBe(1);
+      expect(skillsChangedCalls).toBe(1);
+    });
+  });
+
+  describe("per-skill-directory fallback", () => {
+    test("watches the root and each immediate skill directory, not nested subdirectories", () => {
+      const skillDir = join(SKILLS_DIR, "example-skill");
+      mkdirSync(join(skillDir, "references"), { recursive: true });
+      mkdirSync(join(skillDir, "dist"), { recursive: true });
+
+      watcher.start();
+
+      expect(findWatcher(SKILLS_DIR)).toBeDefined();
+      expect(findWatcher(skillDir)).toBeDefined();
+      expect(findWatcher(join(skillDir, "references"))).toBeUndefined();
+      expect(findWatcher(join(skillDir, "dist"))).toBeUndefined();
+    });
+
+    test("does not watch dependency or staging directories", () => {
+      const skillDir = join(SKILLS_DIR, "example-skill");
+      mkdirSync(join(skillDir, "node_modules", "pkg"), { recursive: true });
+      mkdirSync(join(SKILLS_DIR, ".install-staging", "staged"), {
+        recursive: true,
+      });
+
+      watcher.start();
+
+      expect(findWatcher(join(skillDir, "node_modules"))).toBeUndefined();
+      expect(findWatcher(join(SKILLS_DIR, ".install-staging"))).toBeUndefined();
+      expect(findWatcher(skillDir)).toBeDefined();
+    });
+
+    test("reloads on SKILL.md / TOOLS.json edits within a skill directory", async () => {
+      const skillDir = join(SKILLS_DIR, "example-skill");
+      mkdirSync(skillDir, { recursive: true });
+
+      watcher.start();
+      const skillWatcher = findWatcher(skillDir);
+      expect(skillWatcher).toBeDefined();
+
+      skillWatcher!.callback("change", "SKILL.md");
+      await new Promise((resolve) => setTimeout(resolve, 300));
+      expect(evictCalls).toBe(1);
+      expect(skillsChangedCalls).toBe(1);
+
+      skillWatcher!.callback("change", "TOOLS.json");
+      await new Promise((resolve) => setTimeout(resolve, 300));
+      expect(evictCalls).toBe(2);
+      expect(skillsChangedCalls).toBe(2);
+    });
+
+    test("ignores non-catalog file edits within a skill directory", async () => {
+      const skillDir = join(SKILLS_DIR, "example-skill");
+      mkdirSync(skillDir, { recursive: true });
+
+      watcher.start();
+      const skillWatcher = findWatcher(skillDir);
+
+      skillWatcher!.callback("change", "README.md");
+      skillWatcher!.callback("change", "package.json");
+      await new Promise((resolve) => setTimeout(resolve, 300));
+
+      expect(evictCalls).toBe(0);
+      expect(skillsChangedCalls).toBe(0);
+    });
+
+    test("watches and reloads when a skill is installed", async () => {
+      watcher.start();
+      const rootWatcher = findWatcher(SKILLS_DIR);
+      expect(rootWatcher).toBeDefined();
+
+      const newSkillDir = join(SKILLS_DIR, "new-skill");
+      mkdirSync(newSkillDir, { recursive: true });
+      rootWatcher!.callback("rename", "new-skill");
+
+      await new Promise((resolve) => setTimeout(resolve, 300));
+
+      expect(findWatcher(newSkillDir)).toBeDefined();
+      expect(evictCalls).toBe(1);
+      expect(skillsChangedCalls).toBe(1);
+    });
+
+    test("closes the watcher and reloads when a skill is removed", async () => {
+      const skillDir = join(SKILLS_DIR, "example-skill");
+      mkdirSync(skillDir, { recursive: true });
+
+      watcher.start();
+      expect(findWatcher(skillDir)).toBeDefined();
+
+      rmSync(skillDir, { recursive: true, force: true });
+      const rootWatcher = findWatcher(SKILLS_DIR);
+      rootWatcher!.callback("rename", "example-skill");
+
+      await new Promise((resolve) => setTimeout(resolve, 300));
+
+      expect(findWatcher(skillDir)).toBeUndefined();
+      expect(findCapturedWatcher(skillDir)?.closed).toBe(true);
+      expect(evictCalls).toBe(1);
+      expect(skillsChangedCalls).toBe(1);
+    });
+
+    test("does not duplicate a watcher or reload when the root changes but the skill set does not", async () => {
+      const skillDir = join(SKILLS_DIR, "example-skill");
+      mkdirSync(skillDir, { recursive: true });
+
+      watcher.start();
+      expect(capturedWatcherCount(skillDir)).toBe(1);
+
+      // A stray file event at the root: no skill directory added or removed.
+      const rootWatcher = findWatcher(SKILLS_DIR);
+      rootWatcher!.callback("change", "README.md");
+      await new Promise((resolve) => setTimeout(resolve, 300));
+
+      expect(capturedWatcherCount(skillDir)).toBe(1);
+      expect(evictCalls).toBe(0);
+      expect(skillsChangedCalls).toBe(0);
+    });
+  });
+});

package/src/__tests__/config-watcher.test.ts

@@ -113,11 +113,8 @@ mock.module("../providers/registry.js", () => ({
   resolveProviderFromConnection: async () => null,
 }));
 
-let mcpReloadCallCount = 0;
 mock.module("../daemon/mcp-reload-service.js", () => ({
-  reloadMcpServers: async () => {
-    mcpReloadCallCount += 1;
-  },
+  reloadMcpServers: async () => {},
 }));
 
 mock.module("../signals/conversation-undo.js", () => ({
@@ -157,6 +154,10 @@ mock.module("../runtime/sync/resource-sync-events.js", () => ({
   },
 }));
 
+mock.module("../daemon/skill-memory-refresh.js", () => ({
+  refreshSkillCapabilityMemories: () => {},
+}));
+
 mock.module("../platform/sync-identity.js", () => ({
   syncIdentityNameToPlatform: () => {},
 }));
@@ -182,7 +183,6 @@ function findFileWatch(filePath: string): CapturedFileWatch | undefined {
 
 const WORKSPACE_FILES = new Set([
   "config.json",
-  "mcp.json",
   "SOUL.md",
   "IDENTITY.md",
   "ui/theme.json",
@@ -239,7 +239,6 @@ beforeEach(() => {
   evictCallCount = 0;
   identityCallCount = 0;
   themeCallCount = 0;
-  mcpReloadCallCount = 0;
   watcher = new ConfigWatcher(undefined, TEST_DEBOUNCE_MS);
 });
 
@@ -271,9 +270,9 @@ describe("ConfigWatcher workspace file handlers", () => {
 
   test("unregistered workspace files are not subscribed (only the registered handler set is)", () => {
     watcher.start();
-    // Per-file watching only registers config.json, mcp.json, SOUL.md,
-    // IDENTITY.md, and ui/theme.json. The whole workspace dir must not
-    // be watched either: that was the ENXIO-on-Unix-sockets bug.
+    // Per-file watching only registers config.json, SOUL.md, IDENTITY.md,
+    // and ui/theme.json. The whole workspace dir must not be watched
+    // either — that was the ENXIO-on-Unix-sockets bug.
     expect(findFileWatch(join(WORKSPACE_DIR, "OTHER.md"))).toBeUndefined();
     expect(findWatcher(WORKSPACE_DIR)).toBeUndefined();
   });
@@ -286,14 +285,6 @@ describe("ConfigWatcher workspace file handlers", () => {
     expect(evictCallCount).toBe(0);
   });
 
-  test("mcp.json change reloads MCP servers without evicting conversations", async () => {
-    watcher.start();
-    simulateFileChange(WORKSPACE_DIR, "mcp.json");
-    await new Promise((r) => setTimeout(r, WAIT_MS));
-    expect(mcpReloadCallCount).toBe(1);
-    expect(evictCallCount).toBe(0);
-  });
-
   test("config.json change calls refreshConfigFromSources", async () => {
     let refreshCalled = false;
     watcher.refreshConfigFromSources = async () => {
@@ -341,12 +332,6 @@ describe("ConfigWatcher watcher lifecycle", () => {
     expect(findFileWatch(join(WORKSPACE_DIR, "IDENTITY.md"))).toBeDefined();
   });
 
-  test("start does not watch the skills directory", () => {
-    mkdirSync(join(WORKSPACE_DIR, "skills"), { recursive: true });
-    watcher.start();
-    expect(findWatcher(join(WORKSPACE_DIR, "skills"))).toBeUndefined();
-  });
-
   test("stop cancels pending debounce work, no eviction fires after", async () => {
     watcher.start();
     simulateFileChange(WORKSPACE_DIR, "SOUL.md");

package/src/__tests__/connection-model-compat.test.ts

@@ -19,7 +19,7 @@ describe("isConnectionCompatibleWithModel", () => {
     expect(
       isConnectionCompatibleWithModel(
         { auth: { type: "oauth_subscription" } as never },
-        "gpt-5.5",
+        "gpt-5.4",
       ),
     ).toBe(true);
   });
@@ -79,7 +79,7 @@ describe("describeSubscriptionModelIncompatibility", () => {
 
   test("returns null when model is Codex-compatible", () => {
     expect(
-      describeSubscriptionModelIncompatibility([subscriptionConn], "gpt-5.5"),
+      describeSubscriptionModelIncompatibility([subscriptionConn], "gpt-5.4"),
     ).toBeNull();
   });
 });

package/src/__tests__/conversation-key-store-disk-view.test.ts

@@ -59,7 +59,7 @@ describe("conversation-key-store disk view", () => {
 
     const meta = JSON.parse(readFileSync(metaPath, "utf-8"));
     expect(meta.id).toBe(first.conversationId);
-    expect(meta.title).toBe("conversation.title.generating");
+    expect(meta.title).toBe("Generating title...");
     expect(meta.type).toBe("standard");
     expect(meta.channel).toBeNull();
     expect(readdirSync(conversationsDir)).toEqual([expectedDirName]);