@vellumai/assistant 0.8.0 → 0.8.1

package/src/home/emit-feed-event.ts

@@ -1,169 +0,0 @@
-/**
- * Background-job → home feed event helper.
- *
- * The "force-write, not taught-write" entry point for the activity
- * log. Every background job that wants to surface something on the
- * Home page calls `emitFeedEvent({ source, title, summary, ... })`
- * at the end of its completion path — no LLM involved, no prompt
- * instruction, just a deterministic side effect. This keeps the
- * "what got surfaced" question grep-able to a single symbol.
- *
- * Opinionated defaults for action items:
- *
- *   - `type` is hard-coded to `"action"` — this helper is specifically
- *     for the activity log. Nudges / digests / threads continue to
- *     go through `writeAssistantFeedItem` or platform baseline
- *     generators.
- *   - `author` is hard-coded to `"assistant"` so hybrid authoring
- *     resolution treats these as assistant-produced (platform
- *     defaults can never overwrite them).
- *   - `source` is REQUIRED — actions always have an origin (gmail,
- *     slack, calendar, assistant). The per-source volume cap in
- *     `feed-writer.ts` depends on this.
- *   - No default `expiresAt`. Action items persist until the user
- *     dismisses them. Callers that want auto-expiry pass `expiresAt`
- *     explicitly.
- *   - Optional `dedupKey` — when set, the helper derives a
- *     deterministic id so a second emit for the same logical event
- *     (e.g. the same background job running twice on the same
- *     signal) updates the existing entry in place instead of
- *     appending a duplicate. When absent, a fresh `randomUUID` is
- *     used and every call produces a new entry.
- *
- * Persistence goes through `appendFeedItem`, inheriting its
- * warn-log-on-failure contract — callers never need a try/catch.
- * Schema validation runs at build time so a malformed call throws
- * loudly at the source rather than silently corrupting the file.
- */
-
-import { randomUUID } from "node:crypto";
-
-import {
-  type FeedAction,
-  type FeedItem,
-  type FeedItemDetailPanel,
-  feedItemSchema,
-  type FeedItemSource,
-  type FeedItemUrgency,
-} from "./feed-types.js";
-import { appendFeedItem } from "./feed-writer.js";
-
-/**
- * Default priority for background-job action items. Sits below the
- * assistant nudge default (60) so an explicit nudge from
- * `writeAssistantFeedItem` surfaces above routine activity log
- * entries, but above the platform baseline (40) so background job
- * traces outrank same-source platform defaults.
- */
-const DEFAULT_EMIT_PRIORITY = 50;
-
-/**
- * Parameters accepted by {@link emitFeedEvent}.
- *
- * All action items emitted by background jobs have an origin, so
- * `source` is required. Everything else is optional — callers supply
- * only the fields that describe the specific event.
- */
-export interface EmitFeedEventParams {
-  /** Origin of the underlying event (gmail, slack, calendar, assistant). */
-  source: FeedItemSource;
-  /** Short headline rendered in the feed row. */
-  title: string;
-  /** Body copy rendered below the title. */
-  summary: string;
-  /**
-   * Stable key used to derive a deterministic id so a second emit
-   * for the same logical event updates the existing feed entry in
-   * place. Should include enough structure to identify the event
-   * uniquely (e.g. `"gmail-unread:msg-<messageId>"`,
-   * `"task-runner:<taskId>"`). When omitted, every call produces a
-   * fresh id and appends a new entry.
-   */
-  dedupKey?: string;
-  /**
-   * Priority in [0, 100]. Defaults to {@link DEFAULT_EMIT_PRIORITY}
-   * (50) — above the platform baseline of 40, below the assistant
-   * nudge default of 60.
-   */
-  priority?: number;
-  /** Action buttons surfaced on the feed row. */
-  actions?: FeedAction[];
-  /** Minimum seconds the user must be away before the item is shown. */
-  minTimeAway?: number;
-  /**
-   * Absolute ISO-8601 expiry timestamp. Omit to let the item persist
-   * until the user dismisses it (default for activity-log actions).
-   */
-  expiresAt?: string;
-  /** Visual urgency treatment — controls badge color independently of sort priority. */
-  urgency?: FeedItemUrgency;
-  /** Optional conversation this feed item is associated with. */
-  conversationId?: string;
-  /** Server-driven detail panel descriptor; when present, the client opens this panel kind. */
-  detailPanel?: FeedItemDetailPanel;
-}
-
-/**
- * Build a deterministic feed item id from a source + dedup key.
- *
- * The id is intentionally human-readable: `emit:<source>:<dedupKey>`.
- * This makes debugging easier than a hash (you can eyeball the file
- * and immediately see which background job produced which entry)
- * and `FeedItem.id` is a free-form string so there is no length or
- * charset constraint to worry about.
- */
-function deterministicId(source: FeedItemSource, dedupKey: string): string {
-  return `emit:${source}:${dedupKey}`;
-}
-
-/**
- * Emit a background-job activity-log entry onto the home feed.
- *
- * Builds a fully-formed assistant-authored `action` {@link FeedItem},
- * validates it against the canonical schema, and persists it via
- * {@link appendFeedItem}. Returns the constructed item so the caller
- * can log / reference it downstream.
- *
- * Throws a `ZodError` if the constructed item fails validation
- * (e.g. a `priority` outside `[0, 100]`) — a programming error in
- * the caller that must not be silently swallowed. Persistence-layer
- * failures are absorbed by `appendFeedItem` per its warn-log
- * contract.
- */
-export async function emitFeedEvent(
-  params: EmitFeedEventParams,
-): Promise<FeedItem> {
-  const now = new Date().toISOString();
-
-  const id =
-    params.dedupKey !== undefined
-      ? deterministicId(params.source, params.dedupKey)
-      : randomUUID();
-
-  const item: FeedItem = {
-    id,
-    type: "action",
-    source: params.source,
-    title: params.title,
-    summary: params.summary,
-    priority: params.priority ?? DEFAULT_EMIT_PRIORITY,
-    status: "new",
-    author: "assistant",
-    timestamp: now,
-    createdAt: now,
-    actions: params.actions,
-    urgency: params.urgency,
-    conversationId: params.conversationId,
-    detailPanel: params.detailPanel,
-    minTimeAway: params.minTimeAway,
-    expiresAt: params.expiresAt,
-  };
-
-  // Programming-error guardrail: invalid input throws at the source
-  // instead of corrupting the on-disk snapshot via the writer.
-  feedItemSchema.parse(item);
-
-  await appendFeedItem(item);
-
-  return item;
-}

