@vellumai/assistant 0.10.2-dev.202606250318.5e7cfb0 → 0.10.2

package/src/memory/v2/cli-command-store.ts

@@ -161,23 +161,22 @@ async function runSeedV2CliCommandEntries(generation: number): Promise<void> {
       seeds.push({ id: name, description, content });
     }
 
-    // Sparse (BM25/TF) encoding is computed locally; only the dense vectors
-    // require `embedWithBackend`, which is unconfigured during the cold-start
-    // window before a managed-proxy embedding credential is provisioned. A
-    // dense-embed failure is non-fatal to the in-memory cache: the v3 needle
-    // finder lane reads CLI capabilities from `entries` / the page index, NOT
-    // from Qdrant, so the cache is populated from the local Commander tree
-    // regardless of backend state and commands stay discoverable from first
-    // boot. Only the dense Qdrant upsert is skipped; the managed-credential
-    // reseed and the v3 maintain pass backfill the dense vectors on recovery.
     const nextEntries = new Map<string, CliCommandEntry>();
     let denseVectors: number[][] = [];
-    let denseAvailable = false;
-    let denseError: unknown = null;
     let encodeSparse: (
       input: string,
     ) => ReturnType<typeof generateSparseEmbedding> = generateSparseEmbedding;
     if (seeds.length > 0) {
+      const embedded = await embedWithBackend(
+        config,
+        seeds.map((s) => s.content),
+      );
+      denseVectors = await Promise.all(
+        embedded.vectors.map((v) =>
+          applyCorrectionIfCalibrated(v, embedded.provider, embedded.model),
+        ),
+      );
+
       // CLI commands share the concept-page Qdrant collection, so the sparse
       // vector must use the same stemmed BM25 encoding as the concept-page
       // documents. Fall back to the legacy TF encoder only during the cold-
@@ -191,24 +190,6 @@ async function runSeedV2CliCommandEntries(generation: number): Promise<void> {
               b: config.memory.v2.bm25_b,
             })
           : generateSparseEmbedding(input);
