@vellumai/assistant 0.8.11 → 0.8.12-staging.2

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

@@ -33,6 +33,7 @@ import {
   type FetchLike,
   sanitizePluginName,
 } from "./install-from-github.js";
+import { parsePluginArtifact, type PluginArtifact } from "./plugin-artifact.js";
 import {
   fetchMarketplaceEntries,
   type MarketplaceEntry,
@@ -56,6 +57,7 @@ interface PluginManifestFields {
   readonly description: string | null;
   readonly homepage: string | null;
   readonly license: string | null;
+  readonly artifact: PluginArtifact | null;
 }
 
 /** Options that control which plugin to resolve and at what ref. */
@@ -97,6 +99,13 @@ export interface PluginDetails {
   readonly readme: string | null;
   /** Git ref the catalog metadata / README were resolved at. */
   readonly ref: string;
+  /**
+   * Prebuilt client artifact (download URL + sha256) declared in the
+   * plugin's `package.json` `vellum.artifact`, resolved from the installed
+   * copy first then the repo; `null` when the plugin ships none or its
+   * descriptor is incomplete (e.g. a placeholder `sha256`).
+   */
+  readonly artifact: PluginArtifact | null;
 }
 
 /** No installed copy and no catalog/source entry claims the name. */
@@ -175,6 +184,7 @@ export async function getPluginDetails(
     source,
     readme,
     ref,
+    artifact: local.manifest.artifact ?? remote.manifest.artifact,
   };
 }
 
@@ -342,7 +352,13 @@ function githubFetch(
 }
 
 function emptyManifest(): PluginManifestFields {
-  return { version: null, description: null, homepage: null, license: null };
+  return {
+    version: null,
+    description: null,
+    homepage: null,
+    license: null,
+    artifact: null,
+  };
 }
 
 function safeParseManifest(raw: string): PluginManifestFields {
@@ -365,6 +381,7 @@ function parseManifest(raw: string): PluginManifestFields {
     description: typeof meta.description === "string" ? meta.description : null,
     homepage: typeof meta.homepage === "string" ? meta.homepage : null,
     license: normalizeLicense(meta.license),
+    artifact: parsePluginArtifact(parsed),
   };
 }
 

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

