@vellumai/assistant 0.11.3 → 0.11.4-dev.202608190019.b94dbf2

package/src/cli/commands/memory/memory-v3.ts

@@ -25,6 +25,7 @@ import type {
   MemoryEvalTallyResult,
 } from "../../../plugins/defaults/memory/src/memory-eval-routes.js";
 import type {
+  GateStatsResponse,
   MemoryV3BackfillSectionsResult,
   MemoryV3RebuildIndexResult,
 } from "../../../plugins/defaults/memory/src/memory-v3-routes.js";
@@ -52,6 +53,36 @@ function collectRepeatable(value: string, acc: string[]): string[] {
   return [...acc, value];
 }
 
+/** Render gate-stats as a human-readable table. */
+function formatGateStats(r: GateStatsResponse): string {
+  const lines: string[] = [
+    `Gate-stats (last ${r.lookbackDays} day${r.lookbackDays === 1 ? "" : "s"}, ${r.totalRuns} run${r.totalRuns === 1 ? "" : "s"})`,
+    "",
+    `Bucket     Total  Scored  Passed  ScoredPassRate  Top reasons`,
+  ];
+  for (const b of r.buckets) {
+    const rate =
+      b.scoredPassRate !== null
+        ? `${(b.scoredPassRate * 100).toFixed(1)}%`
+        : "n/a";
+    const topReasons = Object.entries(b.reasons)
+      .sort(([, a], [, bv]) => (bv as number) - (a as number))
+      .slice(0, 3)
+      .map(([k, v]) => `${k}: ${v}`)
+      .join(", ");
+    lines.push(
+      `${b.pageCountRange.padEnd(10)} ${String(b.total).padStart(5)}  ${String(b.scored).padStart(6)}  ${String(b.passed).padStart(6)}  ${rate.padStart(14)}  ${topReasons}`,
+    );
+  }
+  if (r.unknownPageCount.total > 0) {
+    lines.push("");
+    lines.push(
+      `Unknown page count: ${r.unknownPageCount.total} total, ${r.unknownPageCount.passed} passed`,
+    );
+  }
+  return lines.join("\n");
+}
+
 /**
  * Read the `turn` ids from a prior run's `key.json` or `packets.json` (both are
  * arrays of objects carrying a `turn` field). Used to pin `--turns-file` so a
@@ -271,4 +302,37 @@ export function registerMemoryV3Command(memory: Command): void {
       log.info(formatTally(payload));
     },
   );
+
+  // ── gate-stats ────────────────────────────────────────────────────────
+  // Reads the telemetry DB directly — no daemon required.
+
+  subcommand(v3, "gate-stats").action(
+    async (opts: { lookbackDays: string; json?: boolean }) => {
+      const lookbackDays = Number(opts.lookbackDays);
+      const [{ handleMemoryV3GateStats }, { getTelemetrySqlite }] =
+        await Promise.all([
+          import("../../../plugins/defaults/memory/src/memory-v3-routes.js"),
+          import("../../../persistence/db-connection.js"),
+        ]);
+      let payload;
+      try {
+        payload = handleMemoryV3GateStats(
+          Number.isFinite(lookbackDays) ? lookbackDays : 30,
+          getTelemetrySqlite(),
+        );
+      } catch (err) {
+        log.error(
+          "Failed to read gate stats: %s",
+          err instanceof Error ? err.message : String(err),
+        );
+        process.exitCode = 1;
+        return;
+      }
+      if (opts.json === true) {
+        log.info(JSON.stringify(payload, null, 2));
+        return;
+      }
+      log.info(formatGateStats(payload));
+    },
+  );
 }

package/src/cli/commands/memory/memory-validate.ts

@@ -0,0 +1,18 @@
+/**
+ * `assistant memory validate`: the read-only concept-page diagnostic.
+ *
+ * The report covers the concept-page substrate, which is the same store
+ * under memory v2 and v3, so the command is tier-agnostic. The report
+ * function lives in `memory-v2.ts` (the host file already allowed to read
+ * the memory plugin's route types) and is also registered there as
+ * `assistant memory v2 validate` for as long as that namespace exists.
+ */
+
+import type { Command } from "commander";
+
+import { subcommand } from "../../lib/cli-command-help.js";
+import { runMemoryValidate } from "./memory-v2.js";
+
+export function registerMemoryValidateCommand(memory: Command): void {
+  subcommand(memory, "validate").action(runMemoryValidate);
+}

package/src/cli/commands/plugins.ts

@@ -15,6 +15,7 @@ import { cliIpcCall } from "../../ipc/cli-client.js";
 import { stripAnsiAndControlChars } from "../../util/ansi.js";
 import { getWorkspacePluginsDir } from "../../util/platform.js";
 import { truncate } from "../../util/truncate.js";
