@vellumai/assistant 0.8.5 → 0.8.7-dev.202606052118.34cd356

package/src/memory/v2/backfill-jobs.ts

@@ -157,8 +157,14 @@ export async function memoryV2ActivationRecomputeJob(
   const workspaceDir = getWorkspaceDir();
   const database = getDb();
 
+  // Activation maps still need to refresh for archived conversations — a
+  // consolidated page can leave stale slugs above epsilon in their persisted
+  // state — so this job opts back into seeing archived rows.
   const conversations = listConversations(
     ACTIVATION_RECOMPUTE_CONVERSATION_LIMIT,
+    "standard",
+    0,
+    "all",
   );
   const edgeIndex = await getEdgeIndex(workspaceDir);
   const nowText = await loadNowText(workspaceDir);

package/src/memory/v2/consolidation-job.ts

@@ -61,7 +61,21 @@ import {
 } from "node:fs";
 import { dirname, join } from "node:path";
 
+import { isAssistantFeatureFlagEnabled } from "../../config/assistant-feature-flags.js";
 import type { AssistantConfig } from "../../config/types.js";
+import { loadCore } from "../../plugins/defaults/memory-v3-shadow/core.js";
+import {
+  computeV3Health,
+  renderV3Health,
+} from "../../plugins/defaults/memory-v3-shadow/health.js";
+import {
+  loadLeafTree,
+  resolveDataDir,
+} from "../../plugins/defaults/memory-v3-shadow/tree.js";
+import type {
+  LeafPath,
+  Slug,
+} from "../../plugins/defaults/memory-v3-shadow/types.js";
 import { runBackgroundJob } from "../../runtime/background-job-runner.js";
 import { getLogger } from "../../util/logger.js";
 import { getWorkspaceDir } from "../../util/platform.js";
@@ -72,6 +86,7 @@ import {
   type MemoryJob,
   type MemoryJobType,
 } from "../jobs-store.js";
+import { getPageIndex } from "../v2/page-index.js";
 import { MEMORY_V2_CONSOLIDATION_SOURCE } from "./constants.js";
 import { resolveConsolidationPrompt } from "./prompts/consolidation.js";
 
@@ -80,6 +95,14 @@ const log = getLogger("memory-v2-consolidate");
 /** Stable identifier surfaced in `runBackgroundJob` logs and notifications. */
 const JOB_NAME = "memory.consolidate";
 
+/**
+ * v3 plugin flags. Either being on (a) prepends a v3 health block to the
+ * consolidation prompt and (b) enqueues `memory_v3_maintain` as a
+ * post-consolidation follow-up. These gate the v3 plugin itself.
+ */
+const MEMORY_V3_SHADOW = "memory-v3-shadow" as const;
+const MEMORY_V3_LIVE = "memory-v3-live" as const;
+
 /**
  * Hard timeout for the consolidation run. Consolidation reads the buffer,
  * rewrites several files, and re-encodes essentials/threads — generous
@@ -95,9 +118,10 @@ const CONSOLIDATION_TIMEOUT_MS = 15 * 60 * 1000;
  * agent touched: mtime-diffing is fragile across filesystems, and the
  * embedder's content-hash cache makes unchanged pages effectively free.
  */
-const FOLLOW_UP_JOB_TYPES: readonly MemoryJobType[] = [
-  "memory_v2_reembed",
-] as const;
+const FOLLOW_UP_JOB_TYPES: readonly MemoryJobType[] = ["memory_v2_reembed"];
+
+/** Follow-up enqueued only when a v3 flag is on. */
+const V3_FOLLOW_UP_JOB_TYPE: MemoryJobType = "memory_v3_maintain";
 
 /**
  * Job handler. See file header for the full lifecycle. Returns a discriminated
@@ -167,15 +191,22 @@ export async function memoryV2ConsolidateJob(
     // it to a regular file under 1 MiB before substitution so a stray path
     // (or a `/dev/zero`-style pseudo-file) cannot exfiltrate megabytes of
     // bytes through the wake hint.
+    //
+    // That resolved prompt is the base; `maybePrependV3Health` prepends a
+    // freshly computed v3 health block when a v3 flag is on and the tree has
+    // actionable drift, leaving it untouched otherwise.
+    const basePrompt = resolveConsolidationPrompt(
+      config.memory.v2.consolidation_prompt_path,
+      cutoff,
+    );
+    const prompt = await maybePrependV3Health(basePrompt, config);
+
     const runResult = await runBackgroundJob({
       jobName: JOB_NAME,
       source: MEMORY_V2_CONSOLIDATION_SOURCE,
-      prompt: resolveConsolidationPrompt(
-        config.memory.v2.consolidation_prompt_path,
-        cutoff,
-      ),
+      prompt,
       trustContext: { sourceChannel: "vellum", trustClass: "guardian" },
-      callSite: "mainAgent",
+      callSite: "memoryV2Consolidation",
       timeoutMs: CONSOLIDATION_TIMEOUT_MS,
       origin: "memory_consolidation",
       suppressFailureNotifications: true,
@@ -197,9 +228,17 @@ export async function memoryV2ConsolidateJob(
 
     // Step 5: enqueue follow-up jobs. Enqueueing now keeps the dispatch
     // wiring exercised end-to-end so PR 21 only has to swap in the handler
-    // bodies.
+    // bodies. v3 maintenance is appended only while a v3 path (shadow or live)
+    // is active, so it never fans out on v2-only installs.
     const followUpJobIds: string[] = [];
-    for (const jobType of FOLLOW_UP_JOB_TYPES) {
+    const jobTypes: MemoryJobType[] = [...FOLLOW_UP_JOB_TYPES];
+    if (
+      isAssistantFeatureFlagEnabled(MEMORY_V3_SHADOW, config) ||
+      isAssistantFeatureFlagEnabled(MEMORY_V3_LIVE, config)
+    ) {
+      jobTypes.push(V3_FOLLOW_UP_JOB_TYPE);
+    }
+    for (const jobType of jobTypes) {
       try {
         followUpJobIds.push(enqueueMemoryJob(jobType, {}));
       } catch (err) {
@@ -231,6 +270,56 @@ export async function memoryV2ConsolidateJob(
   }
 }
 
+/**
+ * When a v3 flag is enabled and the v3 tree has actionable structural drift,
+ * prepend a rendered health block to `basePrompt` so the consolidation run can
+ * fold tree maintenance into its pass. Returns `basePrompt` UNCHANGED when:
+ *   - neither `memory-v3-shadow` nor `memory-v3-live` is enabled,
+ *   - the health report is all-green (`renderV3Health` returns ""), or
+ *   - computing the report throws for any reason.
+ *
+ * The block is computed here (not baked into the prompt template) so an
+ * operator's custom consolidation prompt stays untouched and the block reflects
+ * the tree state at run time. Health computation is wrapped so a load/compute
+ * failure can never break consolidation — the run proceeds on the base prompt.
+ */
+async function maybePrependV3Health(
+  basePrompt: string,
+  config: AssistantConfig,
+): Promise<string> {
+  const v3Enabled =
+    isAssistantFeatureFlagEnabled(MEMORY_V3_SHADOW, config) ||
+    isAssistantFeatureFlagEnabled(MEMORY_V3_LIVE, config);
+  if (!v3Enabled) return basePrompt;
+
+  try {
+    const pageIndex = await getPageIndex(getWorkspaceDir());
+    const pageLeaves = new Map<Slug, LeafPath[]>();
+    const allSlugs: Slug[] = [];
+    for (const entry of pageIndex.entries) {
+      pageLeaves.set(entry.slug, entry.leaves);
+      allSlugs.push(entry.slug);
+    }
+
+    const dataDir = resolveDataDir();
+    const [tree, core] = await Promise.all([
+      loadLeafTree(dataDir, pageLeaves),
+      loadCore(dataDir),
+    ]);
+
+    const report = computeV3Health({ tree, allSlugs, core });
+    const healthBlock = renderV3Health(report);
+    if (healthBlock.length === 0) return basePrompt;
+    return `${healthBlock}\n\n${basePrompt}`;
+  } catch (err) {
+    log.warn(
+      { err: err instanceof Error ? err.message : String(err) },
+      "consolidation: v3 health computation failed; using base prompt",
+    );
+    return basePrompt;
+  }
+}
+
 /**
  * Read `memory/buffer.md`. Missing file → empty string so the skip-on-empty
  * branch doesn't have to distinguish "no file" from "blank file".

package/src/memory/v2/harness/metrics.ts

@@ -36,6 +36,10 @@ export interface AggregateEval {
 /**
  * recall@k = |topK(selected) ∩ G| / |G|. An empty ground-truth set is defined
  * as recall 1 (nothing to recall — vacuously complete).
+ *
+ * The top-k window is deduped before intersecting with the ground-truth set so
+ * a retriever that emits the same slug twice (e.g. `['a','a']`) cannot count it
+ * twice and push recall above 1.0. Recall is therefore bounded in [0, 1].
  */
 export function recallAtK(
   selected: readonly string[],
@@ -44,7 +48,7 @@ export function recallAtK(
 ): number {
   if (groundTruth.size === 0) return 1;
   let hit = 0;
-  for (const slug of selected.slice(0, k)) {
+  for (const slug of new Set(selected.slice(0, k))) {
     if (groundTruth.has(slug)) hit++;
   }
   return hit / groundTruth.size;

package/src/memory/v2/harness/replay-input.ts

@@ -10,8 +10,10 @@
  *  - `nowText`: read from current workspace files (`loadNowText`). NOT stored
  *    in the log, so it may differ from what the live turn saw —
  *    always-approximate; see `ReconstructionMeta.nowReconstructedFromCurrent`.
- *  - `priorEverInjected`: the union of injected / in_context slugs from earlier
- *    `mode='router'` logs in the same conversation (turn < target).
+ *  - `priorEverInjected`: the union of retained slugs from earlier
+ *    `mode='router'` logs in the same conversation (turn < target). Retained
+ *    statuses mirror production's `everInjected` (injected / in_context, plus
+ *    page_missing / corrupt — see `PRIOR_STATUSES`).
  *
  * The anchor is the turn's assistant reply; the messages the router saw are
  * those strictly before it, so we fetch a bounded recent window up to the
@@ -172,7 +174,21 @@ export async function reconstructInput(
   };
 }
 
-const PRIOR_STATUSES = new Set<string>(["injected", "in_context"]);
+// Production's `everInjected` retains a slug once it is rendered, EXCEPT for
+// missing synthetic slugs (skills/CLI commands whose capability cache is empty
+// — see `missingSyntheticSlugs` in `injection.ts`). Concept pages that turn out
+// `page_missing` or `corrupt` at render time are still retained so they aren't
+// re-attempted every turn (see the `page_missing ... DOES land in everInjected`
+// case in `injection.test.ts`). The replay must mirror that retention or it
+// builds a narrower prior-state than live routing, skewing comparisons. Missing
+// synthetic slugs never enter the missing/corrupt buckets — they log as
+// `injected` — so widening here introduces no new synthetic-slug discrepancy.
+const PRIOR_STATUSES = new Set<string>([
+  "injected",
+  "in_context",
+  "page_missing",
+  "corrupt",
+]);
 
 /**
  * Union of slugs injected on earlier `mode='router'` turns in this conversation

package/src/memory/v2/harness/runner.ts

@@ -74,6 +74,12 @@ export async function runComparison(
     }
     turnsScored++;
 
+    // Thread the abort signal into the reconstructed input so retrievers that
+    // wrap LLM calls (e.g. the router retriever forwarding to `runRouter`) abort
+    // the in-flight per-turn call on caller disconnect — the loop gating below
+    // only stops scheduling new work, it can't cancel the current retrieval.
+    if (signal) reconstructed.input.signal = signal;
+
     const byRetriever: Record<string, TurnEval> = {};
     for (const retriever of retrievers) {
       if (signal?.aborted) break;

package/src/memory/v2/harness/trace.ts

@@ -41,6 +41,12 @@ export interface GateDecision {
   decision: "ready" | "more";
   /** When "more", the generated follow-up queries seeding the next pass. */
   questions?: string[];
+  /**
+   * The gate's one-line rationale for this verdict, when it supplied one.
+   * Surfaced in the descent trace and the live-shadow telemetry so a run can be
+   * analyzed after the fact ("why did the gate keep this set?").
+   */
+  reasoning?: string;
 }
 
 /** Everything that happened on one pass of the loop. */

package/src/memory/v2/migration.ts

@@ -337,9 +337,11 @@ export async function synthesizeConceptPage(
         `Synthesize a single concept page from these v1 sources. Slug hint: \`${cluster.slugHint}\`.\n\n${sourceListing}`,
       ),
     ],