@@ -0,0 +1,197 @@
+/**
+ * Content fingerprint of an installed plugin tree, used to detect local
+ * modifications after install.
+ *
+ * A plugin install is a flattened snapshot of a commit — the `.git` metadata is
+ * stripped during materialization (see {@link ./install-from-github}), so there
+ * is no working tree to ask `git status`. To tell whether a user has edited an
+ * installed copy, install records a per-file digest of the materialized tree in
+ * the provenance sidecar; later a recompute over the on-disk copy is compared
+ * against that baseline.
+ *
+ * The fingerprint is a one-way digest map — it answers "did this change?" and
+ * "which files?", but cannot reconstruct the original bytes. Producing an
+ * actual diff or a 3-way merge instead re-derives the baseline from the
+ * recorded immutable commit SHA (a separate concern from this module).
+ */
+
+import { createHash } from "node:crypto";
+import { readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+
+/** Digest algorithm recorded alongside the file map, for forward compatibility. */
+export type FingerprintAlgorithm = "sha256";
+
+/**
+ * Per-file content digest of a plugin tree. Keys are POSIX-style
+ * (forward-slash) paths relative to the plugin root so the baseline is stable
+ * across platforms; values are lowercase hex digests of each file's bytes.
+ */
+export interface Fingerprint {
+  readonly algorithm: FingerprintAlgorithm;
+  readonly files: Readonly<Record<string, string>>;
+}
+
+/**
+ * Difference between a recorded fingerprint and the current on-disk tree.
+ * Paths are POSIX-relative, matching {@link Fingerprint.files}. A rename
+ * surfaces as one `removed` plus one `added` entry.
+ */
+export interface FingerprintComparison {
+  /** Present in both, but the content digest differs. */
+  readonly modified: readonly string[];
+  /** Present on disk, absent from the recorded baseline. */
+  readonly added: readonly string[];
+  /** Recorded in the baseline, absent on disk. */
+  readonly removed: readonly string[];
+  /** True when the on-disk tree exactly matches the recorded baseline. */
+  readonly clean: boolean;
+}
+
+function hashFile(absPath: string): string {
+  return createHash("sha256").update(readFileSync(absPath)).digest("hex");
+}
+
+/**
+ * Walk `root` and return a content digest for every regular file, keyed by its
+ * POSIX-relative path. Symlinks are skipped (the loader does not follow them,
+ * and install never materializes them); top-level entries named in `exclude`
+ * are skipped so the provenance sidecar never fingerprints itself.
+ */
+export function computeFingerprint(
+  root: string,
+  exclude: readonly string[] = [],
+): Fingerprint {
+  const excluded = new Set(exclude);
+  const files: Record<string, string> = {};
+
+  const walk = (relDir: string): void => {
+    const absDir = relDir ? join(root, relDir) : root;
+    for (const entry of readdirSync(absDir, { withFileTypes: true })) {
+      if (relDir === "" && excluded.has(entry.name)) continue;
+      // Only regular files contribute to the digest; symlinks are never part of
+      // a materialized install and a directory is descended into, not hashed.
+      if (entry.isSymbolicLink()) continue;
+      const rel = relDir ? `${relDir}/${entry.name}` : entry.name;
+      if (entry.isDirectory()) {
+        walk(rel);
+      } else if (entry.isFile()) {
+        files[rel] = hashFile(join(root, rel));
+      }
+    }
+  };
+
+  walk("");
+  return { algorithm: "sha256", files };
+}
+
+/**
+ * Compare the current contents of `root` against a recorded fingerprint,
+ * applying the same `exclude` used to compute the baseline so the sidecar is
+ * not counted as an addition.
+ */
+export function compareFingerprint(
+  root: string,
+  baseline: Fingerprint,
+  exclude: readonly string[] = [],
+): FingerprintComparison {
+  const current = computeFingerprint(root, exclude).files;
+  const modified: string[] = [];
+  const added: string[] = [];
+  const removed: string[] = [];
+
+  for (const [path, digest] of Object.entries(current)) {
+    const recorded = baseline.files[path];
+    if (recorded === undefined) added.push(path);
+    else if (recorded !== digest) modified.push(path);
+  }
+  for (const path of Object.keys(baseline.files)) {
+    if (current[path] === undefined) removed.push(path);
+  }
+
+  modified.sort();
+  added.sort();
+  removed.sort();
+  return {
+    modified,
+    added,
+    removed,
+    clean: modified.length === 0 && added.length === 0 && removed.length === 0,
+  };
+}
+
+/**
+ * Parse a fingerprint from already-decoded JSON. Lenient by design — any shape
+ * problem yields `null` so an older or hand-edited sidecar simply reports "no
+ * recorded baseline" rather than throwing.
+ */
+export function parseFingerprint(value: unknown): Fingerprint | null {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return null;
+  }
+  const obj = value as Record<string, unknown>;
+  if (obj.algorithm !== "sha256") return null;
+  const rawFiles = obj.files;
+  if (
+    typeof rawFiles !== "object" ||
+    rawFiles === null ||
+    Array.isArray(rawFiles)
+  ) {
+    return null;
+  }
+  const files: Record<string, string> = {};
+  for (const [path, digest] of Object.entries(rawFiles)) {
+    if (typeof digest !== "string") return null;
+    files[path] = digest;
+  }
+  return { algorithm: "sha256", files };
+}
+
+/**
+ * Aggregate SHA-256 digest over a tree's contents, returned as `v2:<hex>`.
+ *
+ * This is the same scheme skills record in their `install-meta.json`
+ * `contentHash` (see `src/skills/install-meta.ts`): files are visited in
+ * POSIX-relative path order and each contributes a length-prefixed path
+ * segment followed by its length-prefixed bytes, so neither path/content
+ * boundaries nor reordering can collide. The `v2:` prefix marks the hashing
+ * scheme so it can evolve without ambiguity. Unlike {@link Fingerprint}, this
+ * is a single whole-tree digest — useful as a compact integrity signal
+ * alongside the per-file map. Symlinks are skipped and top-level entries named
+ * in `exclude` (e.g. the sidecar itself) are omitted, matching
+ * {@link computeFingerprint}.
+ */
+export function computeContentHash(
+  root: string,
+  exclude: readonly string[] = [],
+): string {
+  const excluded = new Set(exclude);
+  const entries: Array<{ rel: string; abs: string }> = [];
+
+  const walk = (relDir: string): void => {
+    const absDir = relDir ? join(root, relDir) : root;
+    for (const entry of readdirSync(absDir, { withFileTypes: true })) {
+      if (relDir === "" && excluded.has(entry.name)) continue;
+      if (entry.isSymbolicLink()) continue;
+      const rel = relDir ? `${relDir}/${entry.name}` : entry.name;
+      if (entry.isDirectory()) {
+        walk(rel);
+      } else if (entry.isFile()) {
+        entries.push({ rel, abs: join(root, rel) });
+      }
+    }
+  };
+  walk("");
+  entries.sort((a, b) => a.rel.localeCompare(b.rel));
+
+  const hash = createHash("sha256");
+  for (const { rel, abs } of entries) {
+    const pathBuf = Buffer.from(rel, "utf-8");
+    const content = readFileSync(abs);
+    hash.update(`${pathBuf.length}:`);
+    hash.update(pathBuf);
+    hash.update(`${content.length}:`);
+    hash.update(content);
+  }
+  return `v2:${hash.digest("hex")}`;
+}

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

