@vellumai/assistant 0.12.1 → 0.12.2-staging.2

package/src/daemon/__tests__/conversation-tool-setup.test.ts

@@ -1,30 +1,7 @@
 /**
- * Tests for `isToolActiveForContext` host-tool capability gating.
- *
- * Scenarios verified:
- * - chrome-extension is its own executor and is exempt from the hasNoClient
- *   gate (the extension's own popup UI gates commands; there is no SSE
- *   interactive approval channel, and chrome-extension turns intentionally
- *   run with `hasNoClient: true` because chrome-extension is not in
- *   `INTERACTIVE_INTERFACES`).
- * - macos requires a connected SSE client for host tools that flow through
- *   the proxy (e.g. host_bash, host_file_*, host_browser), so
- *   `hasNoClient: true` denies those on macos.
- * - host_browser IS in the macos capability set — the proxy routes
- *   host_browser_request frames to the desktop client via SSE (or via the
- *   Chrome extension registry when an extension connection is present).
- *
- * The per-capability check (`supportsHostProxy(transport, capability)`) runs
- * first and is authoritative for structural support, so host_bash and
- * host_file_* are filtered out for chrome-extension regardless of the
- * hasNoClient flag.
- *
- * Cross-client exception: tools whose capabilities are in
- * CROSS_CLIENT_EXPOSED_CAPABILITIES (host_bash, host_file, host_browser)
- * are allowed for non-host-proxy interactive interfaces ("web", "ios")
- * when at least one capable client is connected via the event hub.
- * chrome-extension is excluded as a security boundary, regardless of
- * whether the capability is technically supported elsewhere.
+ * Tests for host-tool schema visibility. Host tool definitions stay stable
+ * across interactive and background turns. Chrome extension remains limited
+ * to host_browser because it is the only host capability it implements.
  */
 
 import { beforeEach, describe, expect, mock, test } from "bun:test";
@@ -260,7 +237,7 @@ describe("isToolActiveForContext - Slack task_progress UI exception", () => {
     expect(isToolActiveForContext("ui_update", ctx)).toBe(true);
   });
 
-  test("ui_dismiss remains hidden for Slack without dynamic UI support", () => {
+  test("ui_dismiss stays active for Slack without dynamic UI support", () => {
     expect(
       isToolActiveForContext(
         "ui_dismiss",
@@ -272,42 +249,45 @@ describe("isToolActiveForContext - Slack task_progress UI exception", () => {
           },
         }),
       ),
-    ).toBe(false);
+    ).toBe(true);
   });
 