package/src/home/feed-scheduler.ts

@@ -1,281 +0,0 @@
-/**
- * Home activity feed scheduler.
- *
- * Periodic tick loop that drives the feed producers — the assistant
- * roll-up loop and the platform-baseline Gmail digest generator. This
- * is the layer that turns the Phase-5 scaffolding into a live feed: the
- * producers exist as standalone functions, the writer knows how to
- * persist their output, and the HTTP route + SSE pipeline surface it
- * to the macOS client; this scheduler is what actually calls them.
- *
- * Design notes:
- *
- *   - Mirrors `schedule/scheduler.ts`: `setInterval` + coalescing flag
- *     so two ticks never run in parallel, `timer.unref()` so the timer
- *     never blocks daemon exit, stop() clears the interval on shutdown.
- *
- *   - Each producer tracks its own "last ran at" timestamp and decides
- *     whether to run on each tick. This keeps the tick cadence short
- *     (so cheap producers refresh often) while expensive producers
- *     (LLM roll-up) self-throttle independently.
- *
- *   - Fire-and-forget: every producer failure is logged and swallowed.
- *     A broken producer must never break the tick loop or the daemon.
- *
- *   - `writeAssistantFeedItem` / `generateGmailDigest` both invoke the
- *     feed writer directly, which publishes `home_feed_updated` on every
- *     successful write, so the macOS store auto-refreshes without this
- *     scheduler needing to touch the event hub.
- */
-
-import {
-  checkDiskPressureBackgroundGate,
-  diskPressureBackgroundSkipLogFields,
-  shouldLogDiskPressureBackgroundSkip,
-} from "../daemon/disk-pressure-background-gate.js";
-import { getLogger } from "../util/logger.js";
-import type { FeedItem } from "./feed-types.js";
-import {
-  generateGmailDigest,
-  type GmailCountSource,
-} from "./platform-gmail-digest.js";
-import { type RollupResult, runRollupProducer } from "./rollup-producer.js";
-
-const log = getLogger("home-feed-scheduler");
-
-/** Tick cadence — fast enough for a Gmail digest to feel fresh. */
-const TICK_INTERVAL_MS = 5 * 60 * 1000;
-
-/** Per-producer minimum gap between runs. */
-const GMAIL_DIGEST_INTERVAL_MS = 5 * 60 * 1000;
-/**
- * Roll-up cadence is deliberately long — 120 minutes — because the
- * scheduler is the *safety net*, not the primary trigger. Opening the
- * Home page fires a debounced on-visit refresh in the HTTP route (see
- * `runtime/routes/home-feed-routes.ts`), which is the path most users
- * actually hit. The scheduler exists so the feed still stays fresh
- * for long idle stretches where nobody opens the Home page.
- */
-const ROLLUP_INTERVAL_MS = 2 * 60 * 60 * 1000;
-
-export interface FeedSchedulerHandle {
-  /** Stops the interval. Safe to call multiple times. */
-  stop(): void;
-  /**
-   * Run a single tick synchronously for tests. Returns a summary of
-   * which producers ran during this tick.
-   */
-  runOnce(now?: Date): Promise<FeedTickSummary>;
-}
-
-export interface FeedTickSummary {
-  gmailDigestRan: boolean;
-  rollupRan: boolean;
-}
-
-export interface FeedSchedulerOptions {
-  /**
-   * Optional count source for the Gmail digest. Defaults to
-   * {@link defaultGmailCountSource}, which reads the active OAuth
-   * connection and issues one `messages.list?q=is:unread&maxResults=1`
-   * call to read the `resultSizeEstimate` field (no body fetches).
-   */
-  gmailCountSource?: GmailCountSource;
-  /**
-   * When true (the default), the scheduler fires one tick synchronously
-   * after startup so the feed is populated on the first app open after
-   * daemon boot. Set to false in tests so the only ticks that run are
-   * the ones the test drives via `runOnce()`.
-   */
-  runOnStart?: boolean;
-  /**
-   * Dependency seams for tests. Production callers pass `undefined` so
-   * the scheduler uses the real producer implementations. Tests pass
-   * spies to avoid `mock.module`, which leaks across files in Bun's
-   * test runner.
-   */
-  gmailDigestRunner?: (
-    now: Date,
-    countSource: GmailCountSource,
-  ) => Promise<FeedItem | null>;
-  rollupRunner?: (now: Date) => Promise<RollupResult>;
-}
-
-/**
- * Start the home feed scheduler. Returns a handle whose `stop()` is
- * wired into the daemon shutdown sequence via `ShutdownDeps`.
- */
-export function startFeedScheduler(
-  options: FeedSchedulerOptions = {},
-): FeedSchedulerHandle {
-  let stopped = false;
-  let tickRunning = false;
-  let lastGmailDigestAt = 0;
-  let lastRollupAt = 0;
-
-  const gmailCountSource = options.gmailCountSource ?? defaultGmailCountSource;
-  const gmailDigestRunner = options.gmailDigestRunner ?? generateGmailDigest;
-  const rollupRunner =
-    options.rollupRunner ?? ((now: Date) => runRollupProducer(now));
-
-  const tick = async (now: Date = new Date()): Promise<FeedTickSummary> => {
-    const summary: FeedTickSummary = {
-      gmailDigestRan: false,
-      rollupRan: false,
-    };
-    if (stopped || tickRunning) return summary;
-    const diskPressureGate = checkDiskPressureBackgroundGate("background-work");
-    if (diskPressureGate.action === "skip") {
-      if (shouldLogDiskPressureBackgroundSkip("home-feed-scheduler")) {
-        log.warn(
-          {
-            source: "feed-scheduler",
-            ...diskPressureBackgroundSkipLogFields(diskPressureGate),
-          },
-          "Home feed scheduler skipped during disk pressure cleanup mode",
-        );
-      }
-      return summary;
-    }
-    tickRunning = true;
-    const nowMs = now.getTime();
-    try {
-      if (nowMs - lastGmailDigestAt >= GMAIL_DIGEST_INTERVAL_MS) {
-        lastGmailDigestAt = nowMs;
-        summary.gmailDigestRan = true;
-        const startedAt = Date.now();
-        try {
-          const item = await gmailDigestRunner(now, gmailCountSource);
-          log.info(
-            { wroteItem: item !== null, durationMs: Date.now() - startedAt },
-            "Gmail digest producer ran",
-          );
-        } catch (err) {
-          log.warn(
-            { err, durationMs: Date.now() - startedAt },
-            "Gmail digest producer threw",
-          );
-        }
-      }
-
-      if (nowMs - lastRollupAt >= ROLLUP_INTERVAL_MS) {
-        summary.rollupRan = true;
-        const startedAt = Date.now();
-        try {
-          const result = await rollupRunner(now);
-          log.info(
-            {
-              wroteCount: result.wroteCount,
-              skippedReason: result.skippedReason,
-              durationMs: Date.now() - startedAt,
-            },
-            "Rollup producer ran",
-          );
-          // Only advance the cooldown gate when the producer actually
-          // had a chance to run the LLM. Three skip reasons short-
-          // circuit before any provider call and should NOT burn the
-          // window:
-          //   - `no_provider`: the provider registry wasn't ready yet
-          //     (happens on the startup tick because the feed scheduler
-          //     boots before the provider init pass in
-          //     `daemon/lifecycle.ts`).
-          //   - `no_actions`: there was nothing to roll up. A subsequent
-          //     tick should retry as soon as new actions land, not wait
-          //     the full window.
-          //   - `in_flight`: another caller (usually the on-visit
-          //     refresh trigger in `home-feed-routes.ts`) is already
-          //     running the rollup. That caller's result effectively
-          //     counts as this scheduler tick's real run; bumping the
-          //     gate here would force the NEXT tick to also wait out
-          //     the full window even though nothing broken happened.
-          // Every other outcome — success, empty items, malformed
-          // output, provider error — is a real LLM attempt and does
-          // advance the gate so a broken producer doesn't hammer us.
-          if (
-            result.skippedReason !== "no_provider" &&
-            result.skippedReason !== "no_actions" &&
-            result.skippedReason !== "in_flight"
-          ) {
-            lastRollupAt = nowMs;
-          }
-        } catch (err) {
-          lastRollupAt = nowMs;
-          log.warn(
-            { err, durationMs: Date.now() - startedAt },
-            "Rollup producer threw",
-          );
-        }
-      }
-    } finally {
-      tickRunning = false;
-    }
-    return summary;
-  };
-
-  const timer = setInterval(() => {
-    void tick();
-  }, TICK_INTERVAL_MS);
-  timer.unref();
-  if (options.runOnStart !== false) {
-    // Fire once on startup so the feed is populated on the first app
-    // open after daemon boot. Runs in the background — startup does
-    // not await it.
-    void tick();
-  }
-
-  log.info(
-    {
-      tickIntervalMs: TICK_INTERVAL_MS,
-      gmailDigestIntervalMs: GMAIL_DIGEST_INTERVAL_MS,
-      rollupIntervalMs: ROLLUP_INTERVAL_MS,
-    },
-    "Home feed scheduler started",
-  );
-
-  return {
-    stop(): void {
-      if (stopped) return;
-      stopped = true;
-      clearInterval(timer);
-      log.info("Home feed scheduler stopped");
-    },
-    runOnce: tick,
-  };
-}
-
-/**
- * Default Gmail count source — resolves the active `google` OAuth
- * connection via {@link resolveOAuthConnection}, issues one cheap
- * `messages.list` call with `q=is:unread&maxResults=1`, and returns
- * the `resultSizeEstimate` field. Returns 0 when no Gmail connection
- * exists or the call fails so the digest generator no-ops without
- * throwing.
- *
- * Deliberately does NOT pre-check `isProviderConnected("google")` —
- * that helper only reports local oauth-store rows, which are absent
- * in managed-OAuth mode even when `resolveOAuthConnection("google")`
- * would still resolve via the platform path. Letting the resolver
- * make the decision is the only way to cover both modes.
- */
-async function defaultGmailCountSource(): Promise<number> {
-  // Lazy import — the oauth resolver + gmail client drag in a fair
-  // bit of transitive state, and we only want to pay that cost when a
-  // tick actually runs (not at module load time).
-  const [{ resolveOAuthConnection }, { listMessages }] = await Promise.all([
-    import("../oauth/connection-resolver.js"),
-    import("../messaging/providers/gmail/client.js"),
-  ]);
-
-  try {
-    const connection = await resolveOAuthConnection("google");
-    const response = await listMessages(connection, "is:unread", 1);
-    const estimate = response.resultSizeEstimate;
-    return typeof estimate === "number" && estimate >= 0 ? estimate : 0;
-  } catch (err) {
-    // Either no Gmail connection exists (managed or direct) or the
-    // API call itself failed. Both paths degrade to zero so the
-    // digest generator no-ops without writing a stale item.
-    log.warn({ err }, "Gmail count source failed; treating as zero");
-    return 0;
-  }
-}