@@ -0,0 +1,225 @@
+/**
+ * Upgrade a single installed plugin to the marketplace's current pin.
+ *
+ * The marketplace pins every plugin 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.
+ *
+ * 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.
+ * Mechanically the move is a forced re-install at the current pin, which the
+ * underlying {@link ./install-from-github.installPlugin} performs atomically —
+ * the previously installed copy is preserved until the fetch succeeds.
+ *
+ * Conflict resolution for locally-modified plugins is intentionally out of
+ * scope here: this overwrites the install with the pinned tree. A future
+ * iteration will detect local edits (installed SHA = merge base) and resolve
+ * them before the swap.
+ *
+ * Designed for direct programmatic use with injected dependencies, mirroring
+ * the sibling plugin libraries. The CLI command `assistant plugins upgrade
+ * <name>` is a thin wrapper that supplies production deps and formats the
+ * result.
+ */
+
+import { join } from "node:path";
+
+import { getWorkspacePluginsDir } from "../../util/platform.js";
+import {
+  inspectPlugin,
+  type PluginInspection,
+  PluginInspectNotFoundError,
+} from "./inspect-plugin.js";
+import {
+  type FetchLike,
+  type GitRunner,
+  installPlugin,
+  PluginSourceUnavailableError,
+  type PostinstallRunner,
+  sanitizePluginName,
+} from "./install-from-github.js";
+import { PluginNotInstalledError } from "./uninstall-plugin.js";
+
+/**
+ * Outcome of an upgrade attempt.
+ *
+ * - `upgraded` — the install was moved to the current marketplace pin.
+ * - `already-up-to-date` — the installed commit already equals the pin; no-op.
+ * - `would-upgrade` — a `--dry-run` that found drift but made no changes.
+ */
+export type PluginUpgradeOutcome =
+  | "upgraded"
+  | "already-up-to-date"
+  | "would-upgrade";
+
+/** Options that control which plugin to upgrade and how. */
+export interface UpgradePluginOptions {
+  /** Install name (kebab-case directory name). */
+  readonly name: string;
+  /** Report what would change without modifying the install. */
+  readonly dryRun?: boolean;
+}
+
+/** Dependencies injected by the caller. */
+export interface UpgradePluginDeps {
+  /** HTTP client. Production callers pass `globalThis.fetch.bind(globalThis)`. */
+  readonly fetch: FetchLike;
+  /** Override the workspace plugins directory. Falls back to the live workspace. */
+  readonly workspacePluginsDir?: string;
+  /** Override the git runner used to clone the source. Forwarded to {@link installPlugin}. */
+  readonly runGit?: GitRunner;
+  /** Override the postinstall adapter runner. Forwarded to {@link installPlugin}. */
+  readonly runPostinstall?: PostinstallRunner;
+}
+
+/** Result of an upgrade attempt. */
+export interface PluginUpgradeResult {
+  readonly name: string;
+  readonly outcome: PluginUpgradeOutcome;
+  /** Installed commit before the upgrade; `null` when no provenance was recorded. */
+  readonly fromCommit: string | null;
+  /** Marketplace-pinned commit the install was (or would be) moved to. */
+  readonly toCommit: string;
+  /** Absolute path to the installed plugin directory. */
+  readonly target: string;
+  /** Files materialized by the upgrade; `null` for a no-op or dry run. */
+  readonly fileCount: number | null;
+  /** Whether this was a dry run (no changes made). */
+  readonly dryRun: boolean;
+  /**
+   * Whether the installed copy lacked resolvable provenance before the
+   * upgrade. Such installs are re-pinned to the current SHA, which also
+   * records provenance going forward.
+   */
+  readonly provenanceWasUnknown: boolean;
+}
+
+/** An installed plugin has no marketplace pin to upgrade to. */
+export class PluginNotUpgradableError extends Error {
+  constructor(
+    readonly pluginName: string,
+    reason: string,
+  ) {
+    super(`Plugin "${pluginName}" cannot be upgraded: ${reason}.`);
+    this.name = "PluginNotUpgradableError";
+  }
+}
+
+function pluginTarget(name: string, deps: UpgradePluginDeps): string {
+  const dir = deps.workspacePluginsDir ?? getWorkspacePluginsDir();
+  return join(dir, name);
+}
+
+/**
+ * Move an installed plugin to the marketplace's current pin.
+ *
+ * Throws {@link PluginNotInstalledError} when no copy is installed,
+ * {@link PluginNotUpgradableError} when the install has no marketplace entry to
+ * advance to, {@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.
+ */
+export async function upgradePlugin(
+  opts: UpgradePluginOptions,
+  deps: UpgradePluginDeps,
+): Promise<PluginUpgradeResult> {
+  const name = sanitizePluginName(opts.name);
+  const dryRun = opts.dryRun ?? false;
+
+  let inspection: PluginInspection;
+  try {
+    inspection = await inspectPlugin(
+      { name },
+      { fetch: deps.fetch, workspacePluginsDir: deps.workspacePluginsDir },
+    );
+  } catch (err) {
+    if (err instanceof PluginInspectNotFoundError) {
+      throw new PluginNotInstalledError(name, pluginTarget(name, deps));
+    }
+    throw err;
+  }
+
+  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 "remote-unavailable":
+      // A transient catalog outage is not a permanent "cannot upgrade" state:
+      // the same request can succeed once the marketplace source recovers, so
+      // surface it as a retryable source-unavailable error rather than a
+      // conflict.
+      throw new PluginSourceUnavailableError(
+        `Plugin "${name}" cannot be upgraded: the marketplace could not be reached (${inspection.remoteError ?? "unknown error"}).`,
+        503,
+      );
+  }
+
+  // The remaining statuses (up-to-date, update-available, unknown-provenance)
+  // all imply an installed copy and a resolvable marketplace pin.
+  const { local, remote } = inspection;
+  if (!local || !remote) {
+    throw new PluginNotUpgradableError(
+      name,
+      "its install or marketplace metadata could not be resolved",
+    );
+  }
+
+  const fromCommit = local.commit;
+  const toCommit = remote.commit;
+  const provenanceWasUnknown = inspection.status === "unknown-provenance";
+
+  if (inspection.status === "up-to-date") {
+    return {
+      name,
+      outcome: "already-up-to-date",
+      fromCommit,
+      toCommit,
+      target: local.target,
+      fileCount: null,
+      dryRun,
+      provenanceWasUnknown: false,
+    };
+  }
+
+  if (dryRun) {
+    return {
+      name,
+      outcome: "would-upgrade",
+      fromCommit,
+      toCommit,
+      target: local.target,
+      fileCount: null,
+      dryRun: true,
+      provenanceWasUnknown,
+    };
+  }
+
+  const result = await installPlugin(
+    { name, force: true },
+    {
+      fetch: deps.fetch,
+      workspacePluginsDir: deps.workspacePluginsDir,
+      runGit: deps.runGit,
+      runPostinstall: deps.runPostinstall,
+    },
+  );
+
+  return {
+    name,
+    outcome: "upgraded",
+    fromCommit,
+    toCommit: result.commit ?? toCommit,
+    target: result.target,
+    fileCount: result.fileCount,
+    dryRun: false,
+    provenanceWasUnknown,
+  };
+}

