@vellumai/assistant 0.10.1 → 0.10.2-dev.202606241651.2d2b40d

package/src/cli/lib/__tests__/install-from-github.test.ts

@@ -436,6 +436,108 @@ describe("installPlugin — marketplace resolution", () => {
     expect(meta.contentHash).toMatch(/^v2:[0-9a-f]{64}$/);
   });
 
+  test("installs a plugin rooted at a sub-path, copying only that subtree", async () => {
+    // GIVEN a marketplace entry whose source pins a directory *within* a repo
+    // (a monorepo that ships several plugins) rather than the repo root.
+    const NESTED_SHA = "0f".repeat(20);
+    const NESTED_MANIFEST = {
+      name: "vellum-assistant",
+      plugins: [
+        {
+          name: "nested-plugin",
+          source: {
+            source: "github",
+            repo: "example-org/monorepo",
+            path: "packages/my-plugin",
+            ref: NESTED_SHA,
+          },
+          description: "A plugin that lives in a monorepo sub-directory.",
+        },
+      ],
+    };
+    const fetch = makeContentsFetch({ tree: {}, manifest: NESTED_MANIFEST });
+    // The clone carries files both at the repo root and under the pinned
+    // sub-path; only the sub-path subtree should be materialized.
+    const runGit = fakeGitRunner({
+      tree: {
+        "package.json": '{"name":"monorepo-root"}',
+        "README.md": "# monorepo root",
+        "packages/my-plugin/package.json": '{"name":"nested-plugin"}',
+        "packages/my-plugin/README.md": "# nested plugin",
+        "packages/my-plugin/hooks/init.ts": "export default async () => {};",
+        "packages/other-plugin/package.json": '{"name":"other"}',
+      },
+      commit: NESTED_SHA,
+    });
+
+    // WHEN we install by name
+    const result = await installPlugin(
+      { name: "nested-plugin", ref: "main" },
+      { fetch, runGit, workspacePluginsDir: pluginsDir },
+    );
+
+    // THEN only the sub-path subtree lands, rooted at <pluginsDir>/nested-plugin
+    const target = join(pluginsDir, "nested-plugin");
+    expect(result.target).toBe(target);
+    expect(readFileSync(join(target, "package.json"), "utf-8")).toBe(
+      '{"name":"nested-plugin"}',
+    );
+    expect(existsSync(join(target, "README.md"))).toBe(true);
+    expect(existsSync(join(target, "hooks", "init.ts"))).toBe(true);
+    // AND the repo-root and sibling-package files are NOT copied in — the
+    // install is scoped to the pinned directory.
+    expect(result.fileCount).toBe(3);
+    expect(readFileSync(join(target, "package.json"), "utf-8")).not.toContain(
+      "monorepo-root",
+    );
+    expect(existsSync(join(target, "packages"))).toBe(false);
+
+    // AND provenance records the sub-path so an upgrade/diff re-resolves the
+    // same directory rather than the repo root.
+    const meta = readInstallMeta(target);
+    expect(meta?.source.owner).toBe("example-org");
+    expect(meta?.source.repo).toBe("monorepo");
+    expect(meta?.source.path).toBe("packages/my-plugin");
+    expect(meta?.source.ref).toBe(NESTED_SHA);
+  });
+
+  test("a sub-path that does not exist in the clone surfaces a clean not-found", async () => {
+    // GIVEN an entry pinning a directory the cloned ref doesn't contain
+    const MISSING_SHA = "1a".repeat(20);
+    const MISSING_PATH_MANIFEST = {
+      name: "vellum-assistant",
+      plugins: [
+        {
+          name: "nested-plugin",
+          source: {
+            source: "github",
+            repo: "example-org/monorepo",
+            path: "packages/does-not-exist",
+            ref: MISSING_SHA,
+          },
+        },
+      ],
+    };
+    const fetch = makeContentsFetch({
+      tree: {},
+      manifest: MISSING_PATH_MANIFEST,
+    });
+    const runGit = fakeGitRunner({
+      tree: { "package.json": '{"name":"monorepo-root"}' },
+      commit: MISSING_SHA,
+    });
+
+    // WHEN we install
+    // THEN the absent sub-path yields a hard not-found and nothing is staged
+    await expect(
+      installPlugin(
+        { name: "nested-plugin", ref: "main" },
+        { fetch, runGit, workspacePluginsDir: pluginsDir },
+      ),
+    ).rejects.toBeInstanceOf(PluginNotFoundError);
+    expect(readdirSync(pluginsDir)).toEqual([]);
+  });
+
   test("refuses to install when the checked-out commit differs from the pinned SHA", async () => {
     // GIVEN a clone whose resolved HEAD does not match the manifest's pinned
     // commit SHA — i.e. the upstream object served something unexpected

package/src/cli/lib/__tests__/list-installed-plugins.test.ts

@@ -17,7 +17,7 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 
-import { listInstalledPlugins } from "../list-installed-plugins.js";
+import { listAllPlugins, listInstalledPlugins } from "../list-installed-plugins.js";
 
 let pluginsDir: string;
 
@@ -152,3 +152,162 @@ describe("listInstalledPlugins", () => {
     expect(result.map((p) => p.name)).toEqual(["valid"]);
   });
 });