+import { resolveBundledCliModule } from "../bundled-modules.js";
 import { yellow } from "../lib/cli-colors.js";
 import { applyCommandHelp, subcommand } from "../lib/cli-command-help.js";
 import { confirmPrompt } from "../lib/confirm-prompt.js";
@@ -61,64 +62,112 @@ const loadModule = createRequire(import.meta.url);
 /** Lazy accessors: each getter loads its implementation module on first use. */
 const libs = {
   get catalogCache() {
-    return loadModule(
-      "../lib/plugin-catalog-cache.js",
-    ) as typeof import("../lib/plugin-catalog-cache.js");
+    return resolveBundledCliModule(
+      "pluginCatalogCache",
+      () =>
+        loadModule(
+          "../lib/plugin-catalog-cache.js",
+        ) as typeof import("../lib/plugin-catalog-cache.js"),
+    );
   },
   get catalogLocal() {
-    return loadModule(
-      "../lib/plugin-catalog-local.js",
-    ) as typeof import("../lib/plugin-catalog-local.js");
+    return resolveBundledCliModule(
+      "pluginCatalogLocal",
+      () =>
+        loadModule(
+          "../lib/plugin-catalog-local.js",
+        ) as typeof import("../lib/plugin-catalog-local.js"),
+    );
   },
   get diff() {
-    return loadModule(
-      "../lib/diff-plugin.js",
-    ) as typeof import("../lib/diff-plugin.js");
+    return resolveBundledCliModule(
+      "pluginDiff",
+      () =>
+        loadModule(
+          "../lib/diff-plugin.js",
+        ) as typeof import("../lib/diff-plugin.js"),
+    );
   },
   get inspect() {
-    return loadModule(
-      "../lib/inspect-plugin.js",
-    ) as typeof import("../lib/inspect-plugin.js");
+    return resolveBundledCliModule(
+      "pluginInspect",
+      () =>
+        loadModule(
+          "../lib/inspect-plugin.js",
+        ) as typeof import("../lib/inspect-plugin.js"),
+    );
   },
   get installGitHub() {
-    return loadModule(
-      "../lib/install-from-github.js",
-    ) as typeof import("../lib/install-from-github.js");
+    return resolveBundledCliModule(
+      "pluginInstallGitHub",
+      () =>
+        loadModule(
+          "../lib/install-from-github.js",
+        ) as typeof import("../lib/install-from-github.js"),
+    );
   },
   get installPlatform() {
-    return loadModule(
-      "../lib/install-from-platform.js",
-    ) as typeof import("../lib/install-from-platform.js");
+    return resolveBundledCliModule(
+      "pluginInstallPlatform",
+      () =>
+        loadModule(
+          "../lib/install-from-platform.js",
+        ) as typeof import("../lib/install-from-platform.js"),
+    );
   },
   get installed() {
-    return loadModule(
-      "../lib/list-installed-plugins.js",
-    ) as typeof import("../lib/list-installed-plugins.js");
+    return resolveBundledCliModule(
+      "pluginInstalled",
+      () =>
+        loadModule(
+          "../lib/list-installed-plugins.js",
+        ) as typeof import("../lib/list-installed-plugins.js"),
+    );
   },
   get pinHistory() {
-    return loadModule(
-      "../lib/plugin-pin-history.js",
-    ) as typeof import("../lib/plugin-pin-history.js");
+    return resolveBundledCliModule(
+      "pluginPinHistory",
+      () =>
+        loadModule(
+          "../lib/plugin-pin-history.js",
+        ) as typeof import("../lib/plugin-pin-history.js"),
+    );
   },
   get search() {
-    return loadModule(
-      "../lib/search-plugins.js",
-    ) as typeof import("../lib/search-plugins.js");
+    return resolveBundledCliModule(
+      "pluginSearch",
+      () =>
+        loadModule(
+          "../lib/search-plugins.js",
+        ) as typeof import("../lib/search-plugins.js"),
+    );
   },
   get surfaces() {
-    return loadModule(
-      "../lib/plugin-surfaces.js",
-    ) as typeof import("../lib/plugin-surfaces.js");
+    return resolveBundledCliModule(
+      "pluginSurfaces",
+      () =>
+        loadModule(
+          "../lib/plugin-surfaces.js",
+        ) as typeof import("../lib/plugin-surfaces.js"),
+    );
   },
   get uninstall() {
-    return loadModule(
-      "../lib/uninstall-plugin.js",
-    ) as typeof import("../lib/uninstall-plugin.js");
+    return resolveBundledCliModule(
+      "pluginUninstall",
+      () =>
+        loadModule(
+          "../lib/uninstall-plugin.js",
+        ) as typeof import("../lib/uninstall-plugin.js"),
+    );
   },
   get upgrade() {
-    return loadModule(
-      "../lib/upgrade-plugin.js",
-    ) as typeof import("../lib/upgrade-plugin.js");
+    return resolveBundledCliModule(
+      "pluginUpgrade",
+      () =>
+        loadModule(
+          "../lib/upgrade-plugin.js",
+        ) as typeof import("../lib/upgrade-plugin.js"),
+    );
   },
 };
 