package/src/config/bundled-skills/subagent/SKILL.md

@@ -39,6 +39,7 @@ Each subagent is spawned with a role that determines its tool access. Choose the
 | `researcher` | `web_search`, `web_fetch`, `file_read`, `file_list`, `recall`, `notify_parent` | Information gathering, web research, codebase exploration, reading documentation |
 | `coder` | `bash`, `file_read`, `file_write`, `file_edit`, `web_search`, `recall`, `notify_parent` | Code changes, file editing, running commands, build/test tasks |
 | `planner` | `file_read`, `file_list`, `web_search`, `web_fetch`, `recall`, `notify_parent` | Analysis, planning, synthesizing information, reviewing approaches |
+| `investigator` | `bash`, `file_read`, `file_list`, `web_search`, `web_fetch`, `recall`, `notify_parent` | Root-cause analysis: debugging, log forensics, tracing behavior across many files. Shell access is for read-only investigation (grep/find/reading logs); returns a compact root-cause report |
 
 All specialized roles (`researcher`, `coder`, `planner`) include `notify_parent` for mid-run communication with the parent.
 
@@ -97,5 +98,6 @@ Rule of thumb: "Does this task need to know what we've been talking about?" If y
 - Use `subagent_message` to send follow-up instructions to a running subagent.
 - Use `subagent_abort` to cancel a subagent that is no longer needed.
 - Default to spawning subagents for any task that involves web research, multi-file exploration, or independent coding work. Serial execution should be the exception, not the rule.
