@vellumai/assistant 0.8.2 → 0.8.4

package/src/plugins/defaults/injectors.ts

@@ -20,6 +20,7 @@
  * | `memory-v2-static`       | 38    | after-memory-prefix     |
  * | `now-md`                 | 40    | after-memory-prefix     |
  * | `active-documents`       | 45    | prepend-user-tail       |
+ * | `document-comments`      | 46    | prepend-user-tail       |
  * | `subagent-status`        | 50    | append-user-tail        |
  * | `slack-messages`         | 60    | replace-run-messages    |
  * | `thread-focus`           | 70    | append-user-tail        |
@@ -51,6 +52,7 @@ import { isAssistantFeatureFlagEnabled } from "../../config/assistant-feature-fl
 import { getConfig } from "../../config/loader.js";
 import { getInContextPkbPaths } from "../../daemon/pkb-context-tracker.js";
 import { buildPkbReminder } from "../../daemon/pkb-reminder-builder.js";
+import { listComments } from "../../documents/document-comments-store.js";
 import { searchPkbFiles } from "../../memory/pkb/pkb-search.js";
 import { getLogger } from "../../util/logger.js";
 import { registerPlugin } from "../registry.js";
@@ -87,12 +89,14 @@ const PKB_HINT_ARCHIVE_THRESHOLD = 0.7;
 export const DEFAULT_INJECTOR_ORDER = {
   diskPressureWarning: 5,
   workspaceContext: 10,
+  backgroundTurn: 15,
   unifiedTurnContext: 20,
   pkbContext: 30,
   pkbReminder: 35,
   memoryV2Static: 38,
   nowMd: 40,
   activeDocuments: 45,
+  documentComments: 46,
   subagentStatus: 50,
   slackMessages: 60,
   threadFocus: 70,
@@ -132,12 +136,11 @@ const diskPressureWarningInjector: Injector = {
 };
 
 /**
- * v2 read-side cutover guard. The `pkb-context` injector silences itself
- * under v2 because the `<knowledge_base>` block surfaces PKB content the v2
- * activation block already covers. The `pkb-reminder` injector still fires
- * (its body is generic recall/remember guidance) but skips the hybrid-search
- * hints — those name PKB paths v2 is moving away from. NOW.md is workspace
- * state independent of PKB and fires unchanged.
+ * v2 read-side cutover guard. Under v2 both `pkb-context` and `pkb-reminder`
+ * silence themselves entirely — the `<knowledge_base>` content and the
+ * generic recall/remember nudge are both supplanted by the v2 static
+ * `<memory>` block. NOW.md is workspace state independent of PKB and fires
+ * unchanged.
  */
 function isPkbInjectionSilencedByV2(): boolean {
   return getConfig().memory.v2.enabled;
@@ -171,6 +174,39 @@ const workspaceContextInjector: Injector = {
   },
 };
 
+/**
+ * `background-turn` injector — order 15, prepend-user-tail.
+ *
+ * Wraps the tail user message with a `<background_turn>` block that tells
+ * the assistant the guardian isn't watching and that anything noteworthy
+ * should be surfaced via the `notifications` skill. Fires only when (a) the
+ * conversation's type is "background" or "scheduled" (see
+ * `isBackgroundConversationType`) AND (b) no client is currently connected
+ * (`isNonInteractive`). The second gate is what prevents the reminder from
+ * firing on a manual follow-up the guardian sends into a background thread
+ * — at that point the guardian IS watching, so the framing doesn't apply.
+ *
+ * The inner text is read from `config.conversations.backgroundInjection`, so
+ * operators can edit the reminder without a code change. Setting it to the
+ * empty string disables the injection entirely.
+ */
+const backgroundTurnInjector: Injector = {
+  name: "background-turn",
+  order: DEFAULT_INJECTOR_ORDER.backgroundTurn,
+  async produce(ctx: TurnContext): Promise<InjectionBlock | null> {
+    const inputs = readInjectionInputs(ctx);
+    if (!inputs.isBackgroundConversation) return null;
+    if (!inputs.isNonInteractive) return null;
+    const inner = getConfig().conversations.backgroundInjection;
+    if (!inner) return null;
+    return {
+      id: "background-turn",
+      text: `<background_turn>\n${inner}\n</background_turn>`,
+      placement: "prepend-user-tail",
+    };
+  },
+};
+
 /**
  * `unified-turn-context` injector — order 20, prepend-user-tail.
  *
@@ -253,24 +289,8 @@ const pkbReminderInjector: Injector = {
     const mode = inputs.mode ?? "full";
     if (mode !== "full") return null;
     if (!inputs.pkbActive) return null;
-    // The `memory-retrospective` feature flag enables a focused background
-    // retrospective pass that catches what the in-conversation `remember`
-    // calls miss. When that backstop is on, the per-turn pressure to call
-    // `remember` softens to a judgment framing. When it's off, the original
-    // high-pressure BODY is used so users without the retrospective still
-    // get aggressive capture in-conversation.
-    let relaxed = false;
-    try {
-      relaxed = isAssistantFeatureFlagEnabled(
-        "memory-retrospective",
-        getConfig(),
-      );
-    } catch {
-      // Best-effort — fall back to the default (non-relaxed) BODY.
-    }
-    const reminder = isPkbInjectionSilencedByV2()
-      ? buildPkbReminder([], relaxed)
-      : await buildPkbReminderWithHints(inputs, relaxed);
+    if (isPkbInjectionSilencedByV2()) return null;
+    const reminder = await buildPkbReminderWithHints(inputs);
     return {
       id: "pkb-reminder",
       text: reminder,
@@ -300,7 +320,6 @@ function buildPkbContextBlock(content: string): string {
  */
 async function buildPkbReminderWithHints(
   inputs: TurnInjectionInputs,
-  relaxed: boolean,
 ): Promise<string> {
   let hints: string[] = [];
   const queryVector = inputs.pkbQueryVector;
@@ -361,7 +380,7 @@ async function buildPkbReminderWithHints(
       hints = [];
     }
   }
-  return buildPkbReminder(hints, relaxed);
+  return buildPkbReminder(hints);
 }
 
 /**
@@ -473,6 +492,77 @@ const activeDocumentsInjector: Injector = {
   },
 };
 
+/** Maximum open comments surfaced per document to limit context bloat. */
+const DOCUMENT_COMMENTS_CAP = 10;
+
+/**
+ * Escape closing `</document_comments>` inside user-controlled strings so
+ * they cannot break out of the XML wrapper — same pattern as
+ * {@link buildPkbContextBlock} and {@link buildMemoryV2StaticBlock}.
+ */
+function escapeDocCommentTag(s: string): string {
+  return s.replace(/<\/document_comments\s*>/gi, "&lt;/document_comments&gt;");
+}
+
+/**
+ * `document-comments` injector — order 46, prepend-user-tail.
+ *
+ * Surfaces open top-level comments on active documents so the assistant
+ * knows what feedback to address. For each active document, queries the
+ * comment store for open top-level comments (capped at
+ * {@link DOCUMENT_COMMENTS_CAP} most recent per document). Inline comments
+ * include the quoted anchor text; doc-level comments are labelled as such.
+ *
+ * Gating:
+ *  - `mode === "full"`.
+ *  - `activeDocuments` has at least one entry.
+ *  - At least one document has open comments (returns null otherwise).
+ */
+const documentCommentsInjector: Injector = {
+  name: "document-comments",
+  order: DEFAULT_INJECTOR_ORDER.documentComments,
+  async produce(ctx: TurnContext): Promise<InjectionBlock | null> {
+    const inputs = readInjectionInputs(ctx);
+    const mode = inputs.mode ?? "full";
+    if (mode !== "full") return null;
+    const docs = inputs.activeDocuments;
+    if (!docs || docs.length === 0) return null;
+
+    const sections: string[] = [];
+    for (const doc of docs) {
+      const comments = listComments(doc.surfaceId, {
+        status: "open",
+        topLevelOnly: true,
+      }).slice(-DOCUMENT_COMMENTS_CAP);
+      if (comments.length === 0) continue;
+
+      const lines = comments.map((c) => {
+        const anchor =
+          c.anchorText != null ? escapeDocCommentTag(c.anchorText) : null;
+        const label =
+          anchor != null ? `inline, anchored to "${anchor}"` : "doc-level";
+        return `- Comment #${c.id} (${label}): "${escapeDocCommentTag(c.content)}"`;
+      });
+      sections.push(
+        `Document: "${escapeDocCommentTag(doc.title)}" (surface_id: "${doc.surfaceId}")\n${lines.join("\n")}`,
+      );
+    }
+
+    if (sections.length === 0) return null;
+
+    const text = `<document_comments>
+Open comments on your documents. Address these by editing the document, then use comment_resolve to mark each resolved.
+
+${sections.join("\n\n")}
+</document_comments>`;
+    return {
+      id: "document-comments",
+      text,
+      placement: "prepend-user-tail",
+    };
+  },
+};
+
 /**
  * `subagent-status` injector — order 50, append-user-tail.
  *
@@ -601,12 +691,14 @@ export const defaultInjectorsPlugin: Plugin = {
   injectors: [
     diskPressureWarningInjector,
     workspaceContextInjector,
+    backgroundTurnInjector,
     unifiedTurnContextInjector,
     pkbContextInjector,
     pkbReminderInjector,
     memoryV2StaticInjector,
     nowMdInjector,
     activeDocumentsInjector,
+    documentCommentsInjector,
     subagentStatusInjector,
     slackMessagesInjector,
     threadFocusInjector,

package/src/plugins/external-plugin-loader.ts

@@ -23,7 +23,9 @@
  *                                    other filenames sit in the map for
  *                                    forward compatibility)
  *       tools/
- *         *.ts                    ← each file's default export → plugin.tools[]
+ *         *.ts                    ← each default export → plugin.tools[];
+ *                                   runtime name derives from the filename
+ *                                   basename
  *       src/                      ← internal helpers, ignored by the loader
  *
  * Per-surface, `.js` is preferred over `.ts` (compiled-binary semantics).
@@ -47,6 +49,12 @@ import semver from "semver";
 import { z } from "zod";
 
 import assistantPkg from "../../package.json" with { type: "json" };
+import type {
+  LoadedPluginTool,
+  PluginTool,
+  RiskLevel,
+  ToolExecutionResult,
+} from "../tools/types.js";
 import { getLogger } from "../util/logger.js";
 import { registerPlugin } from "./registry.js";
 import type {
@@ -106,6 +114,72 @@ function stripScope(name: string): string {
   return match ? match[1]! : name;
 }
 
+function toToolNameSegment(value: string): string {
+  return value.replace(/[^a-zA-Z0-9]+/g, "_").replace(/^_+|_+$/g, "") || "tool";
+}
+
+function deriveToolName(toolFileBaseName: string): string {
+  return toToolNameSegment(toolFileBaseName);
+}
+
+/**
+ * Defaults applied by {@link applyPluginToolDefaults} when a plugin tool
+ * omits one of the normally-required fields. Exported as a constant so
+ * tests and callers can reference the same source of truth.
+ *
+ * The default `execute` returns an error result so the model sees a clear
+ * "this tool isn't wired up" signal at call time. The plugin still loads
+ * cleanly — broken individual tools must never block daemon boot.
+ */
+export const PLUGIN_TOOL_DEFAULTS = Object.freeze({
+  description: "",
+  defaultRiskLevel: "medium" as RiskLevel,
+  input_schema: Object.freeze({
+    type: "object",
+    properties: {},
+    additionalProperties: false,
+  }) as object,
+});
+
+/**
+ * Fill the four normally-required {@link PluginTool} fields with documented
+ * defaults when the author omitted them. Returns a {@link LoadedPluginTool}
+ * that is safe to register.
+ */
+function applyPluginToolDefaults(
+  tool: PluginTool,
+  name: string,
+): LoadedPluginTool {
+  const description =
+    typeof tool.description === "string"
+      ? tool.description
+      : PLUGIN_TOOL_DEFAULTS.description;
+  const defaultRiskLevel =
+    typeof tool.defaultRiskLevel === "string"
+      ? tool.defaultRiskLevel
+      : PLUGIN_TOOL_DEFAULTS.defaultRiskLevel;
+  const input_schema =
+    tool.input_schema !== null &&
+    typeof tool.input_schema === "object"
+      ? tool.input_schema
+      : PLUGIN_TOOL_DEFAULTS.input_schema;
+  const execute =
+    typeof tool.execute === "function"
+      ? tool.execute
+      : async (): Promise<ToolExecutionResult> => ({
+          content: `plugin tool ${name} has no execute implementation`,
+          isError: true,
+        });
+  return {
+    ...tool,
+    name,
+    description,
+    defaultRiskLevel,
+    input_schema,
+    execute,
+  };
+}
+
 /**
  * Dynamic-import `absolutePath` and return its default export. Throws when
  * the module has no default export — callers attribute the error.
@@ -266,18 +340,16 @@ async function buildPluginFromDir(pluginDir: string): Promise<Plugin> {
   if (hooks !== undefined) plugin.hooks = hooks;
 
   const tools: PluginToolRegistration[] = [];
-  for (const { path: toolPath } of listSurfaceDir(join(pluginDir, "tools"))) {
-    const tool = await importDefault<PluginToolRegistration>(toolPath);
-    if (
-      tool === null ||
-      typeof tool !== "object" ||
-      typeof (tool as { name?: unknown }).name !== "string"
-    ) {
+  for (const { name: toolName, path: toolPath } of listSurfaceDir(
+    join(pluginDir, "tools"),
+  )) {
+    const tool = await importDefault<PluginTool>(toolPath);
+    if (tool === null || typeof tool !== "object") {
       throw new Error(
-        `external plugin ${name}: ${toolPath} default export must be a Tool object with a string "name"`,
+        `external plugin ${name}: ${toolPath} default export must be an object`,
       );
     }
-    tools.push(tool);
+    tools.push(applyPluginToolDefaults(tool, deriveToolName(toolName)));
   }
   if (tools.length > 0) plugin.tools = tools;
 

package/src/plugins/types.ts

@@ -43,7 +43,7 @@ import type {
 } from "../providers/types.js";
 import type { SkillRoute } from "../runtime/skill-route-registry.js";
 import type {
-  PluginTool,
+  LoadedPluginTool,
   ToolContext,
   ToolExecutionResult,
 } from "../tools/types.js";
@@ -839,6 +839,13 @@ export interface TurnInjectionInputs {
    * knows no human is present to answer clarification questions.
    */
   readonly isNonInteractive?: boolean;
