@vellumai/assistant 0.8.10 → 0.8.11-staging.1

package/src/api/events/tool-result.ts

@@ -124,6 +124,15 @@ export const ToolResultEventSchema = z.object({
   approvalReason: z.string().optional(),
   riskThreshold: z.string().optional(),
   activityMetadata: ToolActivityMetadataSchema.optional(),
+  /**
+   * Unix ms when the daemon finished executing the tool. Pairs with
+   * `ToolUseStartEvent.startedAt` so clients can render a final duration that
+   * stays on the daemon's clock, matching the live elapsed-time counter and
+   * avoiding skew between a server-stamped start and a browser-stamped end.
+   * Absent on streams from older daemons; clients fall back to their own
+   * receipt time.
+   */
+  completedAt: z.number().optional(),
 });
 
 export type ToolResultEvent = z.infer<typeof ToolResultEventSchema>;

package/src/api/events/tool-use-start.ts

@@ -25,6 +25,13 @@ export const ToolUseStartEventSchema = z.object({
   toolUseId: z.string().optional(),
   messageId: z.string().optional(),
   conversationId: z.string().optional(),
+  /**
+   * Unix ms when the daemon began executing the tool. Lets clients anchor a
+   * live elapsed-time counter to the server clock instead of the moment the
+   * event was received over SSE. Absent on streams from older daemons that
+   * pre-date this field; clients fall back to their own receipt time.
+   */
+  startedAt: z.number().optional(),
 });
 
 export type ToolUseStartEvent = z.infer<typeof ToolUseStartEventSchema>;

package/src/api/index.ts