+
+describe("listAllPlugins", () => {
+  test("includes default plugins with source=default", () => {
+    const result = listAllPlugins({ workspacePluginsDir: pluginsDir });
+    const defaults = result.filter((p) => p.source === "default");
+    // All 15 default plugins should be present.
+    expect(defaults.length).toBe(15);
+    // Names should all start with "default-".
+    expect(defaults.every((p) => p.name.startsWith("default-"))).toBe(true);
+    // None should be disabled by default in a fresh temp dir.
+    expect(defaults.every((p) => !p.disabled)).toBe(true);
+  });
+
+  test("includes user plugins with source=user", () => {
+    mkdirSync(join(pluginsDir, "my-plugin"));
+    writeFileSync(
+      join(pluginsDir, "my-plugin", "package.json"),
+      JSON.stringify({ name: "my-plugin", version: "1.0.0" }),
+    );
+
+    const result = listAllPlugins({ workspacePluginsDir: pluginsDir });
+    const user = result.filter((p) => p.source === "user");
+    expect(user).toHaveLength(1);
+    expect(user[0]!.name).toBe("my-plugin");
+    expect(user[0]!.disabled).toBe(false);
+  });
+
+  test("user plugins appear before default plugins", () => {
+    mkdirSync(join(pluginsDir, "zzz-user"));
+    writeFileSync(
+      join(pluginsDir, "zzz-user", "package.json"),
+      JSON.stringify({ name: "zzz-user", version: "1.0.0" }),
+    );
+
+    const result = listAllPlugins({ workspacePluginsDir: pluginsDir });
+    const firstDefaultIdx = result.findIndex((p) => p.source === "default");
+    const lastUserIdx = result
+      .map((p, i) => (p.source === "user" ? i : -1))
+      .filter((i) => i >= 0)
+      .pop();
+
+    expect(lastUserIdx).toBeDefined();
+    expect(firstDefaultIdx).toBeGreaterThan(lastUserIdx!);
+  });
+
+  test("detects disabled state for user plugins", () => {
+    mkdirSync(join(pluginsDir, "my-plugin"));
+    writeFileSync(
+      join(pluginsDir, "my-plugin", "package.json"),
+      JSON.stringify({ name: "my-plugin", version: "1.0.0" }),
+    );
+    writeFileSync(join(pluginsDir, "my-plugin", ".disabled"), "");
+
+    const result = listAllPlugins({ workspacePluginsDir: pluginsDir });
+    const entry = result.find((p) => p.name === "my-plugin");
+    expect(entry).toBeDefined();
+    expect(entry!.disabled).toBe(true);
+  });
+
+  test("detects disabled state for default plugins via stub directory", () => {
+    mkdirSync(join(pluginsDir, "default-advisor"), { recursive: true });
+    writeFileSync(join(pluginsDir, "default-advisor", ".disabled"), "");
+
+    const result = listAllPlugins({ workspacePluginsDir: pluginsDir });
+    const advisor = result.find((p) => p.name === "default-advisor");
+    expect(advisor).toBeDefined();
+    expect(advisor!.disabled).toBe(true);
+  });
+
+  test("default stub directory is excluded from user listing", () => {
+    mkdirSync(join(pluginsDir, "default-advisor"), { recursive: true });
+    writeFileSync(join(pluginsDir, "default-advisor", ".disabled"), "");
+
+    const result = listAllPlugins({ workspacePluginsDir: pluginsDir });
+    // Should appear exactly once, as a default entry (not a user entry).
+    const advisorEntries = result.filter((p) => p.name === "default-advisor");
+    expect(advisorEntries).toHaveLength(1);
+    expect(advisorEntries[0]!.source).toBe("default");
+  });
+
+  test("sort order: enabled user, disabled user, enabled default, disabled default", () => {
+    // User plugins
+    mkdirSync(join(pluginsDir, "aaa-enabled"));
+    writeFileSync(
+      join(pluginsDir, "aaa-enabled", "package.json"),
+      JSON.stringify({ name: "aaa-enabled", version: "1.0.0" }),
+    );
+    mkdirSync(join(pluginsDir, "bbb-disabled"));
+    writeFileSync(
+      join(pluginsDir, "bbb-disabled", "package.json"),
+      JSON.stringify({ name: "bbb-disabled", version: "1.0.0" }),
+    );
+    writeFileSync(join(pluginsDir, "bbb-disabled", ".disabled"), "");
+
+    // Disable one default plugin
+    mkdirSync(join(pluginsDir, "default-advisor"), { recursive: true });
+    writeFileSync(join(pluginsDir, "default-advisor", ".disabled"), "");
+
+    const result = listAllPlugins({ workspacePluginsDir: pluginsDir });
+
+    const enabledUserIdx = result.findIndex(
+      (p) => p.source === "user" && !p.disabled,
+    );
+    const disabledUserIdx = result.findIndex(
+      (p) => p.source === "user" && p.disabled,
+    );
+    const enabledDefaultIdx = result.findIndex(
+      (p) => p.source === "default" && !p.disabled,
+    );
+    const disabledDefaultIdx = result.findIndex(
+      (p) => p.source === "default" && p.disabled,
+    );
+
+    // All groups present.
+    expect(enabledUserIdx).toBeGreaterThanOrEqual(0);
+    expect(disabledUserIdx).toBeGreaterThan(enabledUserIdx);
+    expect(enabledDefaultIdx).toBeGreaterThan(disabledUserIdx);
+    expect(disabledDefaultIdx).toBeGreaterThan(enabledDefaultIdx);
+  });
+
+  test("user plugins sorted by install date within each group", () => {
+    // Create two user plugins with different install dates.
+    // First plugin (older).
+    mkdirSync(join(pluginsDir, "older-plugin"));
+    writeFileSync(
+      join(pluginsDir, "older-plugin", "package.json"),
+      JSON.stringify({ name: "older-plugin", version: "1.0.0" }),
+    );
+    writeFileSync(
+      join(pluginsDir, "older-plugin", "install-meta.json"),
+      JSON.stringify({ installedAt: "2025-01-01T00:00:00.000Z" }),
+    );
+
+    // Second plugin (newer).
+    mkdirSync(join(pluginsDir, "newer-plugin"));
+    writeFileSync(
+      join(pluginsDir, "newer-plugin", "package.json"),
+      JSON.stringify({ name: "newer-plugin", version: "1.0.0" }),
+    );
+    writeFileSync(
+      join(pluginsDir, "newer-plugin", "install-meta.json"),
+      JSON.stringify({ installedAt: "2025-06-01T00:00:00.000Z" }),
+    );
+
+    const result = listAllPlugins({ workspacePluginsDir: pluginsDir });
+    const userPlugins = result.filter((p) => p.source === "user");
+    expect(userPlugins).toHaveLength(2);
+    // Older plugin should come first (install date ascending).
+    expect(userPlugins[0]!.name).toBe("older-plugin");
+    expect(userPlugins[1]!.name).toBe("newer-plugin");
+  });
+
+  test("default plugins have version from their manifest", () => {
+    const result = listAllPlugins({ workspacePluginsDir: pluginsDir });
+    const advisor = result.find((p) => p.name === "default-advisor");
+    expect(advisor).toBeDefined();
+    expect(advisor!.packageJson?.version).toBeTruthy();
+  });
+});