-  test("Slack task_progress UI tools still require a connected client path", () => {
-    expect(
-      isToolActiveForContext(
-        "ui_show",
-        makeCtx({
-          hasNoClient: true,
-          channelCapabilities: {
-            channel: "slack",
-            supportsDynamicUi: false,
-          },
-        }),
-      ),
-    ).toBe(false);
+  test("Slack UI tools stay active for a clientless turn", () => {
+    for (const name of ["ui_show", "ui_update", "ui_dismiss"]) {
+      expect(
+        isToolActiveForContext(
+          name,
+          makeCtx({
+            hasNoClient: true,
+            channelCapabilities: {
+              channel: "slack",
+              supportsDynamicUi: false,
+            },
+          }),
+        ),
+      ).toBe(true);
+    }
   });
 
-  test("other non-dynamic channels still hide UI surface tools", () => {
-    expect(
-      isToolActiveForContext(
-        "ui_show",
-        makeCtx({
-          hasNoClient: false,
-          channelCapabilities: {
-            channel: "telegram",
-            supportsDynamicUi: false,
-          },
-        }),
-      ),
-    ).toBe(false);
+  test("other non-dynamic channels keep UI surface tools on the wire", () => {
+    for (const name of ["ui_show", "ui_update", "ui_dismiss"]) {
+      expect(
+        isToolActiveForContext(
+          name,
+          makeCtx({
+            hasNoClient: false,
+            channelCapabilities: {
+              channel: "telegram",
+              supportsDynamicUi: false,
+            },
+          }),
+        ),
+      ).toBe(true);
+    }
   });
 });
 
 describe("isToolActiveForContext — host tool capability gating", () => {
-  // macOS transport: SSE-based interactive approval required.
   test("host_bash is active for macOS with a connected client", () => {
     expect(
       isToolActiveForContext(
@@ -317,27 +297,22 @@ describe("isToolActiveForContext — host tool capability gating", () => {
     ).toBe(true);
   });
 
-  test("host_bash is NOT active for macOS when hasNoClient is true (security invariant)", () => {
-    // macOS uses an SSE-based interactive approval channel. Without a
-    // connected client the guardian auto-approve path could execute host
-    // commands unattended, so host tools must be denied.
+  test("host_bash remains active for a background macOS turn", () => {
     expect(
       isToolActiveForContext(
         "host_bash",
         makeCtx({ hasNoClient: true, transportInterface: "macos" }),
       ),
-    ).toBe(false);
+    ).toBe(true);
   });
-
-  test("host_file_read is NOT active for macOS when hasNoClient is true", () => {
+  test("host_file_read remains active for a background macOS turn", () => {
     expect(
       isToolActiveForContext(
         "host_file_read",
         makeCtx({ hasNoClient: true, transportInterface: "macos" }),
       ),
-    ).toBe(false);
+    ).toBe(true);
   });
-
   test("host_browser is active for macOS with a connected client", () => {
     // macOS supports host_browser — the proxy routes host_browser_request
     // frames to the desktop client via SSE (or via the Chrome extension
@@ -350,19 +325,14 @@ describe("isToolActiveForContext — host tool capability gating", () => {
     ).toBe(true);
   });
 
-  test("host_browser is NOT active for macOS when hasNoClient is true", () => {
-    // macOS supports host_browser structurally, but without a connected
-    // client the host_browser_request frames have no consumer, so the tool
-    // is denied.
+  test("host_browser remains active for a background macOS turn", () => {
     expect(
       isToolActiveForContext(
         "host_browser",
         makeCtx({ hasNoClient: true, transportInterface: "macos" }),
       ),
-    ).toBe(false);
+    ).toBe(true);
   });
-
-  // chrome-extension transport: the extension is its own executor.
   test("host_browser is active for chrome-extension even when hasNoClient is true", () => {
     // chrome-extension turns run with `hasNoClient: true` by design because
     // chrome-extension is not in `INTERACTIVE_INTERFACES` — it is not an
@@ -418,10 +388,7 @@ describe("isToolActiveForContext — host tool capability gating", () => {
     ).toBe(false);
   });
 
-  // Backwards-compat fallback: no transport plumbed through.
-  test("host_bash falls back to hasNoClient gate when transport is undefined (client connected)", () => {
-    // Without a transport interface we cannot run the per-capability check,
-    // so we fall back to the coarse-grained `hasNoClient` behavior.
+  test("host_bash remains active without transport metadata for a connected turn", () => {
     expect(
       isToolActiveForContext(
         "host_bash",
@@ -430,20 +397,18 @@ describe("isToolActiveForContext — host tool capability gating", () => {
     ).toBe(true);
   });
 
-  test("host_bash falls back to hasNoClient gate when transport is undefined (no client)", () => {
+  test("host_bash remains active without transport metadata for a background turn", () => {
     expect(
       isToolActiveForContext(
         "host_bash",
         makeCtx({ hasNoClient: true, transportInterface: undefined }),
       ),
-    ).toBe(false);
+    ).toBe(true);
   });
 });
 
 describe("isToolActiveForContext — cross-client exception (Phase 1: host_bash)", () => {
   test("host_bash is active for web transport when a host_bash-capable client is connected", () => {
-    // Cross-client path: a web turn should see host_bash when a macOS client
-    // with host_bash capability is connected via the event hub.
     mockClientCountByCapability.set("host_bash", 1);
     expect(
       isToolActiveForContext(
@@ -453,30 +418,24 @@ describe("isToolActiveForContext — cross-client exception (Phase 1: host_bash)
     ).toBe(true);
   });
 
-  test("host_bash is NOT active for web transport when no capable client is connected", () => {
-    // No cross-client fallback: hub has no host_bash-capable subscribers.
+  test("host_bash remains active for web when no capable client is connected", () => {
     mockClientCountByCapability.set("host_bash", 0);
     expect(
       isToolActiveForContext(
         "host_bash",
         makeCtx({ hasNoClient: false, transportInterface: "web" }),
       ),
-    ).toBe(false);
+    ).toBe(true);
   });
-
-  test("host_file_read is NOT active for web transport when only a host_bash client is connected", () => {
-    // The cross-client exception is per-capability: a host_bash-capable
-    // client in the hub does not satisfy host_file's exposure check, since
-    // listClientsByCapability is queried with the tool's actual capability.
+  test("host_file_read remains active for web without host_file clients", () => {
     mockClientCountByCapability.set("host_bash", 1);
     expect(
       isToolActiveForContext(
         "host_file_read",
         makeCtx({ hasNoClient: false, transportInterface: "web" }),
       ),
-    ).toBe(false);
+    ).toBe(true);
   });
-
   test("host_bash for macos transport is unaffected by the cross-client exception", () => {
     // macos natively supports host_bash via host proxy — the supportsHostProxy
     // check passes, so the cross-client branch is never reached.
@@ -489,19 +448,15 @@ describe("isToolActiveForContext — cross-client exception (Phase 1: host_bash)
     ).toBe(true);
   });
 
-  test("host_bash for macos with no client is still denied (security invariant unaffected)", () => {
-    // Even with a capable client in the hub, the macos SSE path takes
-    // precedence — it passes the supportsHostProxy check, bypasses the
-    // cross-client branch, and reaches the hasNoClient gate.
+  test("host_bash remains active for a background macOS turn", () => {
     mockClientCountByCapability.set("host_bash", 1);
     expect(
       isToolActiveForContext(
         "host_bash",
         makeCtx({ hasNoClient: true, transportInterface: "macos" }),
       ),
-    ).toBe(false);
+    ).toBe(true);
   });
-
   test("host_bash is NOT active for chrome-extension even when a capable client is connected", () => {
     // Security boundary: chrome-extension only gets host_browser. The
     // cross-client exception explicitly excludes chrome-extension transport
@@ -515,16 +470,14 @@ describe("isToolActiveForContext — cross-client exception (Phase 1: host_bash)
     ).toBe(false);
   });
 
-  test("host_bash is NOT active for web transport when hasNoClient is true (no approval UI)", () => {
-    // hasNoClient gate: no interactive approval UI available for this turn.
-    // Cross-client exception must not bypass this gate.
+  test("host_bash remains active for a background web turn", () => {
     mockClientCountByCapability.set("host_bash", 1);
     expect(
       isToolActiveForContext(
         "host_bash",
         makeCtx({ hasNoClient: true, transportInterface: "web" }),
       ),
-    ).toBe(false);
+    ).toBe(true);
   });
 });
 
@@ -547,14 +500,14 @@ describe("isToolActiveForContext — cross-client exposure for host_file_*", ()
       ).toBe(true);
     });
 
-    test(`${tool} is NOT exposed for web when no host_file client is connected`, () => {
+    test(`${tool} remains active for web when no host_file client is connected`, () => {
       mockClientCountByCapability.set("host_file", 0);
       expect(
         isToolActiveForContext(
           tool,
           makeCtx({ hasNoClient: false, transportInterface: "web" }),
         ),
-      ).toBe(false);
+      ).toBe(true);
     });
 
     test(`${tool} is NOT exposed for chrome-extension (security boundary)`, () => {
@@ -570,20 +523,19 @@ describe("isToolActiveForContext — cross-client exposure for host_file_*", ()
       ).toBe(false);
     });
 
-    test(`${tool} is NOT exposed when hasNoClient is true (no approval UI)`, () => {
+    test(`${tool} remains active for a background web turn`, () => {
       mockClientCountByCapability.set("host_file", 1);
       expect(
         isToolActiveForContext(
           tool,
           makeCtx({ hasNoClient: true, transportInterface: "web" }),
         ),
-      ).toBe(false);
+      ).toBe(true);
     });
   }
 
-  test("listClientsByCapability is queried with the actual capability, not host_bash (regression guard for D5 latent bug)", () => {
-    mockClientCountByCapability.set("host_bash", 0);
-    mockClientCountByCapability.set("host_file", 1);
+  test("host_file_transfer does not depend on the live host_file roster", () => {
+    mockClientCountByCapability.set("host_file", 0);
     expect(
       isToolActiveForContext(
         "host_file_transfer",
@@ -622,37 +574,33 @@ describe("isToolActiveForContext — cross-client exposure for host_browser", ()
     ).toBe(true);
   });
 
-  test("host_browser is NOT exposed for web when no host_browser client is connected", () => {
+  test("host_browser remains active for web when no host_browser client is connected", () => {
     mockClientCountByCapability.set("host_browser", 0);
     expect(
       isToolActiveForContext(
         "host_browser",
         makeCtx({ hasNoClient: false, transportInterface: "web" }),
       ),
-    ).toBe(false);
+    ).toBe(true);
   });
-
-  test("host_browser is NOT exposed for ios when no host_browser client is connected", () => {
+  test("host_browser remains active for ios when no host_browser client is connected", () => {
     mockClientCountByCapability.set("host_browser", 0);
     expect(
       isToolActiveForContext(
         "host_browser",
         makeCtx({ hasNoClient: false, transportInterface: "ios" }),
       ),
-    ).toBe(false);
+    ).toBe(true);
   });
-
-  test("host_browser is NOT exposed when hasNoClient is true (no approval UI)", () => {
-    // hasNoClient gate: cross-client exception must not bypass this.
+  test("host_browser remains active for a background web turn", () => {
     mockClientCountByCapability.set("host_browser", 1);
     expect(
       isToolActiveForContext(
         "host_browser",
         makeCtx({ hasNoClient: true, transportInterface: "web" }),
       ),
-    ).toBe(false);
+    ).toBe(true);
   });
-
   test("host_browser for macos transport is unaffected by the cross-client exception", () => {
     // macos natively supports host_browser via host proxy — the
     // supportsHostProxy check passes, so the cross-client branch is never
@@ -681,10 +629,7 @@ describe("isToolActiveForContext — cross-client exposure for host_browser", ()
     ).toBe(true);
   });
 
-  test("listClientsByCapability is queried with host_browser, not host_bash or host_file (per-capability invariant)", () => {
-    // Defense against any future regression that hardcodes a different
-    // capability in the cross-client check. Only host_browser-capable
-    // clients should satisfy host_browser exposure.
+  test("host_browser does not depend on the live host_browser roster", () => {
     mockClientCountByCapability.set("host_bash", 1);
     mockClientCountByCapability.set("host_file", 1);
     mockClientCountByCapability.set("host_browser", 0);
@@ -693,7 +638,7 @@ describe("isToolActiveForContext — cross-client exposure for host_browser", ()
         "host_browser",
         makeCtx({ hasNoClient: false, transportInterface: "web" }),
       ),
-    ).toBe(false);
+    ).toBe(true);
   });
 });
 

package/src/daemon/__tests__/plugin-mcp-reconcile.test.ts

@@ -41,10 +41,13 @@ mock.module("../../mcp/mcp-header-store.js", () => ({
 }));
 
 mock.module("../../config/loader.js", () => ({
-  getConfig: () => ({ mcp: { servers: {} } }),
   invalidateConfigCache: () => {},
 }));
 
+mock.module("../../mcp/workspace-mcp-config.js", () => ({
+  loadWorkspaceMcpConfig: () => ({ servers: {} }),
+}));
+
 mock.module("../../tools/registry.js", () => ({
   registerMcpTools: () => [],
   unregisterAllMcpTools: () => {},

package/src/daemon/__tests__/skill-memory-refresh-mtime.test.ts

@@ -0,0 +1,133 @@
+import { mkdirSync, mkdtempSync, rmSync, utimesSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  mock,
+  test,
+} from "bun:test";
+
+const WORKSPACE_DIR = mkdtempSync(join(tmpdir(), "skill-md-mtime-refresh-"));
+process.env.VELLUM_WORKSPACE_DIR = WORKSPACE_DIR;
+
+const seedGraphCalls: number[] = [];
+const seedV2Calls: number[] = [];
+
+mock.module("../../config/loader.js", () => ({
+  getConfig: () => ({}),
+}));
+
+mock.module("../../plugins/defaults/memory/graph/capability-seed.js", () => ({
+  seedSkillGraphNodes: () => {
+    seedGraphCalls.push(Date.now());
+  },
+  seedUninstalledCatalogSkillMemories: async () => {},
+}));
+
+mock.module(
+  "../../plugins/defaults/memory/substrate/boot-maintenance.js",
+  () => ({
+    maybeSeedCapabilitySkills: () => {
+      seedV2Calls.push(Date.now());
+    },
+    maybeSeedCliCommandCards: () => {},
+  }),
+);
+
+const {
+  _resetSkillMdMtimeStateForTests,
+  maybeRefreshSkillCapabilityMemoriesFromMtime,
+  refreshSkillCapabilityMemories,
+  startWorkspaceSkillMdMtimePoll,
+  stopWorkspaceSkillMdMtimePoll,
+} = await import("../skill-memory-refresh.js");
+
+const SKILLS_DIR = join(WORKSPACE_DIR, "skills");
+
+function writeSkill(id: string): string {
+  const dir = join(SKILLS_DIR, id);
+  mkdirSync(dir, { recursive: true });
+  const skillMd = join(dir, "SKILL.md");
+  writeFileSync(
+    skillMd,
+    `---\nname: ${id}\ndescription: ${id}\n---\nbody\n`,
+  );
+  return skillMd;
+}
+
+describe("maybeRefreshSkillCapabilityMemoriesFromMtime", () => {
+  beforeEach(() => {
+    rmSync(SKILLS_DIR, { recursive: true, force: true });
+    mkdirSync(SKILLS_DIR, { recursive: true });
+    seedGraphCalls.length = 0;
+    seedV2Calls.length = 0;
+    _resetSkillMdMtimeStateForTests();
+  });
+
+  afterEach(() => {
+    _resetSkillMdMtimeStateForTests();
+  });
+
+  test("first call reseeds, a second call with unchanged SKILL.md does not", () => {
+    writeSkill("alpha");
+    expect(maybeRefreshSkillCapabilityMemoriesFromMtime()).toBe(true);
+    expect(seedGraphCalls).toHaveLength(1);
+    expect(seedV2Calls).toHaveLength(1);
+
+    expect(maybeRefreshSkillCapabilityMemoriesFromMtime()).toBe(false);
+    expect(seedGraphCalls).toHaveLength(1);
+  });
+
+  test("explicit refresh remembers the signature so the next poll is a no-op", () => {
+    writeSkill("alpha");
+    refreshSkillCapabilityMemories();
+    expect(seedGraphCalls).toHaveLength(1);
+    expect(maybeRefreshSkillCapabilityMemoriesFromMtime()).toBe(false);
+  });
+
+  test("SKILL.md mtime change reseeds", () => {
+    const skillMd = writeSkill("alpha");
+    expect(maybeRefreshSkillCapabilityMemoriesFromMtime()).toBe(true);
+
+    const later = new Date(Date.now() + 5_000);
+    utimesSync(skillMd, later, later);
+    expect(maybeRefreshSkillCapabilityMemoriesFromMtime()).toBe(true);
+    expect(seedGraphCalls).toHaveLength(2);
+  });
+
+  test("TOOLS.json change without a SKILL.md mtime change does not reseed", () => {
+    writeSkill("alpha");
+    expect(maybeRefreshSkillCapabilityMemoriesFromMtime()).toBe(true);
+
+    writeFileSync(
+      join(SKILLS_DIR, "alpha", "TOOLS.json"),
+      JSON.stringify({ version: 1, tools: [] }),
+    );
+    expect(maybeRefreshSkillCapabilityMemoriesFromMtime()).toBe(false);
+    expect(seedGraphCalls).toHaveLength(1);
+  });
+
+  test("adding or removing a skill directory reseeds", () => {
+    writeSkill("alpha");
+    expect(maybeRefreshSkillCapabilityMemoriesFromMtime()).toBe(true);
+
+    writeSkill("bravo");
+    expect(maybeRefreshSkillCapabilityMemoriesFromMtime()).toBe(true);
+
+    rmSync(join(SKILLS_DIR, "bravo"), { recursive: true, force: true });
+    expect(maybeRefreshSkillCapabilityMemoriesFromMtime()).toBe(true);
+    expect(seedGraphCalls).toHaveLength(3);
+  });
+
+  test("startWorkspaceSkillMdMtimePoll runs once immediately and is idempotent", () => {
+    writeSkill("alpha");
+    startWorkspaceSkillMdMtimePoll();
+    expect(seedGraphCalls).toHaveLength(1);
+    startWorkspaceSkillMdMtimePoll();
+    expect(seedGraphCalls).toHaveLength(1);
+    stopWorkspaceSkillMdMtimePoll();
+  });
+});

package/src/daemon/app-change-notify.ts

@@ -0,0 +1,45 @@
+/**
+ * Fan out an app change to open conversation surfaces, connected clients,
+ * and the publish pipeline.
+ *
+ * Compilation is the caller's responsibility. This module only notifies:
+ * it must not call `compileApp()` because that begins with `rm -rf dist/`
+ * and would race a compile already in flight.
+ */
+
+import { broadcastMessage } from "../runtime/assistant-event-hub.js";
+import { publishAppsChanged } from "../runtime/sync/resource-sync-events.js";
+import { updatePublishedAppDeployment } from "../services/published-app-updater.js";
+import type { Conversation } from "./conversation.js";
+import { allConversations } from "./conversation-registry.js";
+import { refreshSurfacesForApp } from "./conversation-surfaces.js";
+
+export function broadcastAppFilesChanged(appId: string): void {
+  broadcastMessage({ type: "app_files_changed", appId });
+  publishAppsChanged();
+}
+
+/**
+ * Refresh every in-memory conversation that has this app open, then broadcast
+ * and re-deploy. Pass `alsoRefresh` when the calling conversation might not
+ * yet be in the registry (tool post-execution hooks).
+ */
+export function notifyAppSurfacesChanged(
+  appId: string,
+  opts?: { fileChange?: boolean; status?: string },
+  alsoRefresh?: Conversation,
+): void {
+  const seen = new Set<string>();
+  if (alsoRefresh) {
+    refreshSurfacesForApp(alsoRefresh, appId, opts);
+    seen.add(alsoRefresh.conversationId);
+  }
+  for (const conversation of allConversations()) {
+    if (seen.has(conversation.conversationId)) {
+      continue;
+    }
+    refreshSurfacesForApp(conversation, appId, opts);
+  }
+  broadcastAppFilesChanged(appId);
+  void updatePublishedAppDeployment(appId);
+}