+- Delegate root-cause investigations ("why is X happening?", debugging, log forensics) to an `investigator` instead of grepping inline. A long investigation done inline floods your own context with file slices and grep output, crowding out the conversation; the investigator does the digging in its own context and returns a compact root-cause report.
 - When a user request has both an information-gathering component and an action component, spawn a researcher immediately rather than doing the research inline yourself.
 - Prefer spawning 2-3 focused subagents over one large general-purpose subagent. Smaller scopes finish faster and fail more gracefully.

package/src/config/bundled-skills/subagent/TOOLS.json

@@ -31,8 +31,14 @@
           },
           "role": {
             "type": "string",
-            "enum": ["general", "researcher", "coder", "planner"],
-            "description": "Agent specialization that controls tool access. 'researcher': read-only (web, files, memory). 'coder': file and bash access. 'planner': read-only analysis. 'general': full access (default). Ignored when fork: true (forks always use general)."
+            "enum": [
+              "general",
+              "researcher",
+              "coder",
+              "planner",
+              "investigator"
+            ],
+            "description": "Agent specialization that controls tool access. 'researcher': read-only (web, files, memory). 'coder': file and bash access. 'planner': read-only analysis. 'investigator': root-cause analysis — debugging, log forensics, tracing behavior across many files; has bash for read-only investigation (grep/find/log inspection) and returns a compact root-cause report. 'general': full access (default). Ignored when fork: true (forks always use general)."
           }
         },
         "required": ["label", "objective"]

package/src/config/call-site-defaults.ts