package/src/cli/commands/schedules.ts

@@ -39,9 +39,39 @@ interface ScheduleRecord {
   wakeConversationId: string | null;
   sourceKey: string | null;
   userEnabled: boolean | null;
+  disarmReason: string | null;
   isOneShot: boolean;
 }
 
+/** Plain-language copy for each `disarmReason` the daemon sends. */
+const DISARM_REASON_TEXT: Record<string, string> = {
+  user_disabled: "turned off by you",
+  plugin_removed: "plugin removed",
+  plugin_disabled: "plugin disabled",
+  declaration_removed: "removed from plugin",
+  declaration_disabled: "paused by plugin",
+};
+
+/**
+ * Why a schedule is off, when the daemon knows. An off row with no reason (an
+ * imperative schedule, or a plugin row from a daemon that predates the field)
+ * reads as plain "disabled".
+ */
+function describeDisarmReason(schedule: ScheduleRecord): string | null {
+  if (schedule.enabled || !schedule.disarmReason) {
+    return null;
+  }
+  return DISARM_REASON_TEXT[schedule.disarmReason] ?? null;
+}
+
+function formatEnabledCell(schedule: ScheduleRecord): string {
+  if (schedule.enabled) {
+    return "enabled";
+  }
+  const reason = describeDisarmReason(schedule);
+  return reason ? `off (${reason})` : "disabled";
+}
+
 interface ListSchedulesResponse {
   schedules: ScheduleRecord[];
 }