package/src/home/platform-gmail-digest.ts

@@ -1,163 +0,0 @@
-/**
- * Platform-baseline Gmail digest generator.
- *
- * Produces a mechanical "N new emails" digest FeedItem for the home
- * activity feed. This is the first platform-authored feed source —
- * it writes a digest item via the feed writer. Scheduling/invocation
- * wiring lands in a follow-up PR when the end-to-end feed flow is
- * turned on.
- *
- * Design notes:
- *
- *   - No LLM calls. Title and summary are purely mechanical so this
- *     path stays cheap and deterministic. Assistant-authored nudges
- *     can override a platform digest for the same `(type, source)`
- *     pair via the feed writer's hybrid-authoring resolver (see
- *     `feed-writer.ts`).
- *   - No direct Gmail API fetches. The count is read from whatever
- *     integration cache already exists. A dependency-injected count
- *     source keeps the function testable and leaves room for the real
- *     integration wiring to land in a follow-up PR.
- *   - One-per-source replacement is handled by the writer — a fresh
- *     digest automatically replaces any prior Gmail digest in place
- *     on each call.
- *   - `minTimeAway: 3600` (1 hour) avoids showing the digest to users
- *     who've only briefly stepped away. Priority `40` is mid-tier so
- *     assistant-authored items naturally win on the sort.
- */
-
-import { randomUUID } from "node:crypto";
-
-import { getLogger } from "../util/logger.js";
-import type { FeedItem } from "./feed-types.js";
-import { appendFeedItem, readHomeFeed } from "./feed-writer.js";
-
-const log = getLogger("platform-gmail-digest");
-
-/**
- * Count source for pending Gmail emails. Kept as an injectable
- * dependency so tests can supply a deterministic number and so the
- * real wiring (an integration cache / event bus) can be swapped in
- * without touching this module.
- *
- * The default source returns 0 — there is no persistent, platform-
- * wide Gmail inbox count tracked in the daemon today, so the default
- * path is a no-op until a real count source is wired in.
- */
-export type GmailCountSource = () => Promise<number>;
-
-async function defaultGmailCountSource(): Promise<number> {
-  // No platform-wide Gmail inbox count exists in the daemon yet.
-  // Callers pass an explicit `countSource` from whatever integration
-  // state is appropriate for their context (tests, watcher store,
-  // future integration event bus, etc.).
-  return 0;
-}
-
-/**
- * Build and append a platform-baseline Gmail digest feed item.
- *
- * Returns `null` when the count is 0 (no-op; we do not write an
- * empty digest). Otherwise returns the constructed `FeedItem` after
- * successfully enqueueing it via `appendFeedItem`.
- *
- * Never throws — all failures degrade to a warn-log so the caller
- * (a scheduler tick) can fire-and-forget without a try/catch.
- */
-export async function generateGmailDigest(
-  now: Date,
-  countSource: GmailCountSource = defaultGmailCountSource,
-): Promise<FeedItem | null> {
-  let count: number;
-  try {
-    count = await countSource();
-  } catch (err) {
-    log.warn({ err }, "Gmail count source threw; skipping digest");
-    return null;
-  }
-
-  if (!Number.isFinite(count) || count <= 0) {
-    return null;
-  }
-
-  const flooredCount = Math.floor(count);
-  const timestamp = now.toISOString();
-  const summary = buildDigestSummary(now);
-
-  const item: FeedItem = {
-    id: randomUUID(),
-    type: "digest",
-    source: "gmail",
-    author: "platform",
-    title: `${flooredCount} new email${flooredCount === 1 ? "" : "s"}`,
-    summary,
-    priority: 40,
-    minTimeAway: 3600,
-    timestamp,
-    createdAt: timestamp,
-    status: "new",
-  };
-
-  try {
-    await appendFeedItem(item);
-  } catch (err) {
-    log.warn({ err }, "Failed to append Gmail digest to feed");
-    return null;
-  }
-
-  return item;
-}
-
-/**
- * Builds the digest summary line. Reads the prior Gmail digest's
- * timestamp from the feed and formats it as `"Since <short time>"`
- * so users can anchor "new emails" to a specific moment. Falls back
- * to a generic string on first-ever digest or on any read failure
- * (the writer is authoritative; we never throw out of the generator).
- */
-function buildDigestSummary(now: Date): string {
-  const priorTimestamp = readPriorGmailDigestTimestamp();
-  if (priorTimestamp == null) {
-    return "Since your last check-in";
-  }
-
-  const priorDate = new Date(priorTimestamp);
-  if (Number.isNaN(priorDate.getTime())) {
-    return "Since your last check-in";
-  }
-
-  return `Since ${formatShortTime(priorDate, now)}`;
-}
-
-function readPriorGmailDigestTimestamp(): string | null {
-  try {
-    const feed = readHomeFeed();
-    const prior = feed.items.find(
-      (item) => item.type === "digest" && item.source === "gmail",
-    );
-    return prior?.timestamp ?? null;
-  } catch (err) {
-    log.warn({ err }, "Failed to read prior Gmail digest timestamp");
-    return null;
-  }
-}
-
-/**
- * Same-day prior → "10:32 AM". Cross-day prior → "Mon 10:32 AM".
- * Plain `toLocaleTimeString` would conflate yesterday and today.
- */
-function formatShortTime(prior: Date, now: Date): string {
-  const time = prior.toLocaleTimeString("en-US", {
-    hour: "numeric",
-    minute: "2-digit",
-  });
-  const sameDay =
-    prior.getFullYear() === now.getFullYear() &&
-    prior.getMonth() === now.getMonth() &&
-    prior.getDate() === now.getDate();
-  if (sameDay) {
-    return time;
-  }
-  const weekday = prior.toLocaleDateString("en-US", { weekday: "short" });
-  return `${weekday} ${time}`;
-}