-    [],
-    systemPrompt,
-    { config: { callSite: "memoryV2Migration" as const } },
+    {
+      tools: [],
+      systemPrompt,
+      config: { callSite: "memoryV2Migration" as const },
+    },
   );
   const body = extractText(response);
 

package/src/memory/v2/page-index.ts

@@ -55,6 +55,11 @@ export interface PageIndexEntry {
   summary: string;
   /** Numeric IDs of outgoing edges, in sorted order. */
   edges: number[];
+  /**
+   * Leaf slugs declared in the page's `leaves:` frontmatter; `[]` when absent.
+   * Synthetic entries (skills, CLI commands) never declare leaves.
+   */
+  leaves: string[];
   /**
    * File mtime in epoch ms; 0 for synthetic entries (skills, CLI commands)
    * that have no on-disk source file. Used by `splitTier1` to rank pages
@@ -118,6 +123,7 @@ export async function getPageIndex(workspaceDir: string): Promise<PageIndex> {
     slug: string;
     summary: string;
     outgoingSlugs: string[];
+    leaves: string[];
     modifiedAt: number;
   }
 
@@ -177,6 +183,7 @@ export async function getPageIndex(workspaceDir: string): Promise<PageIndex> {
       slug,
       summary: normalizeSummary(summarySource),
       outgoingSlugs: page.frontmatter.edges,
+      leaves: page.frontmatter.leaves ?? [],
       modifiedAt: mtimeMs,
     });
   }
@@ -186,6 +193,7 @@ export async function getPageIndex(workspaceDir: string): Promise<PageIndex> {
       slug: `${SKILL_SLUG_PREFIX}${entry.id}`,
       summary: normalizeSummary(entry.content),
       outgoingSlugs: [],
+      leaves: [],
       modifiedAt: 0,
     });
   }
@@ -195,6 +203,7 @@ export async function getPageIndex(workspaceDir: string): Promise<PageIndex> {
       slug: `${CLI_COMMAND_SLUG_PREFIX}${entry.id}`,
       summary: normalizeSummary(entry.description),
       outgoingSlugs: [],
+      leaves: [],
       modifiedAt: 0,
     });
   }
@@ -210,6 +219,7 @@ export async function getPageIndex(workspaceDir: string): Promise<PageIndex> {
       slug: draft.slug,
       summary: draft.summary,
       edges: [],
+      leaves: draft.leaves,
       modifiedAt: draft.modifiedAt,
     };
     bySlug.set(entry.slug, entry);
@@ -329,6 +339,7 @@ function buildLocalPageIndex(
       slug: src.slug,
       summary: src.summary,
       edges: [],
+      leaves: src.leaves,
       modifiedAt: src.modifiedAt,
     };
     localBySlug.set(local.slug, local);

package/src/memory/v2/router.ts

@@ -453,19 +453,16 @@ async function runRouterBatch(
 
   let response;
   try {
-    response = await provider.sendMessage(
-      [userMsg],
-      [routerTool],
+    response = await provider.sendMessage([userMsg], {
+      tools: [routerTool],
       systemPrompt,
-      {
-        config: {
-          callSite: "memoryRouter" as const,
-          tool_choice: { type: "tool" as const, name: ROUTER_TOOL_NAME },
-          disableTurnStartCache: true,
-        },
-        ...(signal ? { signal } : {}),
+      config: {
+        callSite: "memoryRouter" as const,
+        tool_choice: { type: "tool" as const, name: ROUTER_TOOL_NAME },
+        disableTurnStartCache: true,
       },
-    );
+      ...(signal ? { signal } : {}),
+    });
   } catch (err) {
     log.warn({ err }, "Router provider call threw; treating as api_error");
     return emptyBatchResult("api_error");

package/src/memory/v2/sweep-job.ts

@@ -76,7 +76,7 @@ const MAX_BUFFER_CHARS = 16_000;
 // returns the tool input as `unknown`. The two must stay in sync.
 const SWEEP_TOOL_NAME = "emit_remember_entries";
 
-const SWEEP_TOOL: ToolDefinition = {
+const SWEEP_TOOL = {
   name: SWEEP_TOOL_NAME,
   description:
     "Emit zero or more remember()-style entries the assistant should commit to long-term memory.",
@@ -92,7 +92,7 @@ const SWEEP_TOOL: ToolDefinition = {
     },
     required: ["entries"],
   },
-};
+} satisfies ToolDefinition;
 
 const SweepResultSchema = z.object({
   entries: z.array(z.string()),
@@ -154,17 +154,14 @@ export async function memoryV2SweepJob(
       `## existingBuffer\n\n${existingBuffer || "(empty)"}\n\n` +
       `## recentMessages\n\n${recentText}`;
 
-    const response = await provider.sendMessage(
-      [userMessage(userText)],
-      [SWEEP_TOOL],
+    const response = await provider.sendMessage([userMessage(userText)], {
+      tools: [SWEEP_TOOL],
       systemPrompt,
-      {
-        config: {
-          callSite: "memoryV2Sweep" as const,
-          tool_choice: { type: "tool" as const, name: SWEEP_TOOL_NAME },
-        },
+      config: {
+        callSite: "memoryV2Sweep" as const,
+        tool_choice: { type: "tool" as const, name: SWEEP_TOOL_NAME },
       },
-    );
+    });
 
     const toolBlock = extractToolUse(response);
     if (!toolBlock || toolBlock.name !== SWEEP_TOOL_NAME) {

package/src/memory/v2/types.ts

@@ -40,6 +40,7 @@ export const ConceptPageFrontmatterSchema = z
     ref_files: z.array(z.string()).default([]),
     ref_urls: z.array(z.string().url()).default([]),
     summary: z.string().optional(),
+    leaves: z.array(z.string()).optional(),
   })
   .strict();
 

package/src/messaging/providers/slack/render-transcript.test.ts

@@ -200,7 +200,7 @@ describe("renderSlackTranscript — basics", () => {
         "user",
         "[mar 4 2026 8:37 PM MT aaron] nm, i wonder how my assistant is doing",
       ),
-      textMsg("assistant", "[mar 4 2026 8:38 PM MT assistant] i'm good"),
+      textMsg("assistant", "i'm good"),
       textMsg("user", "[mar 4 2026 8:39 PM MT jordan (ET)] ayeeeee"),
     ]);
   });

package/src/messaging/providers/slack/render-transcript.ts

@@ -348,7 +348,7 @@ function maxNullableSlackTs(a: string | null, b: string | null): string | null {
 function renderMessage(msg: RenderableSlackMessage): string {
   const meta = msg.metadata;
 
-  if (msg.role === "assistant" && !hasTimestampTimezone(meta)) {
+  if (msg.role === "assistant") {
     if (msg.metadata?.deletedAt !== undefined) return "[deleted]";
     return appendSlackFileMarkers(msg.content, msg.metadata?.slackFiles);
   }
@@ -704,7 +704,7 @@ export function renderSlackTranscriptWithProvenance(
       },
       sourceChannelTs: meta?.channelTs ?? null,
       tagLineProvenance:
-        hasRenderedText && hasTimestampTimezone(meta)
+        m.role !== "assistant" && hasRenderedText && hasTimestampTimezone(meta)
           ? "slack-timezone-message"
           : "none",
     });

package/src/messaging/style-analyzer.ts

@@ -49,7 +49,7 @@ Also identify recurring contacts (people appearing in 3+ messages) and note how
 
 You MUST respond using the \`store_style_analysis\` tool. Do not respond with text.`;
 
-const storeStyleAnalysisTool: ToolDefinition = {
+const storeStyleAnalysisTool = {
   name: "store_style_analysis",
   description:
     "Store extracted writing style patterns and relationship observations",
@@ -94,7 +94,7 @@ const storeStyleAnalysisTool: ToolDefinition = {
     },
     required: ["style_patterns"],
   },
-};
+} satisfies ToolDefinition;
 
 /**
  * Build a text corpus from provider messages for LLM analysis.
@@ -143,15 +143,12 @@ export async function extractStylePatterns(
     },
   ];
 
-  const response = await provider.sendMessage(
-    promptMessages,
-    [storeStyleAnalysisTool],
-    STYLE_EXTRACTION_SYSTEM_PROMPT,
-    {
-      signal: AbortSignal.timeout(30_000),
-      config: { callSite: "styleAnalyzer" },
-    },
-  );
+  const response = await provider.sendMessage(promptMessages, {
+    tools: [storeStyleAnalysisTool],
+    systemPrompt: STYLE_EXTRACTION_SYSTEM_PROMPT,
+    signal: AbortSignal.timeout(30_000),
+    config: { callSite: "styleAnalyzer" },
+  });
 
   const toolBlock = response.content.find((b) => b.type === "tool_use");
   if (!toolBlock || toolBlock.type !== "tool_use") {

package/src/notifications/__tests__/emit-signal-home-feed.test.ts

@@ -34,6 +34,7 @@ mock.module("../../home/feed-writer.js", () => ({
 // home-feed-side-effect.ts only consumes `getConversation`.
 mock.module("../../memory/conversation-crud.js", () => ({
   getConversation: () => conversationRow,
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 
 // Stub the broadcaster so emit-signal's `getBroadcaster()` does not need

package/src/notifications/__tests__/home-feed-side-effect.test.ts

@@ -30,6 +30,7 @@ mock.module("../../memory/conversation-crud.js", () => ({
     }
     return conversationRow;
   },
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 
 const { writeHomeFeedItemForSignal } =

package/src/notifications/adapters/slack.ts

@@ -16,6 +16,8 @@ import type {
   ChannelAdapter,
   ChannelDeliveryPayload,
   ChannelDestination,
+  ChannelUpdateContext,
+  ChannelUpdatePayload,
   DeliveryResult,
   NotificationChannel,
 } from "../types.js";
@@ -52,9 +54,7 @@ function resolveSlackMessageText(payload: ChannelDeliveryPayload): string {
  * - Optional context: message preview
  * - Context: approval code instructions + invite directive
  */
-function buildAccessRequestBlocks(
-  payload: Record<string, unknown>,
-): unknown[] {
+function buildAccessRequestBlocks(payload: Record<string, unknown>): unknown[] {
   const blocks: unknown[] = [];
 
   // Header
@@ -209,19 +209,18 @@ export class SlackAdapter implements ChannelAdapter {
       payload.contextPayload != null;
 
     try {
-      if (isAccessRequest) {
-        const blocks = buildAccessRequestBlocks(payload.contextPayload!);
-        await sendSlackReply(chatId, messageText, { blocks });
-      } else {
-        await sendSlackReply(chatId, messageText, { useBlocks: true });
-      }
+      const result = isAccessRequest
+        ? await sendSlackReply(chatId, messageText, {
+            blocks: buildAccessRequestBlocks(payload.contextPayload!),
+          })
+        : await sendSlackReply(chatId, messageText, { useBlocks: true });
 
       log.info(
-        { sourceEventName: payload.sourceEventName, chatId },
+        { sourceEventName: payload.sourceEventName, chatId, ts: result.ts },
         "Slack notification delivered",
       );
 
-      return { success: true };
+      return { success: true, messageId: result.ts };
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
       log.error(
@@ -231,4 +230,39 @@ export class SlackAdapter implements ChannelAdapter {
       return { success: false, error: message };
     }
   }
+
+  async update(
+    delivery: ChannelUpdateContext,
+    patch: ChannelUpdatePayload,
+  ): Promise<DeliveryResult> {
+    if (!delivery.messageId) {
+      return {
+        success: false,
+        error:
+          "missing_message_id: this delivery has no captured Slack ts (sent before edit support landed)",
+      };
+    }
+    const text = patch.body?.trim() || patch.title?.trim();
+    if (!text) {
+      return { success: false, error: "no body or title supplied for update" };
+    }
+    try {
+      const result = await sendSlackReply(delivery.destination, text, {
+        messageTs: delivery.messageId,
+        useBlocks: true,
+      });
+      log.info(
+        { chatId: delivery.destination, messageTs: delivery.messageId },
+        "Slack notification updated",
+      );
+      return { success: true, messageId: result.ts ?? delivery.messageId };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      log.error(
+        { err, chatId: delivery.destination, messageTs: delivery.messageId },
+        "Failed to update Slack notification",
+      );
+      return { success: false, error: message };
+    }
+  }
 }