@@ -116,7 +146,7 @@ export function registerSchedulesCommand(program: Command): void {
           const rows = entries.map((schedule) => ({
             id: schedule.id,
             name: schedule.name,
-            enabled: schedule.enabled ? "enabled" : "disabled",
+            enabled: formatEnabledCell(schedule),
             mode: schedule.mode,
             source: describeScheduleSource(schedule.sourceKey) ?? "",
             schedule: describeSchedule(schedule),
@@ -247,6 +277,10 @@ export function registerSchedulesCommand(program: Command): void {
             ["Source conversation", schedule.createdFromConversationId ?? "—"],
             ["Plugin", describeScheduleSource(schedule.sourceKey) ?? "-"],
           ];
+          const disarmReason = describeDisarmReason(schedule);
+          if (disarmReason) {
+            fields.push(["Paused", disarmReason]);
+          }
           const labelWidth = Math.max(...fields.map(([label]) => label.length));
           for (const [label, value] of fields) {
             log.info(`${`${label}:`.padEnd(labelWidth + 2)}${value}`);

package/src/cli/commands/stt.help.ts

@@ -1,7 +1,31 @@
-/** Declarative help for the `assistant stt` command. */
+/**
+ * Declarative help for the `assistant stt` command.
+ *
+ * The advertised provider list is derived from the STT provider catalog, the
+ * single source of truth for which providers exist and which boundaries they
+ * serve, so the help cannot drift from what the daemon actually accepts.
+ */
 
+// provider-catalog is an execution-free data leaf (a literal map behind
+// type-only imports, no adapter or credential graph), consumed synchronously
+// to derive this module's constant. Pure data from pure data, so a lazy
+// `import()` has nothing to defer.
+// eslint-disable-next-line cli/no-daemon-internals
+import {
+  listProviderIds,
+  supportsBoundary,
+} from "../../providers/speech-to-text/provider-catalog.js";
 import type { CliCommandHelp } from "../lib/cli-command-help.js";
 
+/**
+ * `stt transcribe` runs the `daemon-batch` boundary, so streaming-only
+ * providers are omitted: naming one would advertise a configuration that
+ * fails on every file.
+ */
+const batchProviders = listProviderIds()
+  .filter((id) => supportsBoundary(id, "daemon-batch"))
+  .join(", ");
+
 export const sttHelp: CliCommandHelp = {
   name: "stt",
   description: "Speech-to-text operations",
@@ -11,7 +35,8 @@ audio and video files. The provider is set via:
 
   $ assistant config set services.stt.provider <provider>
 
-Supported providers: openai-whisper, deepgram, google-gemini, xai.
+Supported providers: ${batchProviders}.
+Streaming-only providers serve live speech and cannot transcribe files.
 
 Examples:
   $ assistant stt transcribe --file /path/to/meeting.wav

package/src/cli/commands/trust.ts

@@ -5,6 +5,7 @@
  * IPC route (`trust_rules_list`).
  */
 
+import type { TrustRulesListIpcResponse } from "@vellumai/gateway-client";
 import type { Command } from "commander";
 
 import { cliIpcCall } from "../../ipc/cli-client.js";
@@ -13,18 +14,6 @@ import { registerCommand } from "../lib/register-command.js";
 import { log } from "../logger.js";
 import { trustHelp } from "./trust.help.js";
 
-// -- Types --------------------------------------------------------------------
-
-interface TrustRule {
-  id: string;
-  tool: string;
-  pattern: string;
-  risk: string;
-  origin: string;
-  userModified: boolean;
-  updatedAt: string;
-}
-
 // -- Registration -------------------------------------------------------------
 
 export function registerTrustCommand(program: Command): void {
@@ -44,7 +33,7 @@ export function registerTrustCommand(program: Command): void {
             ...(opts.tool ? { tool: opts.tool } : {}),
           };
 
-          const result = await cliIpcCall<{ rules: TrustRule[] }>(
+          const result = await cliIpcCall<TrustRulesListIpcResponse>(
             "trust_rules_list",
             { body: params },
           );
@@ -86,7 +75,7 @@ export function registerTrustCommand(program: Command): void {
             "MODIFIED",
           ];
 
-          const rows: string[][] = rules.map((r: TrustRule) => [
+          const rows: string[][] = rules.map((r) => [
             r.id.slice(0, 16),
             r.tool,
             r.pattern,

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

@@ -32,6 +32,7 @@ import { computeFingerprint } from "../plugin-fingerprint.js";
 import { PluginNotInstalledError } from "../uninstall-plugin.js";
 import {
   PluginMergeBaselineError,
+  PluginNotCuratedError,
   PluginNotUpgradableError,
   upgradePlugin,
 } from "../upgrade-plugin.js";
@@ -574,6 +575,44 @@ describe("upgradePlugin — direct GitHub-URL installs", () => {
     expect(calls[0]?.[0]).toBe("ls-remote");
   });
 
+  test("marketplaceOnly refuses the direct path instead of following the ref", async () => {
+    // GIVEN a direct install tracking `main` at SHA_A, absent from the
+    // marketplace, whose branch has advanced to SHA_B
+    installCopy(pluginsDir, "level-up", { commit: SHA_A, ref: "main" });
+    const fetch = makeFetch({ manifest: undefined });
+    const calls: string[][] = [];
+    const runGit = directGitRunner({ main: SHA_B }, SHA_B, { calls });
+
+    // WHEN a caller that only accepts a curated pin asks for the upgrade
+    const upgrade = upgradePlugin(
+      { name: "level-up", marketplaceOnly: true },
+      { fetch, runGit, workspacePluginsDir: pluginsDir },
+    );
+
+    // THEN it is refused, and the mutable ref is never even resolved
+    await expect(upgrade).rejects.toThrow(PluginNotCuratedError);
+    expect(calls).toEqual([]);
+    // AND the install stays exactly where it was
+    expect(sidecarCommit(pluginsDir, "level-up")).toBe(SHA_A);
+  });
+
+  test("marketplaceOnly still upgrades a plugin the catalog claims", async () => {
+    // GIVEN an install the marketplace pins at SHA_B
+    installCopy(pluginsDir, "level-up", { commit: SHA_A });
+    const fetch = makeFetch({ manifest: manifestWith("level-up", SHA_B) });
+    const runGit = fakeGitRunner(SHA_B);
+
+    // WHEN the same curated-only caller asks for the upgrade
+    const result = await upgradePlugin(
+      { name: "level-up", marketplaceOnly: true },
+      { fetch, runGit, workspacePluginsDir: pluginsDir },
+    );
+
+    // THEN the flag is inert: the curated pin is taken as usual
+    expect(result.outcome).toBe("upgraded");
+    expect(result.toCommit).toBe(SHA_B);
+  });
+
   test("is a no-op when the recorded branch still points at the installed commit", async () => {
     // GIVEN a direct install tracking `main` at SHA_A
     installCopy(pluginsDir, "level-up", { commit: SHA_A, ref: "main" });

package/src/cli/lib/bundled-marketplace.json

@@ -232,7 +232,7 @@
       "source": {
         "source": "github",
         "repo": "vellum-ai/level-up",
-        "ref": "d3cbb50f8aba1f8320cd2d59ea3a85d0a4e9210b"
+        "ref": "4357028acc339c6d6f718d5d6ab279ebf198673b"
       },
       "description": "Surfaces a first-class \"Level Up\" diff card whenever the assistant edits its own skills or plugins, so you can see how it improved itself after the fact.",
       "category": "developer",
@@ -422,6 +422,19 @@
       "license": "MIT",
       "icon": "✈️"
     },
+    {
+      "name": "unabyss",
+      "source": {
+        "source": "github",
+        "repo": "Unabyss/unabyss-vellum",
+        "ref": "9f0bb0753dad09dace8578e242961bc2da912af3"
+      },
+      "description": "Personal and company context from Unabyss, available to your agent through the Unabyss MCP server.",
+      "category": "memory",
+      "homepage": "https://unabyss.com",
+      "license": "MIT",
+      "icon": "🌊"
+    },
     {
       "name": "vellum-client-qa",
       "source": {

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

@@ -17,6 +17,11 @@
  * verbatim, with no curated adapter overlay, exactly as the original untrusted
  * install was (see {@link directUpgrade}).
  *
+ * Because that target is a mutable ref, taking it means running whatever
+ * upstream pushed since, which is a choice only a human should make. A caller
+ * with nobody in the loop passes `marketplaceOnly` to rule it out: the direct
+ * path then throws {@link PluginNotCuratedError} instead of advancing.
+ *
  * 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.
@@ -114,6 +119,20 @@ export interface UpgradePluginOptions {
    * {@link DEFAULT_PLUGIN_UPGRADE_STRATEGY}.
    */
   readonly strategy?: PluginUpgradeStrategy;
+  /**
+   * Refuse to advance an install the marketplace does not claim, instead of
+   * falling back to {@link directUpgrade}.
+   *
+   * A direct install's upgrade target is a mutable upstream ref, so taking it
+   * means fetching and executing whatever was pushed since. Callers with
+   * nobody in the loop (the unattended auto-update sweep) set this so that
+   * outcome is impossible for them, and it is enforced here rather than by the
+   * caller's own pre-check: the catalog is fetched again inside this call, so
+   * an entry that disappears in between would otherwise silently reroute a
+   * curated upgrade into a direct one. Defaults to false, which is what an
+   * interactive `assistant plugins upgrade` wants.
+   */
+  readonly marketplaceOnly?: boolean;
 }
 
 /** Dependencies injected by the caller. */
@@ -208,6 +227,23 @@ export class PluginNotUpgradableError extends Error {
   }
 }
 
+/**
+ * A `marketplaceOnly` upgrade was requested for an install the marketplace does
+ * not claim, so the only revision available is a mutable upstream ref the
+ * caller refuses to take.
+ *
+ * Distinct from {@link PluginNotUpgradableError}: the install *can* be
+ * upgraded, just not without a human choosing to accept unreviewed code.
+ */
+export class PluginNotCuratedError extends Error {
+  constructor(readonly pluginName: string) {
+    super(
+      `Plugin "${pluginName}" cannot be upgraded automatically: it has no marketplace entry, so its only upgrade target is a mutable upstream ref. Run 'assistant plugins upgrade ${pluginName}' to move it deliberately.`,
+    );
+    this.name = "PluginNotCuratedError";
+  }
+}
+
 /**
  * A merge strategy (`ours`/`theirs`) was requested but the install-time
  * baseline needed for a three-way merge cannot be reconstructed.
@@ -244,6 +280,8 @@ function pluginTarget(name: string, deps: UpgradePluginDeps): string {
  * Throws {@link PluginNotInstalledError} when no copy is installed,
  * {@link PluginNotUpgradableError} when the install is neither in the
  * marketplace nor carries a recorded GitHub source to advance,
+ * {@link PluginNotCuratedError} when `marketplaceOnly` was requested for an
+ * install the marketplace does not claim,
  * {@link PluginMergeBaselineError} when a merge strategy is requested but the
  * install-time baseline cannot be reconstructed,
  * {@link PluginSourceUnavailableError} when the marketplace catalog or the
@@ -302,6 +340,10 @@ export async function upgradePlugin(
           "it has no marketplace entry and no installed copy to upgrade",
         );
       }
+      if (opts.marketplaceOnly) {
+        // The caller only accepts a curated pin, and this install has none.
+        throw new PluginNotCuratedError(name);
+      }
       return directUpgrade({ name, local, dryRun, strategy }, deps);
     }
     case "remote-unavailable":