package/src/home/rewrite-command-preview.ts

@@ -1,66 +0,0 @@
-import { getConfiguredProvider } from "../providers/provider-send-message.js";
-import { getLogger } from "../util/logger.js";
-
-const log = getLogger("command-preview-rewriter");
-const REWRITE_TIMEOUT_MS = 3000;
-const REWRITE_MAX_TOKENS = 100;
-
-const SYSTEM_PROMPT = `You rewrite technical computer commands into simple, human-readable descriptions.
-Output ONLY the rewritten description — no quotes, no explanation, no preamble.
-Keep it under 15 words. Use plain language a non-technical person would understand.
-Examples:
-- "ls -la ~/Desktop" → "View files on the desktop"
-- "cat ~/.bashrc" → "Read shell configuration file"
-- "rm -rf /tmp/cache" → "Delete temporary cache files"
-- "grep -r 'password' ." → "Search files for the word 'password'"
-- "curl https://api.example.com/users" → "Fetch user data from an API"`;
-
-export async function rewriteCommandPreview(
-  toolName: string,
-  commandPreview: string,
-): Promise<string | null> {
-  try {
-    const provider = await getConfiguredProvider("feedEventCopy");
-    if (!provider) return null;
-
-    const response = await provider.sendMessage(
-      [
-        {
-          role: "user",
-          content: [
-            {
-              type: "text",
-              text: `Tool: ${toolName}\nCommand: ${commandPreview}`,
-            },
-          ],
-        },
-      ],
-      [],
-      SYSTEM_PROMPT,
-      {
-        config: {
-          max_tokens: REWRITE_MAX_TOKENS,
-          callSite: "feedEventCopy",
-        },
-        signal: AbortSignal.timeout(REWRITE_TIMEOUT_MS),
-      },
-    );
-
-    const block = response.content.find((entry) => entry.type === "text");
-    const text =
-      block && "text" in block ? (block as { text: string }).text.trim() : "";
-    if (!text) return null;
-    return (
-      text
-        .replace(/^["'`]+/, "")
-        .replace(/["'`]+$/, "")
-        .trim() || null
-    );
-  } catch (err) {
-    log.warn(
-      { err, toolName, commandPreview },
-      "Command preview rewrite failed",
-    );
-    return null;
-  }
-}