+  /**
+   * True when the active conversation's type is "background" or "scheduled"
+   * (see `isBackgroundConversationType`). Read by the `background-turn`
+   * injector to wrap the tail user message with a contextual reminder when
+   * the turn is also non-interactive.
+   */
+  readonly isBackgroundConversation?: boolean;
   /**
    * Active documents open in this conversation — surfaced by the
    * `active-documents` injector so the assistant can target existing docs
@@ -1002,15 +1009,17 @@ export interface Injector {
 
 /**
  * Tool registration contributed by a plugin. Uses the narrow
- * {@link PluginTool} shape — plugin authors declare functional fields
- * (`name`, `description`, `input_schema`, `execute`, etc.) and leave category
- * / ownership metadata to the bootstrap, which stamps `category: "plugin"`,
- * `origin: "plugin"`, and `ownerPluginId: <plugin.name>` before handing the
- * batch to `registerPluginTools`. The registration boundary synthesizes
+ * {@link LoadedPluginTool} shape. External plugin authors declare the
+ * nameless `PluginTool` file shape; the loader derives `name` from the
+ * `tools/<name>.ts` basename before storing it on `plugin.tools`. Authors
+ * also leave category / ownership metadata to the bootstrap, which stamps
+ * `category: "plugin"`, `origin: "plugin"`, and
+ * `ownerPluginId: <plugin.name>` before handing the batch to
+ * `registerPluginTools`. The registration boundary synthesizes
  * `getDefinition()` from `{name, description, input_schema}` so the canonical
  * {@link Tool} interface used by the internal registry stays unchanged.
  */