@@ -325,6 +325,8 @@ export {
   DictationRequestSchema,
 } from "./requests/dictation.js";
 export {
+  type ConversationAttachmentBlock,
+  ConversationAttachmentBlockSchema,
   type ConversationContentBlock,
   ConversationContentBlockSchema,
   type ConversationMessage,
@@ -339,6 +341,14 @@ export {
   ConversationSlackMessageSchema,
   type ConversationSubagentNotification,
   ConversationSubagentNotificationSchema,
+  type ConversationSurfaceBlock,
+  ConversationSurfaceBlockSchema,
+  type ConversationTextBlock,
+  ConversationTextBlockSchema,
+  type ConversationThinkingBlock,
+  ConversationThinkingBlockSchema,
+  type ConversationToolUseBlock,
+  ConversationToolUseBlockSchema,
   type PendingToolConfirmation,
   PendingToolConfirmationSchema,
 } from "./responses/conversation-message.js";

package/src/api/responses/conversation-message.ts

@@ -276,6 +276,53 @@ export type ConversationSlackMessage = z.infer<
 // Content block (unified ordered content)
 // ---------------------------------------------------------------------------
 
+/** A run of assistant prose. */
+export const ConversationTextBlockSchema = z.object({
+  type: z.literal("text"),
+  text: z.string(),
+});
+export type ConversationTextBlock = z.infer<typeof ConversationTextBlockSchema>;
+
+/** A contiguous model reasoning run with its timing. */
+export const ConversationThinkingBlockSchema = z.object({
+  type: z.literal("thinking"),
+  thinking: z.string(),
+  /** Unix ms when the model began emitting this reasoning block. */
+  startedAt: z.number().optional(),
+  /** Unix ms when this reasoning block completed. */
+  completedAt: z.number().optional(),
+});
+export type ConversationThinkingBlock = z.infer<
+  typeof ConversationThinkingBlockSchema
+>;
+
+/** A tool invocation carrying its paired result (`toolCall.result`). */
+export const ConversationToolUseBlockSchema = z.object({
+  type: z.literal("tool_use"),
+  toolCall: ConversationMessageToolCallSchema,
+});
+export type ConversationToolUseBlock = z.infer<
+  typeof ConversationToolUseBlockSchema
+>;
+
+/** A vellum surface projection (no provider analog). */
+export const ConversationSurfaceBlockSchema = z.object({
+  type: z.literal("surface"),
+  surface: ConversationMessageSurfaceSchema,
+});
+export type ConversationSurfaceBlock = z.infer<
+  typeof ConversationSurfaceBlockSchema
+>;
+
+/** A vellum attachment projection (no provider analog). */
+export const ConversationAttachmentBlockSchema = z.object({
+  type: z.literal("attachment"),
+  attachment: ConversationMessageAttachmentSchema,
+});
+export type ConversationAttachmentBlock = z.infer<
+  typeof ConversationAttachmentBlockSchema
+>;
+
 /**
  * A single ordered content block. `contentBlocks` is the unified, display-ready
  * projection of a message's model-native content — one ordered tagged array so
@@ -300,20 +347,11 @@ export type ConversationSlackMessage = z.infer<
  * it from the positional arrays, so it stays correct once those are retired.
  */
 export const ConversationContentBlockSchema = z.discriminatedUnion("type", [
-  z.object({ type: z.literal("text"), text: z.string() }),
-  z.object({ type: z.literal("thinking"), thinking: z.string() }),
-  z.object({
-    type: z.literal("tool_use"),
-    toolCall: ConversationMessageToolCallSchema,
-  }),
-  z.object({
-    type: z.literal("surface"),
-    surface: ConversationMessageSurfaceSchema,
-  }),
-  z.object({
-    type: z.literal("attachment"),
-    attachment: ConversationMessageAttachmentSchema,
-  }),
+  ConversationTextBlockSchema,
+  ConversationThinkingBlockSchema,
+  ConversationToolUseBlockSchema,
+  ConversationSurfaceBlockSchema,
+  ConversationAttachmentBlockSchema,
 ]);
 export type ConversationContentBlock = z.infer<
   typeof ConversationContentBlockSchema
@@ -350,23 +388,93 @@ export const ConversationMessageSchema = z.object({
    */
   role: z.enum(["user", "assistant"]),
   /**
-   * Flat plain-text body (joined text segments). Redundant with
-   * `textSegments`/`contentOrder` for clients that render from the positional
-   * arrays (web, CLI), but the legacy Swift macOS client reads `content`
-   * directly and drops any history row missing it (its
-   * `HistoryReconstructionService` skips rows with empty text). The serializer
-   * always emits it — do not remove without updating that client.
+   * @deprecated Superseded by `contentBlocks`. Flat plain-text body (joined
+   * text segments). Redundant with `textSegments`/`contentOrder` for clients
+   * that render from the positional arrays (web, CLI), but the legacy Swift
+   * macOS client reads `content` directly and drops any history row missing it
+   * (its `HistoryReconstructionService` skips rows with empty text). The
+   * serializer always emits it — do not remove without updating that client.
    */
-  content: z.string().optional(),
+  content: z
+    .string()
+    .meta({
+      deprecated: true,
+      description:
+        "Deprecated: superseded by contentBlocks. Flat plain-text body (joined text segments).",
+    })
+    .optional(),
   /** Display timestamp as an ISO-8601 string. */
   timestamp: z.string(),
+  /**
+   * Flat list of attachment metadata for the row. Not yet supersedable by
+   * `contentBlocks`: `renderHistoryContent` emits an `attachment` content
+   * block only for file-block refs with an inline placement, so orphan rows
+   * (unmatched ids, count mismatch, no DB rows — see `alignAttachments`) ship
+   * here alone. Kept non-deprecated until `contentBlocks` reaches attachment
+   * parity, so clients that migrate off the positional arrays don't drop those
+   * chips.
+   */
   attachments: z.array(ConversationMessageAttachmentSchema),
-  toolCalls: z.array(ConversationMessageToolCallSchema).optional(),
-  surfaces: z.array(ConversationMessageSurfaceSchema).optional(),
-  textSegments: z.array(z.string()).optional(),
-  thinkingSegments: z.array(z.string()).optional(),
-  /** Positional `"<type>:<index>"` content ordering (e.g. `"text:0"`, `"thinking:1"`). */
-  contentOrder: z.array(z.string()).optional(),
+  /**
+   * @deprecated Superseded by `contentBlocks` (the `tool_use` variant). Flat
+   * list of tool calls for the row.
+   */
+  toolCalls: z
+    .array(ConversationMessageToolCallSchema)
+    .meta({
+      deprecated: true,
+      description:
+        "Deprecated: superseded by contentBlocks (the tool_use variant). Flat list of tool calls.",
+    })
+    .optional(),
+  /**
+   * @deprecated Superseded by `contentBlocks` (the `surface` variant). Flat
+   * list of surfaces for the row.
+   */
+  surfaces: z
+    .array(ConversationMessageSurfaceSchema)
+    .meta({
+      deprecated: true,
+      description:
+        "Deprecated: superseded by contentBlocks (the surface variant). Flat list of surfaces.",
+    })
+    .optional(),
+  /**
+   * @deprecated Superseded by `contentBlocks`. Text split by tool-call
+   * boundaries; positional sibling of `contentOrder`.
+   */
+  textSegments: z
+    .array(z.string())
+    .meta({
+      deprecated: true,
+      description:
+        "Deprecated: superseded by contentBlocks. Text segments split by tool-call boundaries.",
+    })
+    .optional(),
+  /**
+   * @deprecated Superseded by `contentBlocks`. Reasoning text extracted from
+   * thinking blocks; positional sibling of `contentOrder`.
+   */
+  thinkingSegments: z
+    .array(z.string())
+    .meta({
+      deprecated: true,
+      description:
+        "Deprecated: superseded by contentBlocks. Reasoning text extracted from thinking blocks.",
+    })
+    .optional(),
+  /**
+   * @deprecated Superseded by `contentBlocks`. Positional
+   * `"<type>:<index>"` content ordering (e.g. `"text:0"`, `"thinking:1"`).
+   */
+  contentOrder: z
+    .array(z.string())
+    .meta({
+      deprecated: true,
+      description:
+        'Deprecated: superseded by contentBlocks. Positional "<type>:<index>" content ordering (e.g. "text:0", "thinking:1").',
+    })
+    .optional(),
   /**
    * Unified ordered content blocks — the display-ready projection of the
    * row's model-native content. Ships alongside the positional

package/src/api/responses/memory-v3-selection-log.ts

@@ -29,10 +29,10 @@ import { z } from "zod";
 
 /**
  * One selected page in the v3 set. `source` is the lane that surfaced it —
- * the daemon emits `needle`, `dense`, `edge`, or `carry-forward` — but the
- * schema stays a permissive string so a new lane label (or a historical
- * pre-lane row) doesn't break parsing on the FE. `pinned` marks a slug carried
- * forward across turns.
+ * the daemon emits `core`, `hot`, `needle`, `dense`, or `edge` (historical
+ * rows may carry retired labels) — but the schema stays a permissive string
+ * so a new lane label (or a historical pre-lane row) doesn't break parsing on
+ * the FE. `pinned` marks a page the turn was centrally about.
  */
 export const MemoryV3SelectionRowSchema = z.object({
   slug: z.string(),

package/src/approvals/guardian-request-resolvers.ts

@@ -196,6 +196,32 @@ const pendingInteractionResolver: GuardianRequestResolver = {
     // resolveConfirmation() owns pendingInteractions deregistration.
     const userDecision: UserDecision =
       decision.action === "reject" ? "deny" : "allow";
+
+    // Route-owned confirmations (e.g. the ACP spawn/steer approval gate in
+    // acp-routes.ts) carry a `directResolve` and are NOT owned by any
+    // Conversation.prompter, so handleConfirmationResponse below would no-op
+    // and the caller would block until timeout. Resolve them directly, exactly
+    // as the POST /v1/confirm route does (see approval-routes.ts).
+    if (interaction.directResolve) {
+      pendingInteractions.resolve(
+        request.id,
+        userDecision === "allow" ? "approved" : "rejected",
+      );
+      interaction.directResolve(userDecision);
+      log.info(
+        {
+          event: "resolver_tool_approval_applied",
+          requestId: request.id,
+          action: decision.action,
+          conversationId: request.conversationId,
+          toolName: request.toolName,
+          directResolve: true,
+        },
+        "Tool approval resolver: direct-resolve interaction resolved",
+      );
+      return { ok: true, applied: true };
+    }
+
     const conversation = findConversation(interaction.conversationId);
     if (!conversation) {
       return {

package/src/browser-session/backends/host-bridge.ts

@@ -0,0 +1,29 @@
+import type { BrowserBackend, CdpCommand, CdpResult } from "../types.js";
+
+/**
+ * Host-bridge backend for BrowserSessionManager. Wraps a caller-provided
+ * `sendCdp` transport that routes raw CDP commands through the daemon's
+ * HostBrowserProxy to the desktop client's SSE bridge, which executes
+ * them against the user's Chrome via its local remote-debugging port.
+ * Unlike the extension backend, the bridge has no `Vellum.*`
+ * pseudo-method support. The factory in
+ * `assistant/src/tools/browser/cdp-client/factory.ts` constructs one
+ * per tool invocation.
+ */
+export interface HostBridgeBackendDeps {
+  /** Sends a raw CDP command via the desktop SSE bridge and returns the CDP result. */
+  sendCdp(command: CdpCommand, signal?: AbortSignal): Promise<CdpResult>;
+  isAvailable(): boolean;
+  dispose(): void;
+}
+
+export function createHostBridgeBackend(
+  deps: HostBridgeBackendDeps,
+): BrowserBackend {
+  return {
+    kind: "host-bridge",
+    isAvailable: deps.isAvailable,
+    send: deps.sendCdp,
+    dispose: deps.dispose,
+  };
+}

package/src/browser-session/index.ts

@@ -21,6 +21,7 @@
  */
 export * from "./backends/cdp-inspect.js";
 export * from "./backends/extension.js";
+export * from "./backends/host-bridge.js";
 export * from "./backends/local.js";
 export * from "./events.js";
 export * from "./manager.js";

package/src/browser-session/types.ts

@@ -1,4 +1,8 @@
-export type BrowserBackendKind = "extension" | "local" | "cdp-inspect";
+export type BrowserBackendKind =
+  | "extension"
+  | "local"
+  | "cdp-inspect"
+  | "host-bridge";
 
 export interface CdpCommand {
   method: string;

package/src/cli/commands/__tests__/schedules.test.ts

@@ -151,7 +151,8 @@ describe("schedules list", () => {
             retryCount: 0,
             maxRetries: 3,
             retryBackoffMs: 60_000,
-            description: "Every 30 minutes",
+            description: "Authored heartbeat check",
+            cadenceDescription: "Every 30 minutes",
             mode: "execute",
             status: "active",
             routingIntent: "all_channels",
@@ -175,6 +176,8 @@ describe("schedules list", () => {
         expect.objectContaining({
           id: "schedule-1",
           name: "Heartbeat",
+          description: "Authored heartbeat check",
+          cadenceDescription: "Every 30 minutes",
         }),
       ],
     });
@@ -201,7 +204,8 @@ describe("schedules list", () => {
             retryCount: 0,
             maxRetries: 3,
             retryBackoffMs: 60_000,
-            description: "Every 30 minutes",
+            description: "Authored heartbeat check",
+            cadenceDescription: "Every 30 minutes",
             mode: "execute",
             status: "active",
             routingIntent: "all_channels",
@@ -219,6 +223,7 @@ describe("schedules list", () => {
     expect(logLines.join("\n")).toContain("ID");
     expect(logLines.join("\n")).toContain("Heartbeat");
     expect(logLines.join("\n")).toContain("Every 30 minutes (UTC)");
+    expect(logLines.join("\n")).not.toContain("Authored heartbeat check");
   });
 
   test("sets exit code on IPC failure", async () => {
@@ -376,6 +381,8 @@ describe("schedules create", () => {
       "Heartbeat",
       "--expression",
       "*/30 * * * *",
+      "--description",
+      "Checks service heartbeat",
       "--message",
       "run heartbeat",
     ]);
@@ -388,6 +395,7 @@ describe("schedules create", () => {
           body: {
             name: "Heartbeat",
             expression: "*/30 * * * *",
+            description: "Checks service heartbeat",
             message: "run heartbeat",
             enabled: true,
           },
@@ -397,6 +405,39 @@ describe("schedules create", () => {
     expect(logLines).toEqual(["Created schedule: Heartbeat"]);
   });
 
+  test("requires a description", async () => {
+    const { exitCode } = await runCommand([
+      "schedules",
+      "create",
+      "Heartbeat",
+      "--expression",
+      "*/30 * * * *",
+      "--message",
+      "run heartbeat",
+    ]);
+
+    expect(exitCode).not.toBe(0);
+    expect(ipcCalls).toEqual([]);
+  });
+
+  test("rejects an empty description", async () => {
+    const { exitCode } = await runCommand([
+      "schedules",
+      "create",
+      "Heartbeat",
+      "--expression",
+      "*/30 * * * *",
+      "--description",
+      "   ",
+      "--message",
+      "run heartbeat",
+    ]);
+
+    expect(exitCode).not.toBe(0);
+    expect(ipcCalls).toEqual([]);
+    expect(errorLines).toEqual(["description is required"]);
+  });
+
   test("passes --timezone through to the request body", async () => {
     mockIpcResult = { ok: true, result: { schedules: [] } };
 
@@ -408,6 +449,8 @@ describe("schedules create", () => {
       "0 9 * * MON-FRI",
       "--message",
       "morning summary",
+      "--description",
+      "Summarizes weekday mornings",
       "--timezone",
       "America/New_York",
     ]);
@@ -421,6 +464,7 @@ describe("schedules create", () => {
             name: "Morning",
             expression: "0 9 * * MON-FRI",
             message: "morning summary",
+            description: "Summarizes weekday mornings",
             enabled: true,
             timezone: "America/New_York",
           },
@@ -440,6 +484,8 @@ describe("schedules create", () => {
       "0 0 * * *",
       "--message",
       "placeholder",
+      "--description",
+      "Draft schedule",
       "--no-enabled",
     ]);
 
@@ -452,6 +498,7 @@ describe("schedules create", () => {
             name: "Drafted",
             expression: "0 0 * * *",
             message: "placeholder",
+            description: "Draft schedule",
             enabled: false,
           },
         },
@@ -480,7 +527,8 @@ describe("schedules create", () => {
             retryCount: 0,
             maxRetries: 3,
             retryBackoffMs: 60_000,
-            description: "Every 30 minutes",
+            description: "Checks service heartbeat",
+            cadenceDescription: "Every 30 minutes",
             mode: "execute",
             status: "active",
             routingIntent: "all_channels",
@@ -500,12 +548,20 @@ describe("schedules create", () => {
       "*/30 * * * *",
       "--message",
       "run heartbeat",
+      "--description",
+      "Checks service heartbeat",
       "--json",
     ]);
 
     expect(exitCode).toBe(0);
     expect(JSON.parse(stdout)).toEqual({
-      schedules: [expect.objectContaining({ id: "new-schedule-id" })],
+      schedules: [
+        expect.objectContaining({
+          id: "new-schedule-id",
+          description: "Checks service heartbeat",
+          cadenceDescription: "Every 30 minutes",
+        }),
+      ],
     });
     expect(logLines).toEqual([]);
   });
@@ -524,6 +580,8 @@ describe("schedules create", () => {
       "not-a-cron",
       "--message",
       "noop",
+      "--description",
+      "Invalid test schedule",
     ]);
 
     expect(exitCode).toBe(10);

package/src/cli/commands/__tests__/skills.test.ts

@@ -146,6 +146,59 @@ describe("skills list", () => {
     ).toEqual({});
   });
 
+  test("--json derives source from owner for plugin-resident skills", async () => {
+    /**
+     * Plugin-resident skills are mapped to kind:bundled/origin:vellum, so
+     * their attribution lives on `owner`. The CLI must surface that as
+     * `plugin:<id>` instead of collapsing to "bundled".
+     */
+
+    // GIVEN a plugin-resident skill (owner set) and a plain bundled skill
+    mockIpcResults = [
+      {
+        ok: true,
+        result: {
+          skills: [
+            {
+              id: "caveman",
+              name: "Caveman",
+              description: "Ultra-compressed communication mode",
+              origin: "vellum",
+              kind: "bundled",
+              status: "enabled",
+              owner: { kind: "plugin", id: "caveman" },
+            },
+            {
+              id: "weather",
+              name: "Weather",
+              description: "Get weather",
+              origin: "vellum",
+              kind: "bundled",
+              status: "enabled",
+            },
+          ],
+        },
+      },
+    ];
+
+    // WHEN listing skills as JSON
+    const { stdout } = await runCommand(["skills", "list", "--json"]);
+
+    // THEN the plugin skill's source is `plugin:<id>` and owner is preserved
+    const parsed = JSON.parse(stdout) as {
+      ok: boolean;
+      skills: Array<{ id: string; source: string; owner?: unknown }>;
+    };
+    const caveman = parsed.skills.find((s) => s.id === "caveman");
+    const weather = parsed.skills.find((s) => s.id === "weather");
+    expect(caveman?.source).toBe("plugin:caveman");
+    expect(caveman?.owner).toEqual({ kind: "plugin", id: "caveman" });
+
+    // AND a bundled skill with no owner keeps the "bundled" source label
+    expect(weather?.source).toBe("bundled");
+    expect(weather?.owner).toBeUndefined();
+  });
+
   test("IPC failure sets exitCode 1", async () => {
     mockIpcResults = [{ ok: false, error: "Connection refused" }];
 

package/src/cli/commands/channel-verification-sessions.ts

@@ -79,7 +79,7 @@ export function registerChannelVerificationSessionsCommand(
         "after",
         `
 Verification sessions are used to verify guardian bindings and trusted
-contacts across channels (telegram, phone, slack). Three flows exist:
+contacts across channels (telegram, phone, slack, email). Three flows exist:
 
   1. Inbound challenge — the assistant generates a secret code and waits
      for the guardian to send it back on the channel. Used when the
@@ -107,10 +107,10 @@ Examples:
       cvs
         .command("create")
         .description("Create a new verification session")
-        .option("--channel <channel>", "Channel type (telegram, phone, slack)")
+        .option("--channel <channel>", "Channel type (telegram, phone, slack, email)")
         .option(
           "--destination <destination>",
-          "Destination address for outbound verification (handle, phone number, or user ID)",
+          "Destination address for outbound verification (handle, phone number, user ID, or email address)",
         )
         .option("--rebind", "Replace existing guardian binding")
         .option(
@@ -140,7 +140,7 @@ Routes between three creation modes based on the provided options:
 
   2. Outbound: --channel <ch> --destination <dest>
      Sends a verification code to the given destination. Supports telegram
-     (handle or chat ID), phone (E.164 number), and slack (user ID).
+     (handle or chat ID), phone (E.164 number), slack (user ID), and email.
      Use --rebind to replace an existing guardian binding.
 
   3. Inbound: --channel <ch> (no --destination)
@@ -240,7 +240,7 @@ Examples:
         )
         .requiredOption(
           "--channel <channel>",
-          "Channel type (telegram, phone, slack)",
+          "Channel type (telegram, phone, slack, email)",
         )
         .option(
           "--origin-conversation-id <id>",
@@ -290,7 +290,7 @@ Examples:
         .description("Cancel all active verification sessions for a channel")
         .requiredOption(
           "--channel <channel>",
-          "Channel type (telegram, phone, slack)",
+          "Channel type (telegram, phone, slack, email)",
         )
         .addHelpText(
           "after",

package/src/cli/commands/inference-providers.ts

@@ -16,8 +16,6 @@
 
 import type { Command } from "commander";
 
-import { isAssistantFeatureFlagEnabled } from "../../config/assistant-feature-flags.js";
-import { getConfig } from "../../config/loader.js";
 import { cliIpcCall } from "../../ipc/cli-client.js";
 import type { OAuth2Config } from "../../security/oauth2.js";
 import { startOAuth2Flow } from "../../security/oauth2.js";
@@ -343,12 +341,6 @@ function attachLoginChatgptSubcommand(providers: Command): void {
     .description("Authenticate with ChatGPT via browser OAuth flow")
     .option("--json", "Output as JSON")
     .action(async (opts: { json?: boolean }) => {
-      const config = getConfig();
-      if (!isAssistantFeatureFlagEnabled("chatgpt-subscription-auth", config)) {
-        writeCliError("This feature is not yet available", opts.json);
-        return;
-      }
-
       try {
         // Step 1: Run browser-based PKCE OAuth flow
         process.stdout.write("Opening browser for ChatGPT authentication...\n");

package/src/cli/commands/plugins.ts

@@ -55,7 +55,7 @@ Examples:
       plugins
         .command("install <name>")
         .description(
-          "Install a plugin from vellum-ai/vellum-assistant/experimental/plugins/<name>",
+          "Install a plugin from the curated plugins/marketplace.json catalog",
         )
         .option("--force", "Overwrite an existing install")
         .option(
@@ -150,7 +150,7 @@ Examples:
       plugins
         .command("search <query>")
         .description(
-          "Search vellum-ai/vellum-assistant/experimental/plugins for plugin names matching <query> (case-insensitive regex)",
+          "Search the plugins/marketplace.json catalog for plugin names matching <query> (case-insensitive regex)",
         )
         .option("--json", "Emit machine-readable JSON instead of a table")
         .action(async (query: string, opts: { json?: boolean }) => {