@vellumai/assistant 0.10.9 → 0.10.10-dev.202607162206.d08e98e

package/src/cli/lib/upgrade-plugin.ts

@@ -1,12 +1,20 @@
 /**
- * Upgrade a single installed plugin to the marketplace's current pin.
+ * Upgrade a single installed plugin to its source's current revision.
  *
- * The marketplace pins every plugin to a full, immutable commit SHA (see
+ * A marketplace plugin pins to a full, immutable commit SHA (see
  * {@link ./plugin-marketplace}); an upgrade re-materializes the install at
  * whatever SHA the catalog currently advertises. Drift is detected with the
  * same exact commit-SHA comparison {@link ./inspect-plugin} uses, so an
  * upgrade is a no-op when the installed copy already matches the pin.
  *
+ * A plugin installed directly from a GitHub URL (untrusted, not in the
+ * marketplace) is upgraded against its *recorded* source instead: its
+ * `install-meta.json` names the owner/repo/path/ref it was cloned from, and the
+ * upgrade target is whatever that ref resolves to now — a pinned SHA is
+ * immutable (a no-op), a branch / tag / `HEAD` advances as upstream does. Such
+ * an upgrade re-materializes verbatim, with no curated adapter overlay, exactly
+ * as the original untrusted install was (see {@link directUpgrade}).
+ *
  * This is deliberately a distinct operation from install: `install` is
  * first-time materialization (and errors on an existing install unless
  * `--force` is passed), whereas `upgrade` moves an existing install forward.
@@ -36,11 +44,11 @@ import { PRESERVED_ENTRIES } from "../../plugins/plugin-tree-walk.js";
 import { getWorkspacePluginsDir } from "../../util/platform.js";
 import type { FetchLike } from "./fetch-like.js";
 import {
+  fetchCommitDate,
   inspectPlugin,
   type PluginInspection,
   PluginInspectNotFoundError,
   type PluginLocalInfo,
-  type PluginRemoteInfo,
 } from "./inspect-plugin.js";
 import {
   finalizeStagedInstall,
@@ -52,6 +60,7 @@ import {
   PluginSourceUnavailableError,
   type PostinstallRunner,
   readInstallMeta,
+  resolveRefCommit,
   sanitizePluginName,
 } from "./install-from-github.js";
 import { type ConflictLabels, mergePluginTree } from "./merge-plugin-tree.js";
@@ -191,23 +200,27 @@ function pluginTarget(name: string, deps: UpgradePluginDeps): string {
 }
 
 /**
- * Move an installed plugin to the marketplace's current pin.
+ * Move an installed plugin to its source's current revision — the marketplace
+ * pin for a catalog plugin, or the recorded GitHub ref's current commit for a
+ * directly-installed one (delegated to {@link directUpgrade}).
  *
- * The `strategy` controls how local edits are reconciled with the pin:
- * `overwrite` (default) re-installs the pin wholesale; `ours`/`theirs`/
+ * The `strategy` controls how local edits are reconciled with the target:
+ * `overwrite` (default) re-installs it wholesale; `ours`/`theirs`/
  * `assistant` do a three-way merge that carries non-conflicting local edits
  * forward, resolving conflicting hunks toward the local edit (`ours`) or the
- * pin (`theirs`), or leaving git conflict markers in the file for the assistant
- * to resolve (`assistant`).
+ * target (`theirs`), or leaving git conflict markers in the file for the
+ * assistant to resolve (`assistant`).
  *
  * Throws {@link PluginNotInstalledError} when no copy is installed,
- * {@link PluginNotUpgradableError} when the install has no marketplace entry to
- * advance to, {@link PluginMergeBaselineError} when a merge strategy is
- * requested but the install-time baseline cannot be reconstructed,
- * {@link PluginSourceUnavailableError} when the marketplace catalog is
- * temporarily unreachable (a retryable outage, distinct from the permanent
- * no-entry case), and propagates {@link installPlugin}'s errors (e.g. source
- * unavailable, postinstall failure) when the re-install itself fails.
+ * {@link PluginNotUpgradableError} when the install is neither in the
+ * marketplace nor carries a recorded GitHub source to advance,
+ * {@link PluginMergeBaselineError} when a merge strategy is requested but the
+ * install-time baseline cannot be reconstructed,
+ * {@link PluginSourceUnavailableError} when the marketplace catalog or the
+ * plugin source is temporarily unreachable (a retryable outage, distinct from
+ * the permanent no-source case), and propagates {@link installPlugin}'s errors
+ * (e.g. source unavailable, postinstall failure) when the re-install itself
+ * fails.
  */
 export async function upgradePlugin(
   opts: UpgradePluginOptions,
@@ -233,11 +246,19 @@ export async function upgradePlugin(
   switch (inspection.status) {
     case "not-installed":
       throw new PluginNotInstalledError(name, pluginTarget(name, deps));
-    case "not-in-marketplace":
-      throw new PluginNotUpgradableError(
-        name,
-        "it has no marketplace entry to upgrade from",
-      );
+    case "not-in-marketplace": {
+      // The marketplace doesn't claim this name, but a plugin installed directly
+      // from a GitHub URL (untrusted) still has a recorded source to advance:
+      // upgrade it by re-fetching whatever its recorded ref now resolves to.
+      const local = inspection.local;
+      if (!local) {
+        throw new PluginNotUpgradableError(
+          name,
+          "it has no marketplace entry and no installed copy to upgrade",
+        );
+      }
+      return directUpgrade({ name, local, dryRun, strategy }, deps);
+    }
     case "remote-unavailable":
       // A transient catalog outage is not a permanent "cannot upgrade" state:
       // the same request can succeed once the marketplace source recovers, so
@@ -309,17 +330,28 @@ export async function upgradePlugin(
     strategy === "theirs" ||
     strategy === "assistant"
   ) {
+    const [remoteOwner, remoteRepo] = remote.repo.split("/");
     return mergeUpgrade(
       {
         name,
         strategy,
         local,
-        remote,
         fromCommit,
         fromTimestamp,
         toCommit,
         toTimestamp,
         provenanceWasUnknown,
+        theirsSource: {
+          owner: remoteOwner ?? "",
+          repo: remoteRepo ?? "",
+          rootPath: remote.path,
+          ref: remote.commit,
+        },
+        // The install baseline re-materializes with the curated adapter overlay
+        // (canonical ref); the target reads its overlay at the marketplace ref
+        // the pin was advertised from.
+        baseStubRef: DEFAULT_PLUGIN_REF,
+        theirsStubRef: remote.marketplaceRef,
       },
       deps,
     );
@@ -352,9 +384,176 @@ export async function upgradePlugin(
   };
 }
 
+/**
+ * Upgrade a plugin the marketplace does not claim by re-fetching its recorded
+ * GitHub source — the untrusted-direct-install analogue of the marketplace
+ * upgrade above.
+ *
+ * A direct install (`plugins install <github-url>`) records the exact
+ * owner/repo/path/ref it was cloned from in its `install-meta.json`. Its
+ * "latest" is whatever that ref currently resolves to, so the upgrade target is
+ * {@link resolveRefCommit} of the recorded ref — a pinned full SHA is immutable
+ * (nothing to advance to), while a branch / tag / `HEAD` moves as upstream does.
+ * The move is then materialized verbatim, with no curated adapter overlay,
+ * exactly as the original untrusted install was.
+ *
+ * Throws {@link PluginNotUpgradableError} when no resolvable GitHub source was
+ * recorded (a manually-copied install), {@link PluginNotFoundError} when the
+ * recorded ref has vanished from the remote, {@link PluginMergeBaselineError}
+ * when a merge strategy's install-time baseline cannot be reconstructed, and
+ * {@link PluginSourceUnavailableError} on a transient source outage.
+ */
+async function directUpgrade(
+  ctx: {
+    readonly name: string;
+    readonly local: PluginLocalInfo;
+    readonly dryRun: boolean;
+    readonly strategy: PluginUpgradeStrategy;
+  },
+  deps: UpgradePluginDeps,
+): Promise<PluginUpgradeResult> {
+  const { name, local, dryRun, strategy } = ctx;
+  const source = local.source;
+  // Without resolvable GitHub coordinates in the provenance sidecar (a
+  // manually-copied install, or a sidecar naming a non-github source) there is
+  // nothing to re-fetch.
+  if (!source || source.kind !== "github" || !source.owner || !source.repo) {
+    throw new PluginNotUpgradableError(
+      name,
+      "it has no marketplace entry and no recorded GitHub source to re-fetch from",
+    );
+  }
+  const fetchSource: PluginFetchSource = {
+    owner: source.owner,
+    repo: source.repo,
+    rootPath: source.path ?? "",
+    ref: source.ref,
+  };
+
+  const fromCommit = local.commit;
+  const fromTimestamp = local.committedAt;
+  const provenanceWasUnknown = fromCommit === null;
+
+  // Resolve what the recorded ref points at now, without cloning. A pinned
+  // full-SHA ref is immutable, so it resolves to itself — nothing to advance to.
+  const toCommit = await resolveRefCommit(fetchSource, deps.runGit);
+  if (toCommit === null) {
+    // The recorded ref is gone from the remote (deleted branch / tag) or the
+    // repo is unreachable as a hard failure — there is no revision to move to.
+    throw new PluginNotFoundError(
+      name,
+      fetchSource.ref,
+      `${fetchSource.owner}/${fetchSource.repo}`,
+    );
+  }
+
+  if (
+    fromCommit !== null &&
+    toCommit.toLowerCase() === fromCommit.toLowerCase()
+  ) {
+    return {
+      name,
+      outcome: "already-up-to-date",
+      fromCommit,
+      fromTimestamp,
+      toCommit,
+      // The ref still points at the installed commit, so the "to" version is the
+      // "from" version — reuse its recorded timestamp rather than a fresh fetch.
+      toTimestamp: fromTimestamp,
+      target: local.target,
+      fileCount: null,
+      dryRun,
+      strategy,
+      conflicts: [],
+      binaryConflicts: [],
+      provenanceWasUnknown: false,
+    };
+  }
+
+  if (dryRun) {
+    // Preview: resolve the target commit's date the same way `plugins inspect`
+    // does, so the dry run shows the human-readable version it would move to.
+    const toTimestamp = await fetchCommitDate(
+      `${fetchSource.owner}/${fetchSource.repo}`,
+      toCommit,
+      deps.fetch,
+    );
+    return {
+      name,
+      outcome: "would-upgrade",
+      fromCommit,
+      fromTimestamp,
+      toCommit,
+      toTimestamp,
+      target: local.target,
+      fileCount: null,
+      dryRun: true,
+      strategy,
+      conflicts: [],
+      binaryConflicts: [],
+      provenanceWasUnknown,
+    };
+  }
+
+  if (
+    strategy === "ours" ||
+    strategy === "theirs" ||
+    strategy === "assistant"
+  ) {
+    // A direct install carries no curated adapter overlay, so both the install
+    // baseline and the incoming revision re-materialize verbatim (`stubRef`
+    // null), pinned to the recorded install commit and the resolved target.
+    return mergeUpgrade(
+      {
+        name,
+        strategy,
+        local,
+        fromCommit,
+        fromTimestamp,
+        toCommit,
+        toTimestamp: null,
+        provenanceWasUnknown,
+        theirsSource: { ...fetchSource, ref: toCommit },
+        baseStubRef: null,
+        theirsStubRef: null,
+      },
+      deps,
+    );
+  }
+
+  // overwrite (default): re-install the recorded direct source verbatim, moving
+  // to whatever its ref now resolves to. Untrusted — no curated adapter overlay,
+  // just as the original direct install was materialized.
+  const result = await installPlugin(
+    { name, force: true, directSource: fetchSource },
+    {
+      fetch: deps.fetch,
+      workspacePluginsDir: deps.workspacePluginsDir,
+      runGit: deps.runGit,
+      runPostinstall: deps.runPostinstall,
+    },
+  );
+
+  return {
+    name,
+    outcome: "upgraded",
+    fromCommit,
+    fromTimestamp,
+    toCommit: result.commit ?? toCommit,
+    toTimestamp: result.committedAt,
+    target: result.target,
+    fileCount: result.fileCount,
+    dryRun: false,
+    strategy,
+    conflicts: [],
+    binaryConflicts: [],
+    provenanceWasUnknown,
+  };
+}
+
 /**
  * Carry local edits forward by three-way merging the on-disk install (`ours`)
- * and the marketplace pin (`theirs`) against the re-materialized install commit
+ * and the incoming revision (`theirs`) against the re-materialized install commit
  * (`base`), then atomically swapping the merged tree into place pinned at the
  * new commit. Conflicting hunks resolve toward `ours` or `theirs` per the
  * strategy, or are left as git conflict markers under `assistant`;
@@ -365,16 +564,25 @@ async function mergeUpgrade(
     readonly name: string;
     readonly strategy: "ours" | "theirs" | "assistant";
     readonly local: PluginLocalInfo;
-    readonly remote: PluginRemoteInfo;
     readonly fromCommit: string | null;
     readonly fromTimestamp: string | null;
     readonly toCommit: string;
     readonly toTimestamp: string | null;
     readonly provenanceWasUnknown: boolean;
+    /** Coordinates of the revision being merged in (`theirs`), pinned to {@link ctx.toCommit}. */
+    readonly theirsSource: PluginFetchSource;
+    /**
+     * Curated-adapter-stub ref overlaid when re-materializing the install
+     * baseline, or `null` for a direct (untrusted) install that carries no
+     * curated overlay.
+     */
+    readonly baseStubRef: string | null;
+    /** Curated-adapter-stub ref overlaid on the incoming revision, or `null` for a direct install. */
+    readonly theirsStubRef: string | null;
   },
   deps: UpgradePluginDeps,
 ): Promise<PluginUpgradeResult> {
-  const { name, strategy, local, remote } = ctx;
+  const { name, strategy, local, theirsSource } = ctx;
 
   // Marker labels name each side by its commit so the assistant can tell the
   // local edit from the incoming pin when resolving.
@@ -401,13 +609,6 @@ async function mergeUpgrade(
     rootPath: meta.source.path ?? "",
     ref: meta.commit,
   };
-  const [remoteOwner, remoteRepo] = remote.repo.split("/");
-  const theirsSource: PluginFetchSource = {
-    owner: remoteOwner ?? "",
-    repo: remoteRepo ?? "",
-    rootPath: remote.path,
-    ref: remote.commit,
-  };
 
   const pluginsDir = deps.workspacePluginsDir ?? getWorkspacePluginsDir();
   const baseDir = mkdtempSync(join(tmpdir(), `plugin-upgrade-base-${name}-`));
@@ -429,7 +630,7 @@ async function mergeUpgrade(
       {
         source: baseSource,
         name,
-        stubRef: DEFAULT_PLUGIN_REF,
+        stubRef: ctx.baseStubRef,
         destDir: baseDir,
       },
       deps,
@@ -457,7 +658,7 @@ async function mergeUpgrade(
       {
         source: theirsSource,
         name,
-        stubRef: remote.marketplaceRef,
+        stubRef: ctx.theirsStubRef,
         destDir: theirsDir,
       },
       deps,
@@ -479,8 +680,8 @@ async function mergeUpgrade(
       conflictLabels,
     });
 
-    const toCommit = theirs.commit ?? remote.commit;
-    const toTimestamp = theirs.committedAt ?? remote.committedAt;
+    const toCommit = theirs.commit ?? ctx.toCommit;
+    const toTimestamp = theirs.committedAt ?? ctx.toTimestamp;
     finalizeStagedInstall(stagingDir, {
       name,
       source: theirsSource,

package/src/config/__tests__/default-profile-catalog.test.ts

@@ -1,6 +1,5 @@
 import { describe, expect, test } from "bun:test";
 
-import { setOverridesForTesting } from "../../__tests__/feature-flag-test-helpers.js";
 import { resolveModelIntent } from "../../providers/model-intents.js";
 import { CALL_SITE_DEFAULTS } from "../call-site-defaults.js";
 import {
@@ -177,7 +176,7 @@ describe("resolver integration", () => {
     }
   });
 
-  test("a disabled managed default falls through to the custom-* profile", () => {
+  test("a disabled managed default does not divert resolution to the custom-* clone", () => {
     const llm = LLMSchema.parse({
       profiles: {
         balanced: { source: "managed", status: "disabled" },
@@ -189,18 +188,15 @@ describe("resolver integration", () => {
         },
       },
     });
-    // Legacy cascade: the disabled stub falls through to the custom-* hop.
-    setOverridesForTesting({ "override-or-default-resolution": false });
-    expect(resolveDefaultProfileKey("mainAgent", llm)).toBe("custom-balanced");
-    const resolved = resolveCallSiteConfig("mainAgent", llm);
-    expect(resolved.model).toBe("claude-sonnet-4-6");
-    // Override-or-default: the hop is gone — the fallback anchor is the
-    // code-owned intent, and a legacy disabled stub does not suppress it.
-    setOverridesForTesting({});
+    // The fallback anchor is the code-owned intent: a legacy disabled stub
+    // does not suppress it, and the user-mutable custom-* clone never
+    // captures the call site.
     expect(resolveDefaultProfileKey("mainAgent", llm)).toBe("balanced");
-    expect(resolveCallSiteConfig("mainAgent", llm).model).not.toBe(
-      "claude-sonnet-4-6",
+    const resolved = resolveCallSiteConfig("mainAgent", llm);
+    expect(resolved.model).toBe(
+      CODE_DEFAULT_PROFILE_ENTRIES.balanced.model as string,
     );
+    expect(resolved.model).not.toBe("claude-sonnet-4-6");
   });
 });
 

package/src/config/__tests__/plugin-resident-skill-discovery.test.ts

@@ -0,0 +1,137 @@
+/**
+ * Tests for plugin-resident skill discovery in `loadSkillCatalog`.
+ *
+ * The catalog surfaces skills a plugin ships at `plugins/<dir>/skills/<id>/`.
+ * The gate is a loadable manifest (parseable `package.json` with a non-empty
+ * `name`) — the manifest `name` need NOT equal the install directory name.
+ * That match must not be required: a plugin is installed under its marketplace
+ * slug or GitHub path leaf, which routinely differs from its `package.json`
+ * `name` (e.g. cognee installs to `cognee`/`vellum-assistant` while its package
+ * is named `cognee-memory`). Requiring the match silently drops the plugin's
+ * skills even though the runtime loads its hooks and tools fine.
+ */
+import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { beforeEach, describe, expect, test } from "bun:test";
+
+import { getWorkspacePluginsDir } from "../../util/platform.js";
+import { loadSkillCatalog } from "../skills.js";
+
+function writePlugin(
+  dirName: string,
+  packageName: string,
+  skills: Array<{ id: string; description: string }>,
+  opts: { disabled?: boolean; packageJson?: string | null } = {},
+): void {
+  const pluginDir = join(getWorkspacePluginsDir(), dirName);
+  mkdirSync(pluginDir, { recursive: true });
+
+  if (opts.packageJson === null) {
+    // Intentionally omit package.json.
+  } else {
+    writeFileSync(
+      join(pluginDir, "package.json"),
+      opts.packageJson ??
+        JSON.stringify({
+          name: packageName,
+          version: "1.0.0",
+          peerDependencies: { "@vellumai/plugin-api": "*" },
+        }),
+    );
+  }
+
+  if (opts.disabled) writeFileSync(join(pluginDir, ".disabled"), "");
+
+  for (const skill of skills) {
+    const skillDir = join(pluginDir, "skills", skill.id);
+    mkdirSync(skillDir, { recursive: true });
+    writeFileSync(
+      join(skillDir, "SKILL.md"),
+      `---\nname: ${skill.id}\ndescription: ${skill.description}\n---\n\nBody for ${skill.id}.\n`,
+    );
+  }
+}
+
+function skillById(id: string) {
+  return loadSkillCatalog().find((s) => s.id === id);
+}
+
+describe("discoverPluginResidentSkills (via loadSkillCatalog)", () => {
+  beforeEach(() => {
+    const pluginsDir = getWorkspacePluginsDir();
+    if (existsSync(pluginsDir))
+      rmSync(pluginsDir, { recursive: true, force: true });
+  });
+
+  test("surfaces a plugin skill when the install dir name differs from package.json name", () => {
+    // dir `vellum-assistant` (GitHub path leaf) vs package `cognee-memory`:
+    // the exact cognee shape that was silently dropped before.
+    writePlugin("vellum-assistant", "cognee-memory", [
+      {
+        id: "qa-cognee-sync",
+        description: "Sync session memory into the graph.",
+      },
+    ]);
+
+    const skill = skillById("qa-cognee-sync");
+    expect(skill).toBeDefined();
+    expect(skill!.source).toBe("plugin");
+    // Attribution is the install slug (directory name), which is the identity
+    // used by `plugins list` and per-conversation plugin scoping.
+    expect(skill!.owner).toEqual({ kind: "plugin", id: "vellum-assistant" });
+  });
+
+  test("surfaces a plugin skill when dir name equals package.json name", () => {
+    writePlugin("demo-matched", "demo-matched", [
+      { id: "qa-matched-skill", description: "A matched-name plugin skill." },
+    ]);
+
+    const skill = skillById("qa-matched-skill");
+    expect(skill).toBeDefined();
+    expect(skill!.owner).toEqual({ kind: "plugin", id: "demo-matched" });
+  });
+
+  test("skips a plugin directory that has no package.json", () => {
+    writePlugin(
+      "no-manifest",
+      "unused",
+      [{ id: "qa-no-manifest-skill", description: "Should not surface." }],
+      { packageJson: null },
+    );
+
+    expect(skillById("qa-no-manifest-skill")).toBeUndefined();
+  });
+
+  test("skips a plugin directory whose package.json is unparseable", () => {
+    writePlugin(
+      "bad-manifest",
+      "unused",
+      [{ id: "qa-bad-manifest-skill", description: "Should not surface." }],
+      { packageJson: "{ not valid json" },
+    );
+
+    expect(skillById("qa-bad-manifest-skill")).toBeUndefined();
+  });
+
+  test("skips a plugin directory whose package.json has no name", () => {
+    writePlugin(
+      "nameless",
+      "unused",
+      [{ id: "qa-nameless-skill", description: "Should not surface." }],
+      { packageJson: JSON.stringify({ version: "1.0.0" }) },
+    );
+
+    expect(skillById("qa-nameless-skill")).toBeUndefined();
+  });
+
+  test("hides resident skills of a disabled plugin", () => {
+    writePlugin(
+      "disabled-plugin",
+      "disabled-pkg",
+      [{ id: "qa-disabled-skill", description: "Hidden while disabled." }],
+      { disabled: true },
+    );
+
+    expect(skillById("qa-disabled-skill")).toBeUndefined();
+  });
+});

package/src/config/__tests__/profile-materialization.test.ts

@@ -1,9 +1,8 @@
 import { describe, expect, test } from "bun:test";
 
 import { VELLUM_MANAGED_CONNECTION_NAME } from "../../providers/vellum-model-routing.js";
-import { resolveCallSiteConfig } from "../llm-resolver.js";
 import { completeCustomProfile } from "../profile-materialization.js";
-import { LLMConfigBase, LLMSchema, ProfileEntry } from "../schemas/llm.js";
+import { LLMConfigBase, ProfileEntry } from "../schemas/llm.js";
 
 const fullDefault = LLMConfigBase.parse({
   provider: "anthropic",
@@ -209,89 +208,3 @@ describe("completeCustomProfile", () => {
     expect(completed.contextWindow).not.toBe(fullDefault.contextWindow);
   });
 });
-
-// Equivalence with the live deep-merge resolver: on a profile-less call site
-// with no activeProfile, the custom profile is the only profile layer above
-// `llm.default`, which is exactly the standalone meaning materialization
-// bakes in. Partial and completed forms must resolve identically — this is
-// the contract that lets migration 128 rewrite profiles without changing
-// behavior under the current resolver, and lets the M6 resolver treat the
-// completed form as the profile's full meaning.
-//
-// (Deliberately NOT covered: a partial profile layered above other profiles
-// — e.g. mainAgent activeProfile above the balanced call-site layer — where
-// omitted fields inherit from the mid layer today. That context-dependent
-// meaning is unrepresentable as a single complete profile; the standalone
-// reading is the one that ships. See the M6 plan, Behavior changes #4.)
-describe("completeCustomProfile — resolver equivalence", () => {
-  const PARTIALS: Record<string, ProfileEntry> = {
-    empty: {},
-    "model only, served by default provider": { model: "claude-fable-5" },
-    "model only, implies another provider": { model: "gpt-5.5" },
-    "sampling only": { temperature: 0.3 },
-    "explicit null sampling": { temperature: null },
-    "nested thinking fragment": { thinking: { enabled: false } },
-    "tokens and effort": { maxTokens: 1234, effort: "low" },
-    "explicit cross-provider without connection": {
-      provider: "openai",
-      model: "gpt-5.4",
-    },
-    "complete profile": {
-      provider: "openai",
-      model: "gpt-5.4",
-      provider_connection: "openai-personal",
-      maxTokens: 9000,
-      effort: "high",
-      temperature: 0.1,
-      topP: 0.5,
-    },
-    "metadata alongside config": {
-      model: "gpt-5.5",
-      label: "My GPT",
-      description: "d",
-      status: "active",
-    },
-  };
-
-  // Run the whole matrix against two defaults: the schema-typical null
-  // sampling, and a default with non-null temperature/topP — the latter is
-  // what catches sampling-inheritance regressions (null defaults make those
-  // cases pass vacuously).
-  const DEFAULTS: Record<string, LLMConfigBase> = {
-    "null sampling": fullDefault,
-    "non-null sampling": LLMConfigBase.parse({
-      ...fullDefault,
-      temperature: 0.7,
-      topP: 0.9,
-    }),
-  };
-
-  const resolveWith = (dflt: LLMConfigBase, profile: ProfileEntry) => {
-    const llm = LLMSchema.parse({
-      default: dflt,
-      profiles: { "custom-x": { source: "user", ...profile } },
-    });
-    return resolveCallSiteConfig("vision", llm, {
-      overrideProfile: "custom-x",
-      // The equivalence contract is a legacy-cascade property by definition:
-      // materialization pins what the MERGE produced. Under
-      // override-or-default semantics a partial profile falls back instead
-      // of merging (pinned by llm-resolver-override-or-default.test.ts).
-      resolutionSemantics: "legacy-merge",
-    });
-  };
-
-  for (const [defaultName, dflt] of Object.entries(DEFAULTS)) {
-    for (const [name, partial] of Object.entries(PARTIALS)) {
-      test(`partial and completed resolve identically (${defaultName} default): ${name}`, () => {
-        const completed = completeCustomProfile(dflt, {
-          source: "user",
-          ...partial,
-        });
-        expect(resolveWith(dflt, completed)).toEqual(
-          resolveWith(dflt, partial),
-        );
-      });
-    }
-  }
-});