-export type PluginToolRegistration = PluginTool;
+export type PluginToolRegistration = LoadedPluginTool;
 /**
  * HTTP route registration contributed by a plugin. Plugins express routes as
  * {@link SkillRoute} values — the same shape the skill-route registry

package/src/prompts/__tests__/system-prompt.test.ts

@@ -1,13 +1,13 @@
 /**
- * Tests for the Background Conversation gating in buildSystemPrompt.
- *
- * The Background Conversation guidance is gated on
- * `options.isBackgroundConversation === true`.  Interactive (default)
- * conversations must pay zero token cost — the section must be entirely
- * absent unless the flag is explicitly true.
+ * Smoke tests for buildSystemPrompt — covers tool-routing-guidance
+ * exclusions and other call-shape invariants. Background-conversation
+ * guidance is no longer rendered into the system prompt; see
+ * `__tests__/injector-background-turn.test.ts` for the per-turn
+ * user-message injection that replaced it.
  */
 
-import { mkdirSync } from "node:fs";
+import { copyFileSync, mkdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 const TEST_DIR = process.env.VELLUM_WORKSPACE_DIR!;
@@ -58,60 +58,59 @@ mock.module("../../config/loader.js", () => ({
   setNestedValue: () => {},
 }));
 
-const { buildSystemPrompt, SYSTEM_PROMPT_CACHE_BOUNDARY } =
+const { buildSystemPrompt, maybeReseedBootstrapForCohort } =
   await import("../system-prompt.js");
 
-describe("buildSystemPrompt — Background Conversation gating", () => {
+describe("buildSystemPrompt — tool routing guidance", () => {
   beforeEach(() => {
     mkdirSync(TEST_DIR, { recursive: true });
   });
 
-  test("isBackgroundConversation: true — appends the Background Conversation section", () => {
-    const result = buildSystemPrompt({ isBackgroundConversation: true });
-    expect(result).toContain("## Background Conversation");
-    expect(result).toContain("`notifications` skill");
-    expect(result).toContain("assistant notifications send");
+  test("does not include ask_question routing guidance", () => {
+    const result = buildSystemPrompt({});
+    expect(result).not.toContain("## Clarifying questions");
+    expect(result).not.toContain("ask_question");
   });
+});
 
-  test("isBackgroundConversation: false — section is omitted", () => {
-    const result = buildSystemPrompt({ isBackgroundConversation: false });
-    expect(result).not.toContain("## Background Conversation");
-  });
+describe("maybeReseedBootstrapForCohort — content-automation template", () => {
+  const templatesDir = join(import.meta.dirname!, "..", "templates");
 
-  test("options undefined — section is omitted (interactive default)", () => {
-    const result = buildSystemPrompt(undefined);
-    expect(result).not.toContain("## Background Conversation");
+  beforeEach(() => {
+    mkdirSync(TEST_DIR, { recursive: true });
+    // Seed the workspace with the generic BOOTSTRAP.md so the cohort
+    // reseed detects it as an unmodified template and overwrites it.
+    copyFileSync(
+      join(templatesDir, "BOOTSTRAP.md"),
+      join(TEST_DIR, "BOOTSTRAP.md"),
+    );
   });
 
-  test("options provided without the flag — section is omitted", () => {
-    const result = buildSystemPrompt({});
-    expect(result).not.toContain("## Background Conversation");
+  function reseedAndRead(): string {
+    maybeReseedBootstrapForCohort("content-automation");
+    return readFileSync(join(TEST_DIR, "BOOTSTRAP.md"), "utf-8");
+  }
+
+  test("loads the geo-writing skill on first turn", () => {
+    const content = reseedAndRead();
+    expect(content).toContain("geo-writing");
   });
 
-  test("section lives in the static (cached) block, not the dynamic suffix", () => {
-    // The section is deterministic for a given conversationType, so it
-    // belongs in staticParts to share the cache block with other
-    // call-time-stable instructions.
-    const result = buildSystemPrompt({ isBackgroundConversation: true });
-    const boundaryIdx = result.indexOf(SYSTEM_PROMPT_CACHE_BOUNDARY);
-    expect(boundaryIdx).toBeGreaterThan(-1);
-    const staticBlock = result.slice(0, boundaryIdx);
-    const dynamicBlock = result.slice(
-      boundaryIdx + SYSTEM_PROMPT_CACHE_BOUNDARY.length,
-    );
-    expect(staticBlock).toContain("## Background Conversation");
-    expect(dynamicBlock).not.toContain("## Background Conversation");
+  test("uses skill-first onboarding approach", () => {
+    const content = reseedAndRead();
+    expect(content).toContain("Skill-First Onboarding");
+    expect(content).toContain("The skill is the onboarding");
   });
-});
 
-describe("buildSystemPrompt — tool routing guidance", () => {
-  beforeEach(() => {
-    mkdirSync(TEST_DIR, { recursive: true });
+  test("includes comment-driven edit loop", () => {
+    const content = reseedAndRead();
+    expect(content).toContain("comment-driven");
+    expect(content).toContain("comment_resolve");
+    expect(content).toContain("document_update");
   });
 
-  test("does not include ask_question routing guidance", () => {
-    const result = buildSystemPrompt({});
-    expect(result).not.toContain("## Clarifying questions");
-    expect(result).not.toContain("ask_question");
+  test("references VOICE.md for voice capture", () => {
+    const content = reseedAndRead();
+    expect(content).toContain("VOICE.md");
   });
 });

package/src/prompts/__tests__/task-progress-hint-section.test.ts

@@ -74,18 +74,14 @@ describe("task_progress hint in parallel-tool-calls section", () => {
   });
 
   test("renders regardless of options passed", () => {
-    const withBackground = buildSystemPrompt({
-      isBackgroundConversation: true,
-    });
-    const withoutBackground = buildSystemPrompt({
-      isBackgroundConversation: false,
-    });
+    const withClientFlag = buildSystemPrompt({ hasNoClient: true });
+    const withoutClientFlag = buildSystemPrompt({ hasNoClient: false });
     const withExcludePrefix = buildSystemPrompt({
       excludeCustomPrefix: true,
     });
 
-    expect(withBackground).toContain("task_progress");
-    expect(withoutBackground).toContain("task_progress");
+    expect(withClientFlag).toContain("task_progress");
+    expect(withoutClientFlag).toContain("task_progress");
     expect(withExcludePrefix).toContain("task_progress");
   });
 

package/src/prompts/normalize-onboarding.ts

@@ -19,6 +19,20 @@ export const TOOL_DISPLAY_NAMES: Record<string, string> = {
   "apple-notes": "Apple Notes",
 };
 
+/**
+ * Map of known prior-assistant IDs (from the client onboarding UI) to display names.
+ * Unknown IDs pass through with first-letter capitalization via `normalizePriorAssistants`.
+ */
+export const PRIOR_ASSISTANT_DISPLAY_NAMES: Record<string, string> = {
+  chatgpt: "ChatGPT",
+  claude: "Claude",
+  openclaw: "OpenClaw",
+  hermes: "Hermes",
+  manus: "Manus",
+  gemini: "Gemini",
+  copilot: "Copilot",
+};
+
 /**
  * Map of known task IDs to plain-language labels describing what the assistant
  * does for each task category.
@@ -56,14 +70,28 @@ export function normalizeTasks(tasks: string[]): string[] {
   return tasks.map((id) => TASK_DISPLAY_LABELS[id] ?? id);
 }
 
+/**
+ * Maps each prior-assistant ID through `PRIOR_ASSISTANT_DISPLAY_NAMES`,
+ * falling back to first-letter capitalization for unknown IDs.
+ */
+export function normalizePriorAssistants(assistants: string[]): string[] {
+  return assistants.map(
+    (id) => PRIOR_ASSISTANT_DISPLAY_NAMES[id] ?? capitalizeFirst(id),
+  );
+}
+
 export interface NormalizedOnboarding {
   preferredName?: string;
   commonWork: string[];
   dailyTools: string[];
   tone?: string;
   assistantName?: string;
+  priorAssistants?: string[];
   googleConnected?: boolean;
   googleServices?: string[];
+  cohort?: string;
+  websiteUrl?: string;
+  contentSourceUrl?: string;
 }
 
 const SCOPE_SERVICE_MAP: Record<string, string> = {
@@ -103,5 +131,17 @@ export function normalizeOnboardingContext(
     googleServices: ctx.googleConnected
       ? deriveGoogleServices(ctx.googleScopes)
       : undefined,
+    priorAssistants: ctx.priorAssistants?.length
+      ? normalizePriorAssistants(ctx.priorAssistants)
+      : undefined,
+    cohort: ctx.cohort,
+    websiteUrl:
+      typeof ctx.websiteUrl === "string"
+        ? ctx.websiteUrl.trim().replace(/[\r\n\t]/g, "") || undefined
+        : undefined,
+    contentSourceUrl:
+      typeof ctx.contentSourceUrl === "string"
+        ? ctx.contentSourceUrl.trim().replace(/[\r\n\t]/g, "") || undefined
+        : undefined,
   };
 }