-      try {
-        const embedded = await embedWithBackend(
-          config,
-          seeds.map((s) => s.content),
-        );
-        denseVectors = await Promise.all(
-          embedded.vectors.map((v) =>
-            applyCorrectionIfCalibrated(v, embedded.provider, embedded.model),
-          ),
-        );
-        denseAvailable = true;
-      } catch (err) {
-        denseError = err;
-        log.warn(
-          { err },
-          "Embedding backend unavailable — seeding CLI-command cache without dense Qdrant vectors; the needle lane surfaces commands from the cache and the dense lane backfills when the backend recovers",
-        );
-      }
     }
 
     if (generation !== requestedSeedGeneration) {
@@ -220,17 +201,7 @@ async function runSeedV2CliCommandEntries(generation: number): Promise<void> {
       return;
     }
 
-    // Populate the in-memory cache (and therefore the page index / needle lane)
-    // from the local Commander tree regardless of dense availability.
-    for (const seed of seeds) {
-      nextEntries.set(seed.id, seed);
-    }
-
-    // Write the dense+sparse Qdrant points only when dense vectors were
-    // produced. In the degraded (backend-unavailable) path we skip the upsert
-    // so we never write half-formed points; the dense lane backfills on
-    // recovery.
-    if (seeds.length > 0 && denseAvailable) {
+    if (seeds.length > 0) {
       const now = Date.now();
       await Promise.all(
         seeds.map((seed, i) =>
@@ -243,48 +214,40 @@ async function runSeedV2CliCommandEntries(generation: number): Promise<void> {
           }),
         ),
       );
+      for (const seed of seeds) {
+        nextEntries.set(seed.id, seed);
+      }
     }
 
-    // The CLI tree is always available (no remote catalog), so pruning to clear
-    // stale rows runs whenever we wrote the current set this run OR there was
-    // nothing to embed (empty tree). The cold-start degraded path (commands
-    // present but dense embedding unavailable) skips the prune so we never
-    // reconcile the collection against a set we did not persist. Run the legacy
-    // `kind` backfill once per process so pre-discriminator rows become prunable.
-    if (denseAvailable || seeds.length === 0) {
-      const knownIds = new Set(seeds.map((s) => s.id));
-      if (!legacyKindBackfillDone) {
-        try {
-          await backfillKindOnPointsWithPrefix(
-            CLI_COMMAND_SLUG_PREFIX,
-            CLI_COMMAND_PAYLOAD_KIND,
-            knownIds,
-          );
-          legacyKindBackfillDone = true;
-        } catch (err) {
-          log.warn(
-            { err },
-            "Failed to backfill kind on legacy CLI-command points — pruning may leave orphans this run",
-          );
-        }
+    // The CLI tree is always available (no remote catalog), so pruning is
+    // unconditional. Run the legacy `kind` backfill once per process so
+    // pre-discriminator rows become prunable.
+    const knownIds = new Set(seeds.map((s) => s.id));
+    if (!legacyKindBackfillDone) {
+      try {
+        await backfillKindOnPointsWithPrefix(
+          CLI_COMMAND_SLUG_PREFIX,
+          CLI_COMMAND_PAYLOAD_KIND,
+          knownIds,
+        );
+        legacyKindBackfillDone = true;
+      } catch (err) {
+        log.warn(
+          { err },
+          "Failed to backfill kind on legacy CLI-command points — pruning may leave orphans this run",
+        );
       }
-      await pruneSlugsWithPrefixExcept(
-        CLI_COMMAND_SLUG_PREFIX,
-        seeds.map((s) => s.id),
-        { kind: CLI_COMMAND_PAYLOAD_KIND },
-      );
     }
+    await pruneSlugsWithPrefixExcept(
+      CLI_COMMAND_SLUG_PREFIX,
+      seeds.map((s) => s.id),
+      { kind: CLI_COMMAND_PAYLOAD_KIND },
+    );
 
-    // Atomically replace the cache from the freshly enumerated commands. Drop
-    // the page-index cache so the next router invocation observes the new
-    // command set.
+    // Atomically replace the cache only after every step above succeeds.
     entries = nextEntries;
     invalidatePageIndex();
-
-    // Surface a dense-embed failure to `throwOnError` callers so the existing
-    // retry + maintain machinery backfills the dense lane. The in-memory cache
-    // is already updated above, so the needle lane is fixed regardless.
-    lastSeedError = denseError;
+    lastSeedError = null;
   } catch (err) {
     lastSeedError = err;
     log.warn({ err }, "Failed to seed v2 CLI-command entries");

package/src/memory/v2/prompts/consolidation.ts

@@ -18,9 +18,12 @@
  * the convention established for the sweep prompt.
  */
 
+import { lstatSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { isAbsolute, join } from "node:path";
+
 import { getLogger } from "../../../util/logger.js";
 import { getWorkspaceDir } from "../../../util/platform.js";
-import { loadPromptOverride } from "../../prompt-override.js";
 
 const log = getLogger("memory-v2-consolidate-prompt");
 
@@ -58,6 +61,14 @@ export const CORE_PAGES_CONSOLIDATION_SECTION = `## 10. Review \`memory/core-pag
 
 `;
 
+/**
+ * Upper bound for the override file. Real consolidation prompts are kilobytes;
+ * 1 MiB is generous headroom while preventing a `settings.write` principal from
+ * pointing the field at a multi-gigabyte file (or `/dev/zero`-like stream that
+ * `lstat` can't size cap on its own) and exfiltrating it through the wake hint.
+ */
+const MAX_PROMPT_BYTES = 1 * 1024 * 1024;
+
 /**
  * Consolidation prompt — live-mode only. The agent runs as itself (full
  * SOUL.md + IDENTITY.md + persona + memory autoloads) with the standard
@@ -826,32 +837,90 @@ export function renderConsolidationPrompt(
 /**
  * Load the consolidation prompt template, optionally overridden from the file
  * referenced by `memory.v2.consolidation_prompt_path`, then substitute
- * `{{CUTOFF}}`. File loading (path resolution, size guard, and the permissive
- * fall-back to the bundled prompt on a missing/unreadable/empty/oversized
- * override) is handled by the shared {@link loadPromptOverride}.
+ * `{{CUTOFF}}`. Path-resolution rules are documented on the schema field.
  *
  * Override files get the same placeholder substitutions as the bundled
  * template: `{{CUTOFF}}` always, and `{{CORE_PAGES_SECTION}}` per the same
  * flag gate — so a prompt copied from the bundled source never leaks a raw
  * placeholder, and a customized prompt can opt into the managed section.
+ *
+ * Failure handling is intentionally permissive — missing file, read error, or
+ * empty/whitespace-only body all log a warning and fall back to the bundled
+ * prompt. Consolidation must never break because of a bad override: the
+ * daemon's startup philosophy is "log and recover."
  */
 export function resolveConsolidationPrompt(
   overridePath: string | null,
   cutoff: string,
   options: ConsolidationPromptOptions,
 ): string {
-  const override = loadPromptOverride({
-    overridePath,
-    workspaceDir: getWorkspaceDir(),
-    log,
-    label: "consolidation prompt",
-  });
-  if (override === null) return renderConsolidationPrompt(cutoff, options);
-
-  return override
+  if (overridePath === null) return renderConsolidationPrompt(cutoff, options);
+
+  const resolvedPath = resolveOverridePath(overridePath);
+  let contents: string;
+  try {
+    const stat = lstatSync(resolvedPath);
+    if (!stat.isFile()) {
+      log.warn(
+        {
+          configuredPath: overridePath,
+          resolvedPath,
+          reason: "not_regular_file",
+          fallback: "bundled",
+        },
+        "consolidation prompt override is not a regular file; using bundled prompt",
+      );
+      return renderConsolidationPrompt(cutoff, options);
+    }
+    if (stat.size > MAX_PROMPT_BYTES) {
+      log.warn(
+        {
+          configuredPath: overridePath,
+          resolvedPath,
+          size: stat.size,
+          limit: MAX_PROMPT_BYTES,
+          reason: "oversized_override",
+          fallback: "bundled",
+        },
+        "consolidation prompt override exceeds size limit; using bundled prompt",
+      );
+      return renderConsolidationPrompt(cutoff, options);
+    }
+    contents = readFileSync(resolvedPath, "utf-8");
+  } catch (err) {
+    const code = (err as NodeJS.ErrnoException).code;
+    log.warn(
+      { configuredPath: overridePath, resolvedPath, code, fallback: "bundled" },
+      "consolidation prompt override unreadable; using bundled prompt",
+    );
+    return renderConsolidationPrompt(cutoff, options);
+  }
+
+  if (contents.trim().length === 0) {
+    log.warn(
+      {
+        configuredPath: overridePath,
+        resolvedPath,
+        reason: "empty_override",
+        fallback: "bundled",
+      },
+      "consolidation prompt override is empty; using bundled prompt",
+    );
+    return renderConsolidationPrompt(cutoff, options);
+  }
+
+  return contents
     .replaceAll(CUTOFF_PLACEHOLDER, cutoff)
     .replaceAll(
       CORE_PAGES_PLACEHOLDER,
       options.includeCorePagesSection ? CORE_PAGES_CONSOLIDATION_SECTION : "",
     );
 }
+
+function resolveOverridePath(overridePath: string): string {
+  if (overridePath.startsWith("~/")) {
+    return join(homedir(), overridePath.slice(2));
+  }
+  if (isAbsolute(overridePath)) return overridePath;
+  return join(getWorkspaceDir(), overridePath);
+}

package/src/memory/v2/prompts/router.ts

@@ -22,14 +22,22 @@
  * same placeholder substitution applies to overrides.
  */
 
+import { lstatSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { isAbsolute, join } from "node:path";
+
 import { getLogger } from "../../../util/logger.js";
-import {
-  loadPromptOverride,
-  MAX_PROMPT_OVERRIDE_BYTES,
-} from "../../prompt-override.js";
 
 const log = getLogger("memory-v2-router-prompt");
 
+/**
+ * Hard upper bound on the override file size. The bundled prompt is well
+ * under 4 KiB; 1 MiB is generous-enough for any reasonable hand-edit while
+ * still preventing pathological inputs from being slurped into memory on
+ * every router call.
+ */
+const MAX_PROMPT_BYTES = 1 * 1024 * 1024;
+
 /** Sentinel substituted with the assistant's display name at runtime. */
 const ASSISTANT_NAME_PLACEHOLDER = "{{ASSISTANT_NAME}}";
 
@@ -94,12 +102,14 @@ export function renderRouterPrompt(opts: RenderRouterPromptOpts): string {
 /**
  * Load the router prompt template, optionally overridden from the file
  * referenced by `memory.v2.router.router_prompt_path`, then substitute the
- * standard placeholders. File loading (path resolution, size guard, and the
- * permissive fall-back to the bundled prompt on a missing/unreadable/empty/
- * oversized override) is handled by the shared {@link loadPromptOverride}.
+ * standard placeholders. Path-resolution rules mirror the consolidation
+ * prompt override: absolute paths used as-is, leading `~/` expanded to home,
+ * relative paths resolved under `workspaceDir`.
  *
- * An `inlineOverride` (e.g. the simulator playground) takes precedence over the
- * configured file path; same placeholder substitution and size guard apply.
+ * Failure handling is intentionally permissive — missing file, read error,
+ * oversized file, or empty/whitespace-only body all log a warning and fall
+ * back to the bundled prompt. Router selection must never break because of
+ * a bad override.
  */
 export function resolveRouterPrompt(
   overridePath: string | null,
@@ -107,15 +117,17 @@ export function resolveRouterPrompt(
   opts: RenderRouterPromptOpts,
   inlineOverride?: string | null,
 ): string {
-  // Inline override takes precedence over the configured file path and the
-  // bundled prompt. Empty/whitespace bodies fall through to file/bundled
-  // resolution so a "cleared" textarea is treated as no override.
+  // Inline override (e.g. simulator playground) takes precedence over the
+  // configured file path and the bundled prompt. Same placeholder
+  // substitution + size guard as the file-path branch; empty/whitespace
+  // bodies fall through to file/bundled resolution so a "cleared" textarea
+  // is treated as no override.
   if (inlineOverride !== undefined && inlineOverride !== null) {
-    if (inlineOverride.length > MAX_PROMPT_OVERRIDE_BYTES) {
+    if (inlineOverride.length > MAX_PROMPT_BYTES) {
       log.warn(
         {
           size: inlineOverride.length,
-          limit: MAX_PROMPT_OVERRIDE_BYTES,
+          limit: MAX_PROMPT_BYTES,
           reason: "oversized_inline_override",
           fallback: "path_or_bundled",
         },
@@ -126,13 +138,62 @@ export function resolveRouterPrompt(
     }
   }
 
-  const override = loadPromptOverride({
-    overridePath,
-    workspaceDir,
-    log,
-    label: "router prompt",
-  });
-  return substitutePlaceholders(override ?? ROUTER_PROMPT, opts);
+  if (overridePath === null) return renderRouterPrompt(opts);
+
+  const resolvedPath = resolveOverridePath(overridePath, workspaceDir);
+  let contents: string;
+  try {
+    const stat = lstatSync(resolvedPath);
+    if (!stat.isFile()) {
+      log.warn(
+        {
+          configuredPath: overridePath,
+          resolvedPath,
+          reason: "not_regular_file",
+          fallback: "bundled",
+        },
+        "router prompt override is not a regular file; using bundled prompt",
+      );
+      return renderRouterPrompt(opts);
+    }
+    if (stat.size > MAX_PROMPT_BYTES) {
+      log.warn(
+        {
+          configuredPath: overridePath,
+          resolvedPath,
+          size: stat.size,
+          limit: MAX_PROMPT_BYTES,
+          reason: "oversized_override",
+          fallback: "bundled",
+        },
+        "router prompt override exceeds size limit; using bundled prompt",
+      );
+      return renderRouterPrompt(opts);
+    }
+    contents = readFileSync(resolvedPath, "utf-8");
+  } catch (err) {
+    const code = (err as NodeJS.ErrnoException).code;
+    log.warn(
+      { configuredPath: overridePath, resolvedPath, code, fallback: "bundled" },
+      "router prompt override unreadable; using bundled prompt",
+    );
+    return renderRouterPrompt(opts);
+  }
+
+  if (contents.trim().length === 0) {
+    log.warn(
+      {
+        configuredPath: overridePath,
+        resolvedPath,
+        reason: "empty_override",
+        fallback: "bundled",
+      },
+      "router prompt override is empty; using bundled prompt",
+    );
+    return renderRouterPrompt(opts);
+  }
+
+  return substitutePlaceholders(contents, opts);
 }
 
 function substitutePlaceholders(
@@ -146,3 +207,14 @@ function substitutePlaceholders(
     .replaceAll(USER_NAME_PLACEHOLDER, () => user)
     .replaceAll(PAGE_INDEX_PLACEHOLDER, () => opts.pageIndexBlock);
 }
+
+function resolveOverridePath(
+  overridePath: string,
+  workspaceDir: string,
+): string {
+  if (overridePath.startsWith("~/")) {
+    return join(homedir(), overridePath.slice(2));
+  }
+  if (isAbsolute(overridePath)) return overridePath;
+  return join(workspaceDir, overridePath);
+}

package/src/memory/v2/skill-store.ts

@@ -16,11 +16,8 @@
 //
 // Skill entries are kept in a small in-process cache so the render path can
 // fetch a `SkillEntry` synchronously by id without round-tripping to Qdrant.
-// The cache is replaced atomically from the local catalog at the end of a seed
-// run — including when the dense embedding backend is unavailable, in which
-// case only the dense Qdrant write is deferred so the cache (and the v3 needle
-// lane it feeds) still reflects the current skills. An unexpected error in
-// another step leaves the prior cache intact (skills are best-effort).
+// The cache is replaced atomically at the end of a successful seed run; on
+// error the prior cache stays intact (skills are best-effort).
 
 import { isAssistantFeatureFlagEnabled } from "../../config/assistant-feature-flags.js";
 import { getConfig } from "../../config/loader.js";
@@ -231,26 +228,26 @@ async function runSeedV2SkillEntries(generation: number): Promise<void> {
       );
     }
 
-    // Build the dense + sparse vectors for the Qdrant write. Sparse (BM25/TF)
-    // encoding is computed locally and needs no backend; only the dense vectors
-    // require `embedWithBackend`, which is unconfigured during the cold-start
-    // window before a managed-proxy embedding credential is provisioned.
-    //
-    // A dense-embed failure is non-fatal to the in-memory cache: the v3 needle
-    // finder lane and always-candidate skill pinning read skills from `entries`
-    // / the page index, NOT from Qdrant, so the cache is populated from the
-    // local catalog regardless of backend state and skills stay discoverable
-    // from first boot. Only the dense Qdrant upsert is skipped; the managed-
-    // credential reseed (`maybeReseedCapabilitiesAfterManagedCredential`) and
-    // the v3 maintain pass backfill the dense vectors once the backend recovers.
+    // Embed all content strings in one batched call when there is anything to
+    // embed. Skipping the call when `seeds` is empty avoids throwing on an
+    // unavailable embedding backend in the all-disabled case, so pruning and
+    // cache replacement still run and clear stale state.
     const nextEntries = new Map<string, SkillEntry>();
     let denseVectors: number[][] = [];
-    let denseAvailable = false;
-    let denseError: unknown = null;
     let encodeSparse: (
       input: string,
     ) => ReturnType<typeof generateSparseEmbedding> = generateSparseEmbedding;
     if (seeds.length > 0) {
+      const embedded = await embedWithBackend(
+        config,
+        seeds.map((s) => s.content),
+      );
+      denseVectors = await Promise.all(
+        embedded.vectors.map((v) =>
+          applyCorrectionIfCalibrated(v, embedded.provider, embedded.model),
+        ),
+      );
+
       // Skills share the concept-page Qdrant collection, so the sparse vector
       // must use the same stemmed BM25 encoding the concept-page documents
       // carry — otherwise the stemmed BM25 query vectors used by callers (see
@@ -266,24 +263,6 @@ async function runSeedV2SkillEntries(generation: number): Promise<void> {
               b: config.memory.v2.bm25_b,
             })
           : generateSparseEmbedding(input);
-      try {
-        const embedded = await embedWithBackend(
-          config,
-          seeds.map((s) => s.content),
-        );
-        denseVectors = await Promise.all(
-          embedded.vectors.map((v) =>
-            applyCorrectionIfCalibrated(v, embedded.provider, embedded.model),
-          ),
-        );
-        denseAvailable = true;
-      } catch (err) {
-        denseError = err;
-        log.warn(
-          { err },
-          "Embedding backend unavailable — seeding skill cache without dense Qdrant vectors; the needle lane surfaces skills from the cache and the dense lane backfills when the backend recovers",
-        );
-      }
     }
 
     if (generation !== requestedSeedGeneration) {
@@ -295,17 +274,7 @@ async function runSeedV2SkillEntries(generation: number): Promise<void> {
       return;
     }
 
-    // Populate the in-memory cache (and therefore the page index / needle lane)
-    // from the local catalog regardless of dense availability.
-    for (const seed of seeds) {
-      nextEntries.set(seed.id, seed);
-    }
-
-    // Write Qdrant points only when dense vectors were produced. In the
-    // degraded (backend-unavailable) path we skip Qdrant mutation entirely —
-    // both the upsert and the prune below — so we never write half-formed
-    // points or reconcile the collection against a set we did not persist.
-    if (seeds.length > 0 && denseAvailable) {
+    if (seeds.length > 0) {
       const now = Date.now();
       await Promise.all(
         seeds.map((seed, i) =>
@@ -318,15 +287,16 @@ async function runSeedV2SkillEntries(generation: number): Promise<void> {
           }),
         ),
       );
+      for (const seed of seeds) {
+        nextEntries.set(seed.id, seed);
+      }
     }
 
-    // Prune stale skill slugs. Skip when the catalog is unavailable (empty array
-    // from network failure or cold cache — we cannot enumerate which uninstalled
-    // catalog skills should exist) OR when dense vectors were not written this
-    // run (don't reconcile Qdrant against points we did not refresh). The
-    // `seeds.length === 0` branch still prunes under an available catalog so the
-    // all-disabled case clears stale rows.
-    if (catalogAvailable && (denseAvailable || seeds.length === 0)) {
+    // Prune stale skill slugs. When the catalog is unavailable (empty array
+    // from network failure or cold cache), we cannot enumerate which
+    // uninstalled catalog skills should exist, so skip pruning entirely to
+    // avoid aggressively removing previously-seeded catalog skill embeddings.
+    if (catalogAvailable) {
       // Tag legacy skill points missing `payload.kind` before pruning so the
       // kind-scoped prune can see them. Once-per-process; the backfill is
       // idempotent (server-side `is_empty` filter), so a partial failure
@@ -351,26 +321,19 @@ async function runSeedV2SkillEntries(generation: number): Promise<void> {
         seeds.map((s) => s.id),
         { kind: SKILL_PAYLOAD_KIND },
       );
-    } else if (!catalogAvailable) {
+    } else {
       log.info(
         "Catalog unavailable — skipping skill pruning to preserve prior catalog embeddings",
       );
     }
 
-    // Atomically replace the cache from the freshly enumerated skills. The local
-    // resolution (`resolveSkillStates`) is authoritative, so a skill the config
-    // just disabled or removed drops out here even when the remote catalog is
-    // unavailable. Drop the page-index cache so the next router invocation
-    // observes the new skill set (skill entries share the unified concept-page
-    // collection and surface in the same index).
+    // Atomically replace the cache only after every step above succeeds.
     entries = nextEntries;
+    // Drop the page-index cache so the next router invocation observes the
+    // freshly seeded skill set (skill entries share the unified concept-page
+    // collection and surface in the same index).
     invalidatePageIndex();
-
-    // Surface a dense-embed failure to `throwOnError` callers (the managed-
-    // credential reseed and the operator reembed route) so the existing retry +
-    // maintain machinery backfills the dense lane. The in-memory cache is
-    // already updated above, so the needle lane is fixed regardless.
-    lastSeedError = denseError;
+    lastSeedError = null;
   } catch (err) {
     lastSeedError = err;
     log.warn({ err }, "Failed to seed v2 skill entries");

package/src/notifications/__tests__/broadcaster.test.ts

@@ -27,22 +27,14 @@ mock.module("../copy-composer.js", () => ({
   composeFallbackCopy: () => composeFallbackReturn,
 }));
 
-// Stub only getGuardianDelivery; keep the real selectors so this mock is
-// harmless if it leaks into destination-resolver.test.ts under a shared run.
-const realGuardianReader = await import(
-  "../../contacts/guardian-delivery-reader.js"
-);
-mock.module("../../contacts/guardian-delivery-reader.js", () => ({
-  ...realGuardianReader,
-  getGuardianDelivery: async () => null,
-}));
-
-// Use the real destination-resolver (DB-free via the local-read stub below)
-// so this mock does not leak into destination-resolver.test.ts under a shared
-// bun-test invocation. With no guardian, the resolver still yields a vellum
-// destination, which is all these tests exercise.
-mock.module("../../contacts/contact-store.js", () => ({
-  findGuardianForChannel: () => null,
+mock.module("../destination-resolver.js", () => ({
+  resolveDestinations: (channels: string[]) => {
+    const map = new Map<string, ChannelDestination>();
+    for (const ch of channels) {
+      map.set(ch, { channel: ch as ChannelDestination["channel"] });
+    }
+    return map;
+  },
 }));
 
 mock.module("../conversation-pairing.js", () => ({