package/src/cli/lib/list-installed-plugins.ts

@@ -13,10 +13,25 @@
  */
 
 import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
-import { join } from "node:path";
+import { dirname, join } from "node:path";
 
 import { getWorkspacePluginsDir } from "../../util/platform.js";
 
+/**
+ * Directory containing first-party default plugin packages. Each subdirectory
+ * has a `package.json` with `name` (prefixed `default-`) and `version`.
+ * Read from the filesystem at call time to avoid pulling hook/tool
+ * implementations into the CLI process (which would create circular
+ * dependencies in test environments).
+ */
+const DEFAULT_PLUGINS_DIR = join(
+  dirname(new URL(import.meta.url).pathname),
+  "..",
+  "..",
+  "plugins",
+  "defaults",
+);
+
 /** Minimal manifest fields surfaced to the CLI. */
 export interface PluginPackageMetadata {
   readonly name?: string;
@@ -40,6 +55,20 @@ export interface InstalledPluginInfo {
   readonly issues: readonly string[];
 }
 
+/** Where the plugin comes from. */
+export type PluginSource = "user" | "default";
+
+/**
+ * Extended plugin entry that includes source (`user` vs `default`) and
+ * disabled status. Used by {@link listAllPlugins}.
+ */
+export interface AllPluginInfo extends InstalledPluginInfo {
+  /** Whether this is a user-installed or first-party default plugin. */
+  readonly source: PluginSource;
+  /** Whether the plugin is disabled via a `.disabled` sentinel file. */
+  readonly disabled: boolean;
+}
+
 /** Options accepted by {@link listInstalledPlugins}. */
 export interface ListInstalledPluginsOptions {
   /** Override the workspace plugins directory. Falls back to {@link getWorkspacePluginsDir}. */
@@ -146,3 +175,152 @@ function readPluginEntry(
 
   return { name, target, packageJson, issues };
 }
+
+/**
+ * List all plugins — both user-installed (from `<workspace>/plugins/`) and
+ * first-party defaults (from the source tree). Each entry is annotated with
+ * its `source` (`"user"` or `"default"`) and `disabled` status (whether a
+ * `.disabled` sentinel file exists in the plugin's workspace directory).
+ *
+ * For user plugins, the `.disabled` file lives in the plugin's own install
+ * directory. For default plugins, it lives in a stub directory at
+ * `<workspace>/plugins/<manifest-name>/` (created by `plugins disable`).
+ *
+ * Stub directories created by `plugins disable <default-name>` are excluded
+ * from the user listing so a disabled default plugin appears only once (as a
+ * default entry, not a duplicate user entry with "missing package.json").
+ *
+ * Sort order:
+ * 1. Enabled user plugins (by install date, oldest first — matches
+ *    hook/tool resolution order)
+ * 2. Disabled user plugins (by install date)
+ * 3. Enabled default plugins (by repo array order — matches registration
+ *    order which fixes hook-chain order)
+ * 4. Disabled default plugins (by repo array order)
+ */
+export function listAllPlugins(
+  opts: ListInstalledPluginsOptions = {},
+): AllPluginInfo[] {
+  const pluginsDir = opts.workspacePluginsDir ?? getWorkspacePluginsDir();
+
+  // ── User plugins ───────────────────────────────────────────────────────
+  // Filter out default-plugin stub directories (created by `plugins disable
+  // default-<name>`) so they don't show up as duplicate user entries.
+  const defaultNames = new Set(
+    readDefaultPluginManifests().map((m) => m.name),
+  );
+  const userPlugins: AllPluginInfo[] = listInstalledPlugins(opts)
+    .filter((entry) => !defaultNames.has(entry.name))
+    .map((entry) => ({
+      ...entry,
+      source: "user" as const,
+      disabled: existsSync(join(entry.target, ".disabled")),
+    }));
+
+  // ── Default plugins ────────────────────────────────────────────────────
+  // Default plugins live in the source tree at src/plugins/defaults/<name>/.
+  // Read each package.json from the filesystem to get name+version without
+  // importing hook/tool implementations (which would create circular
+  // dependencies in test environments). The .disabled sentinel lives in a
+  // stub directory at <workspace>/plugins/<manifest-name>/.
+  // readDefaultPluginManifests returns in repo array (registration) order.
+  const defaultPlugins: AllPluginInfo[] = readDefaultPluginManifests().map(
+    (manifest) => {
+      const target = join(pluginsDir, manifest.name);
+      const disabled = existsSync(join(target, ".disabled"));
+      return {
+        name: manifest.name,
+        target,
+        packageJson: {
+          name: manifest.name,
+          version: manifest.version,
+        },
+        issues: [],
+        source: "default" as const,
+        disabled,
+      };
+    },
+  );
+
+  // Sort: enabled user (install date), disabled user (install date),
+  // enabled default (repo order), disabled default (repo order).
+  const enabledUser = userPlugins.filter((p) => !p.disabled);
+  const disabledUser = userPlugins.filter((p) => p.disabled);
+  const enabledDefault = defaultPlugins.filter((p) => !p.disabled);
+  const disabledDefault = defaultPlugins.filter((p) => p.disabled);
+
+  enabledUser.sort((a, b) => getPluginInstallDate(a) - getPluginInstallDate(b));
+  disabledUser.sort(
+    (a, b) => getPluginInstallDate(a) - getPluginInstallDate(b),
+  );
+  // enabledDefault and disabledDefault keep repo array order (no sort).
+
+  return [...enabledUser, ...disabledUser, ...enabledDefault, ...disabledDefault];
+}
+
+interface DefaultPluginManifest {
+  readonly name: string;
+  readonly version?: string;
+}
+
+/**
+ * Read first-party default plugin manifests from the filesystem. Each
+ * subdirectory under {@link DEFAULT_PLUGINS_DIR} that has a `package.json`
+ * with a `name` field is included. This avoids importing `defaults/index.ts`
+ * (which would pull in hook/tool implementations and create circular
+ * dependencies in test environments).
+ */
+function readDefaultPluginManifests(): readonly DefaultPluginManifest[] {
+  if (!existsSync(DEFAULT_PLUGINS_DIR)) return [];
+
+  const entries = readdirSync(DEFAULT_PLUGINS_DIR, { withFileTypes: true })
+    .filter((e) => e.isDirectory())
+    .map((e) => e.name)
+    .sort();
+
+  const manifests: DefaultPluginManifest[] = [];
+  for (const name of entries) {
+    const pkgJsonPath = join(DEFAULT_PLUGINS_DIR, name, "package.json");
+    if (!existsSync(pkgJsonPath)) continue;
+    try {
+      const raw = readFileSync(pkgJsonPath, "utf8");
+      const parsed = JSON.parse(raw) as Record<string, unknown>;
+      if (typeof parsed.name === "string") {
+        manifests.push({
+          name: parsed.name,
+          version:
+            typeof parsed.version === "string" ? parsed.version : undefined,
+        });
+      }
+    } catch {
+      // Skip malformed entries — lenient like listInstalledPlugins.
+    }
+  }
+  return manifests;
+}
+
+/**
+ * Resolve the install date for a user plugin directory, in epoch ms.
+ * Reads `install-meta.json`'s `installedAt` field first, falling back to
+ * the directory's birthtime. Mirrors the logic in mtime-cache's
+ * `getInstallDate` so the sort order matches hook/tool resolution order.
+ */
+function getPluginInstallDate(plugin: AllPluginInfo): number {
+  const metaPath = join(plugin.target, "install-meta.json");
+  try {
+    if (existsSync(metaPath)) {
+      const raw = JSON.parse(readFileSync(metaPath, "utf8")) as Record<string, unknown>;
+      if (typeof raw.installedAt === "string") {
+        const ms = Date.parse(raw.installedAt);
+        if (Number.isFinite(ms)) return ms;
+      }
+    }
+  } catch {
+    // Fall through to birthtime.
+  }
+  try {
+    return statSync(plugin.target).birthtimeMs;
+  } catch {
+    return 0;
+  }
+}

package/src/config/__tests__/loader-callsite-strip-fallback.test.ts

@@ -0,0 +1,143 @@
+import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import {
+  afterAll,
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  mock,
+  test,
+} from "bun:test";
+
+const WORKSPACE_DIR = process.env.VELLUM_WORKSPACE_DIR!;
+const CONFIG_PATH = join(WORKSPACE_DIR, "config.json");
+
+function ensureTestDir(): void {
+  const dirs = [
+    WORKSPACE_DIR,
+    join(WORKSPACE_DIR, "data"),
+    join(WORKSPACE_DIR, "data", "memory"),
+    join(WORKSPACE_DIR, "data", "logs"),
+  ];
+  for (const dir of dirs) {
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  }
+}
+
+function makeLoggerStub(): Record<string, unknown> {
+  const stub: Record<string, unknown> = {};
+  for (const m of [
+    "info",
+    "warn",
+    "error",
+    "debug",
+    "trace",
+    "fatal",
+    "silent",
+    "child",
+  ]) {
+    stub[m] = m === "child" ? () => makeLoggerStub() : () => {};
+  }
+  return stub;
+}
+
+mock.module("../../util/logger.js", () => ({
+  getLogger: () => makeLoggerStub(),
+}));
+
+afterAll(() => {
+  mock.restore();
+});
+
+import { resolveCallSiteConfig } from "../llm-resolver.js";
+import { invalidateConfigCache, loadConfig } from "../loader.js";
+
+function writeConfig(obj: unknown): void {
+  writeFileSync(CONFIG_PATH, JSON.stringify(obj, null, 2) + "\n");
+}
+
+/**
+ * Base config where the active profile resolves to a DIFFERENT model than the
+ * `balanced` profile that the shipped `memoryV3SelectL2` call-site default
+ * points at. This lets each test distinguish the two failure modes:
+ *   - call-site default applied (fixed)  -> model "balanced-model"
+ *   - silently downgraded to active      -> model "active-model"
+ */
+function baseLlm(callSites: Record<string, unknown>): unknown {
+  return {
+    llm: {
+      default: { provider: "anthropic", model: "default-model" },
+      profiles: {
+        balanced: { provider: "anthropic", model: "balanced-model" },
+        speedy: { provider: "anthropic", model: "active-model" },
+      },
+      activeProfile: "speedy",
+      callSites,
+    },
+  };
+}
+
+describe("config recovery prunes call-site overrides emptied by a strip", () => {
+  beforeEach(() => {
+    ensureTestDir();
+    if (existsSync(CONFIG_PATH)) rmSync(CONFIG_PATH, { force: true });
+    delete process.env.IS_PLATFORM;
+    invalidateConfigCache();
+  });
+
+  afterEach(() => {
+    delete process.env.IS_PLATFORM;
+    if (existsSync(CONFIG_PATH)) rmSync(CONFIG_PATH, { force: true });
+    invalidateConfigCache();
+  });
+
+  test("an undefined call-site profile ref falls back to the shipped default, not the active profile", () => {
+    // The `.profile` ref is invalid (no such profile), so schema recovery
+    // strips it. Before the fix this left `callSites.memoryV3SelectL2 = {}`,
+    // which the resolver treats as a present override and so skips the shipped
+    // `{profile:"balanced"}` default — silently resolving to the active profile.
+    writeConfig(baseLlm({ memoryV3SelectL2: { profile: "ghost-profile" } }));
+
+    const config = loadConfig();
+
+    // The emptied call-site entry must be pruned entirely, not left as `{}`.
+    expect(config.llm.callSites?.memoryV3SelectL2).toBeUndefined();
+
+    // Resolution now lands on the shipped call-site default (balanced), not the
+    // active profile ("active-model"), which is what the bug produced.
+    const resolved = resolveCallSiteConfig("memoryV3SelectL2", config.llm);
+    expect(resolved.model).toBe("balanced-model");
+  });
+
+  test("a valid sibling call-site override survives while the invalid one is pruned", () => {
+    // memoryRouter -> balanced is valid and must be preserved; only the invalid
+    // memoryV3SelectL2 entry is pruned. Guards against over-pruning the parent.
+    writeConfig(
+      baseLlm({
+        memoryV3SelectL2: { profile: "missing" },
+        memoryRouter: { profile: "balanced" },
+      }),
+    );
+
+    const config = loadConfig();
+
+    expect(config.llm.callSites?.memoryV3SelectL2).toBeUndefined();
+    expect(config.llm.callSites?.memoryRouter).toEqual({ profile: "balanced" });
+  });
+
+  test("a partial override keeping other fields is not pruned", () => {
+    // Stripping the invalid `.profile` leaves a non-empty `{temperature:0.5}`,
+    // a legitimate user override the resolver should keep (and which therefore
+    // still shadows the shipped default per existing either/or semantics).
+    writeConfig(
+      baseLlm({ memoryV3SelectL2: { profile: "missing", temperature: 0.5 } }),
+    );
+
+    const config = loadConfig();
+
+    expect(config.llm.callSites?.memoryV3SelectL2).toEqual({
+      temperature: 0.5,
+    });
+  });
+});

package/src/config/bundled-skills/computer-use/TOOLS.json

@@ -8,7 +8,12 @@
       "risk": "low",
       "input_schema": {
         "type": "object",
-        "properties": {},
+        "properties": {
+          "target_client_id": {
+            "type": "string",
+            "description": "ID of the specific client to target. Required when multiple clients support host_cu; omit when only one is connected. Obtain IDs from `assistant clients list --capability host_cu`."
+          }
+        },
         "required": []
       },
       "executor": "tools/computer-use-observe.ts",