@@ -7,6 +7,13 @@ type CallSiteDefaultConfig = {
   temperature?: number | null;
   thinking?: { enabled?: boolean; streamThinking?: boolean };
   contextWindow?: { maxInputTokens?: number };
+  /**
+   * Opt the call site out of prompt caching. Set for one-shot call sites
+   * whose prompts never repeat — or repeat slower than the cache TTL — so
+   * each call would pay the cache-write premium without a future read.
+   * Telemetry confirms ~0–5% cache hit rates on these sites.
+   */
+  disableCache?: boolean;
 };
 
 export const CALL_SITE_DEFAULTS: Record<LLMCallSite, CallSiteDefaultConfig> = {
@@ -17,7 +24,7 @@ export const CALL_SITE_DEFAULTS: Record<LLMCallSite, CallSiteDefaultConfig> = {
   patternScan: { profile: "balanced" },
   narrativeRefinement: { profile: "balanced" },
   callAgent: { profile: "balanced" },
-  memoryConsolidation: { profile: "balanced" },
+  memoryConsolidation: { profile: "balanced", disableCache: true },
   identityIntro: { profile: "balanced" },
   emptyStateGreeting: { profile: "balanced" },
 
@@ -32,6 +39,7 @@ export const CALL_SITE_DEFAULTS: Record<LLMCallSite, CallSiteDefaultConfig> = {
     effort: "low",
     thinking: { enabled: false, streamThinking: false },
     temperature: 0,
+    disableCache: true,
   },
   conversationStarters: {
     profile: "balanced",
@@ -47,7 +55,7 @@ export const CALL_SITE_DEFAULTS: Record<LLMCallSite, CallSiteDefaultConfig> = {
   memoryV2Sweep: { profile: "cost-optimized" },
   memoryV2Consolidation: { profile: "balanced" },
   conversationSummarization: { profile: "cost-optimized" },
-  conversationTitle: { profile: "cost-optimized" },
+  conversationTitle: { profile: "cost-optimized", disableCache: true },
   approvalCopy: { profile: "cost-optimized" },
   approvalConversation: { profile: "cost-optimized" },
   trustRuleSuggestion: { profile: "cost-optimized" },
@@ -70,6 +78,7 @@ export const CALL_SITE_DEFAULTS: Record<LLMCallSite, CallSiteDefaultConfig> = {
     profile: "cost-optimized",
     effort: "low",
     thinking: { enabled: false },
+    disableCache: true,
   },
   guardianQuestionCopy: {
     profile: "cost-optimized",
@@ -107,11 +116,13 @@ export const CALL_SITE_DEFAULTS: Record<LLMCallSite, CallSiteDefaultConfig> = {
     effort: "low",
     thinking: { enabled: false },
     temperature: 0.7,
+    disableCache: true,
   },
   homeSuggestedPrompts: {
     profile: "cost-optimized",
     maxTokens: 512,
     effort: "low",
     thinking: { enabled: false },
+    disableCache: true,
   },
 };

package/src/config/feature-flag-registry.json

@@ -75,14 +75,6 @@
       "description": "Control Developer nav visibility in macOS settings",
       "defaultEnabled": false
     },
-    {
-      "id": "system-schedule-toggles",
-      "scope": "assistant",
-      "key": "system-schedule-toggles",
-      "label": "System Schedule Toggles",
-      "description": "Show the Heartbeat pause toggle on the schedules settings page. The toggle only pauses automatic runs; manual Run now remains available.",
-      "defaultEnabled": false
-    },
     {
       "id": "developer-menu-items",
       "scope": "client",
@@ -363,6 +355,14 @@
       "description": "Enable self-hosted assistant configuration.",
       "defaultEnabled": false
     },
+    {
+      "id": "web-remote-ingress",
+      "scope": "assistant",
+      "key": "web-remote-ingress",
+      "label": "Web Remote Ingress",
+      "description": "Serve the web client over a public tunnel and enable browser pairing for self-hosted assistants.",
+      "defaultEnabled": false
+    },
     {
       "id": "settings-sleep-policy",
       "scope": "assistant",
@@ -403,14 +403,6 @@
       "description": "When on, memory-v3 topic-tree retrieval becomes the live injected memory source (suppressing v2 injection). Off by default; only enable after shadow telemetry validates the design.",
       "defaultEnabled": false
     },
-    {
-      "id": "empty-state-dynamic-greetings",
-      "scope": "assistant",
-      "key": "empty-state-dynamic-greetings",
-      "label": "Dynamic Empty-State Greetings",
-      "description": "Enable the empty new-chat screen to refresh cached greeting options via the empty-state greeting LLM call site. When off, the assistant serves workspace-authored greetings or static fallbacks only.",
-      "defaultEnabled": false
-    },
     {
       "id": "self-intro-greeting",
       "scope": "both",