@vellumai/assistant 0.7.3 → 0.8.1

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

@@ -82,15 +82,44 @@ export async function save(
  * The child row inherits everInjected as-is so previously-attached slugs are
  * not re-injected on the child's first turn — matching the v1 semantics where
  * a fork carries over all in-context memories.
+ *
+ * Synchronous so it can run inside the bun:sqlite transaction that wraps
+ * `forkConversation()` — keeping the state copy atomic with the message and
+ * attachment copies.
  */
-export async function fork(
+export function forkActivationState(
   database: DrizzleDb,
   parentConversationId: string,
   newConversationId: string,
-): Promise<void> {
-  const parent = await hydrate(database, parentConversationId);
-  if (!parent) return;
-  await save(database, newConversationId, parent);
+): void {
+  const row = database
+    .select()
+    .from(activationState)
+    .where(eq(activationState.conversationId, parentConversationId))
+    .get();
+  if (!row) return;
+
+  database
+    .insert(activationState)
+    .values({
+      conversationId: newConversationId,
+      messageId: row.messageId,
+      stateJson: row.stateJson,
+      everInjectedJson: row.everInjectedJson,
+      currentTurn: row.currentTurn,
+      updatedAt: row.updatedAt,
+    })
+    .onConflictDoUpdate({
+      target: activationState.conversationId,
+      set: {
+        messageId: row.messageId,
+        stateJson: row.stateJson,
+        everInjectedJson: row.everInjectedJson,
+        currentTurn: row.currentTurn,
+        updatedAt: row.updatedAt,
+      },
+    })
+    .run();
 }
 
 /**

package/src/memory/v2/activation.ts

@@ -36,15 +36,13 @@
 
 import type { AssistantConfig } from "../../config/types.js";
 import { applyCorrectionIfCalibrated } from "../anisotropy.js";
-import {
-  embedWithBackend,
-  generateSparseEmbedding,
-} from "../embedding-backend.js";
+import { embedWithBackend } from "../embedding-backend.js";
 import { clampUnitInterval } from "../validation.js";
 import type { EdgeIndex } from "./edge-index.js";
 import { hybridQueryConceptPages } from "./qdrant.js";
 import { rerankCandidates } from "./reranker.js";
 import { simBatch } from "./sim.js";
+import { generateBm25QueryEmbedding } from "./sparse-bm25.js";
 import type { ActivationState, EverInjectedEntry } from "./types.js";
 
 /**
@@ -125,12 +123,13 @@ export async function selectCandidates(
 
   // (2) ANN top-50 against the concatenated turn text. Pure whitespace joins
   // (no separators) keep the embedding behavior aligned with how callers
-  // would naturally read the three texts together.
+  // would naturally read the three texts together. Whitespace-only channels
+  // contribute no semantic content, so trim before deciding whether to embed.
   const annQueryText = [userText, assistantText, nowText]
-    .filter((s) => s.length > 0)
+    .filter((s) => s.trim().length > 0)
     .join("\n");
 
-  if (annQueryText.length > 0) {
+  if (annQueryText.trim().length > 0) {
     throwIfAborted(signal);
     const denseResult = await embedWithBackend(config, [annQueryText], {
       signal,
@@ -141,7 +140,7 @@ export async function selectCandidates(
       denseResult.model,
     );
     throwIfAborted(signal);
-    const sparse = generateSparseEmbedding(annQueryText);
+    const sparse = generateBm25QueryEmbedding(annQueryText);
     const limit =
       config.memory.v2.ann_candidate_limit ?? UNLIMITED_ANN_CANDIDATE_LIMIT;
     const hits = await hybridQueryConceptPages(dense, sparse, limit);
@@ -202,17 +201,19 @@ interface ComputeOwnActivationResult {
  *          + c_user · sim_u + c_assistant · sim_a + c_now · sim_n
  *          + c_user · α · r_norm_u + c_assistant · α · r_norm_a
  * over the candidate set, where the rerank terms only fire for slugs that
- * land in the unified top-K-by-pre-rerank-A_o window. Returns a sparse map
- * keyed by slug; slugs whose computed value rounds to 0 are still included
- * so callers can see the candidate set explicitly. Also returns a per-slug
- * breakdown of the raw inputs (decayed prior + raw sims + rerank deltas) so
- * callers can render contribution diagnostics without re-running the math.
+ * land in the unified top-K window. The pool is ranked by the rerank-eligible
+ * channels alone (`c_user · sim_u + c_assistant · sim_a`) so prior- or
+ * NOW-heavy slugs — which can't gain from rerank — don't starve out
+ * genuinely user/assistant-relevant slugs. Returns a sparse map keyed by
+ * slug; slugs whose computed value rounds to 0 are still included so callers
+ * can see the candidate set explicitly. Also returns a per-slug breakdown of
+ * the raw inputs (decayed prior + raw sims + rerank deltas) so callers can
+ * render contribution diagnostics without re-running the math.
  *
  * The three `simBatch` calls run concurrently — they hit independent named
  * vectors and embed independent query texts. Cross-encoder rerank then runs
- * once on the unified top-K (selected by pre-rerank A_o, not per-channel
- * fused sim) so an entry strong in both channels can't double-boost itself
- * past entries that only land in one channel.
+ * once on the unified top-K so an entry strong in both channels can't
+ * double-boost itself past entries that only land in one channel.
  */
 export async function computeOwnActivation(
   params: ComputeOwnActivationParams,
@@ -248,8 +249,16 @@ export async function computeOwnActivation(
     simU: number;
     simA: number;
     simN: number;
-    /** Pre-rerank A_o; ranking signal for the unified rerank pool. */
+    /** Pre-rerank A_o; full sum used for the final activation value. */
     preRerank: number;
+    /**
+     * Ranking signal for the unified rerank pool — only the channels that
+     * actually participate in rerank (user + assistant). Excluding
+     * `priorContribution` and `c_now * simN` prevents prior- or NOW-heavy
+     * slugs from consuming the rerank budget despite being ineligible for
+     * cross-encoder gains.
+     */
+    rerankPoolScore: number;
   }
   const inputs: SlugInputs[] = slugList.map((slug) => {
     const prev = priorState?.state[slug] ?? 0;
@@ -257,23 +266,24 @@ export async function computeOwnActivation(
     const simA = simAssistant.get(slug) ?? 0;
     const simN = simNow.get(slug) ?? 0;
     const priorContribution = d * prev;
+    const rerankPoolScore = c_user * simU + c_assistant * simA;
     return {
       slug,
       priorContribution,
       simU,
       simA,
       simN,
-      preRerank:
-        priorContribution + c_user * simU + c_assistant * simA + c_now * simN,
+      preRerank: priorContribution + rerankPoolScore + c_now * simN,
+      rerankPoolScore,
     };
   });
 
-  // Unified top-K by pre-rerank A_o. Both channels rerank against the **same**
-  // slug set, so a slug strong on user can't crowd out one strong on assistant
-  // by virtue of appearing in both per-channel top-Ks. Both channel queries
-  // ride in a single `rerankCandidates` call so the worker tokenizes and
-  // forward-passes them together — half the per-call overhead of two
-  // serialised round-trips.
+  // Unified top-K by rerank-eligible signal only. Both channels rerank against
+  // the **same** slug set, so a slug strong on user can't crowd out one strong
+  // on assistant by virtue of appearing in both per-channel top-Ks. Both
+  // channel queries ride in a single `rerankCandidates` call so the worker
+  // tokenizes and forward-passes them together — half the per-call overhead
+  // of two serialised round-trips.
   let userRerankBoost: ReadonlyMap<string, number> = new Map();
   let assistantRerankBoost: ReadonlyMap<string, number> = new Map();
   let inPoolSet: ReadonlySet<string> = new Set();
@@ -282,17 +292,20 @@ export async function computeOwnActivation(
     throwIfAborted(signal);
     const topSlugs = inputs
       .slice()
-      .sort((a, b) => b.preRerank - a.preRerank)
+      .sort((a, b) => b.rerankPoolScore - a.rerankPoolScore)
       .slice(0, rerankCfg.top_k)
       .map((e) => e.slug);
     if (topSlugs.length > 0) {
-      inPoolSet = new Set(topSlugs);
       const [userScores, assistantScores] = await rerankCandidates(
         [userText, assistantText],
         topSlugs,
         config,
       );
       throwIfAborted(signal);
+      // Build the pool from slugs the cross-encoder actually scored, so a
+      // backend failure (which yields empty maps) doesn't mislabel candidates
+      // as `inRerankPool` in the inspector.
+      inPoolSet = new Set([...userScores.keys(), ...assistantScores.keys()]);
       userRerankBoost = normalizeRerankScores(userScores, rerankCfg.alpha);
       assistantRerankBoost = normalizeRerankScores(
         assistantScores,

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

@@ -7,8 +7,7 @@
 //
 //   - `memory_v2_migrate`              — one-shot v1→v2 synthesis (PR 16).
 //   - `memory_v2_reembed`              — fan out an `embed_concept_page` job
-//     per slug, plus four reserved-slug jobs for the meta files
-//     (`__essentials__`, `__threads__`, `__recent__`, `__buffer__`).
+//     per concept-page slug.
 //   - `memory_v2_activation_recompute` — recompute persisted activation
 //     state for every conversation, no rendering. Used after consolidation
 //     replaces or deletes pages that other conversations still reference.
@@ -19,9 +18,6 @@
 // the same code paths exercised by tests of those modules run unchanged when
 // a backfill kicks them off.
 
-import { readFile } from "node:fs/promises";
-import { join } from "node:path";
-
 import type { AssistantConfig } from "../../config/types.js";
 import { getLogger } from "../../util/logger.js";
 import { getWorkspaceDir } from "../../util/platform.js";
@@ -30,6 +26,7 @@ import { listConversations } from "../conversation-queries.js";
 import { getDb } from "../db-connection.js";
 import { enqueueEmbedConceptPageJob } from "../jobs/embed-concept-page.js";
 import type { MemoryJob } from "../jobs-store.js";
+import { stringifyMessageContent } from "../message-content.js";
 import {
   computeOwnActivation,
   selectCandidates,
@@ -41,25 +38,11 @@ import {
   MigrationAlreadyAppliedError,
   runMemoryV2Migration,
 } from "./migration.js";
+import { loadNowText } from "./now-text.js";
 import { listPages } from "./page-store.js";
 
 const log = getLogger("memory-v2-backfill");
 
-/**
- * Reserved slugs the reembed job enqueues alongside the concept-page slugs.
- * These name the four prose meta files (essentials/threads/recent/buffer)
- * loaded into the system prompt by PR 11. Embedding them is forward-looking
- * — the existing `embed-concept-page` handler treats unknown slugs as
- * deletions (a no-op when no embedding exists), so enqueueing here is safe
- * regardless of whether the meta files are ever embedded for retrieval.
- */
-export const META_FILE_SLUGS = [
-  "__essentials__",
-  "__threads__",
-  "__recent__",
-  "__buffer__",
-] as const;
-
 // ---------------------------------------------------------------------------
 // memory_v2_migrate — wraps runMemoryV2Migration
 // ---------------------------------------------------------------------------
@@ -106,16 +89,22 @@ export async function memoryV2MigrateJob(
 }
 
 // ---------------------------------------------------------------------------
-// memory_v2_reembed — fan out embed jobs for every page + meta file
+// memory_v2_reembed — fan out embed jobs for every concept page
 // ---------------------------------------------------------------------------
 
 /**
- * Job handler: enqueue an `embed_concept_page` job per concept-page slug, plus
- * one job per reserved meta-file slug ({@link META_FILE_SLUGS}).
+ * Job handler: enqueue an `embed_concept_page` job per concept-page slug.
+ *
+ * Returns the total number of jobs enqueued. Callers (and tests) use the
+ * return value to assert progress without inspecting the job table directly.
  *
- * Returns the total number of jobs enqueued — `concept-page count + 4`.
- * Callers (and tests) use the return value to assert progress without
- * inspecting the job table directly.
+ * Note on meta files: `essentials.md` / `threads.md` / `recent.md` /
+ * `buffer.md` are direct-injected into the system prompt every turn via
+ * `_autoinject.md`. They are NOT enqueued for embedding here — their slugs
+ * (`__essentials__` etc.) contain underscores that the concept-page slug
+ * validator rejects (`[a-z0-9][a-z0-9-]*`), and they live at `memory/<name>.md`
+ * rather than `memory/concepts/<name>.md`, so path resolution would also miss.
+ * Embedding them would be redundant with the direct injection regardless.
  */
 export async function memoryV2ReembedJob(
   _job: MemoryJob,
@@ -127,16 +116,12 @@ export async function memoryV2ReembedJob(
   for (const slug of slugs) {
     enqueueEmbedConceptPageJob({ slug });
   }
-  for (const slug of META_FILE_SLUGS) {
-    enqueueEmbedConceptPageJob({ slug });
-  }
 
-  const total = slugs.length + META_FILE_SLUGS.length;
   log.info(
-    { conceptPages: slugs.length, metaFiles: META_FILE_SLUGS.length, total },
+    { conceptPages: slugs.length, total: slugs.length },
     "Memory v2 reembed enqueued",
   );
-  return total;
+  return slugs.length;
 }
 
 // ---------------------------------------------------------------------------
@@ -303,55 +288,3 @@ function lastExchangeTexts(conversationId: string): {
   }
   return { userText, assistantText };
 }
-
-/**
- * Coerce stored message content (JSON-serialized `ContentBlock[]` *or* plain
- * string in legacy rows) into a single text string. Image / tool blocks are
- * dropped — recompute only needs the spoken text.
- */
-function stringifyMessageContent(stored: string): string {
-  let parsed: unknown;
-  try {
-    parsed = JSON.parse(stored);
-  } catch {
-    return stored.trim();
-  }
-  if (typeof parsed === "string") return parsed.trim();
-  if (!Array.isArray(parsed)) return "";
-  const parts: string[] = [];
-  for (const block of parsed) {
-    if (
-      block &&
-      typeof block === "object" &&
-      (block as { type?: string }).type === "text" &&
-      typeof (block as { text?: unknown }).text === "string"
-    ) {
-      parts.push((block as { text: string }).text);
-    }
-  }
-  return parts.join("\n").trim();
-}
-
-/**
- * Read the prose meta files that compose the "NOW" context the activation
- * pipeline correlates against. Mirrors the autoload order in
- * `system-prompt.ts` so the same prose drives both injection and recompute.
- * Missing or unreadable files are treated as empty.
- */
-async function loadNowText(workspaceDir: string): Promise<string> {
-  const filenames = ["essentials.md", "threads.md", "recent.md"];
-  const reads = await Promise.all(
-    filenames.map(async (filename) => {
-      try {
-        const text = await readFile(
-          join(workspaceDir, "memory", filename),
-          "utf-8",
-        );
-        return text.trim();
-      } catch {
-        return "";
-      }
-    }),
-  );
-  return reads.filter((part) => part.length > 0).join("\n\n");
-}

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

@@ -6,17 +6,17 @@
  * rewrites `memory/recent.md`, promotes new essentials/threads, and trims the
  * buffer down to entries that arrived after the run started.
  *
- * Unlike `sweep`, consolidation runs as the assistant: `wakeAgentForOpportunity()`
- * loads the standard system prompt (SOUL.md + IDENTITY.md + persona + memory/*
- * autoloads) and the standard tool surface (read_file, write_file, edit_file,
- * list_files, bash). The hint string carries the prompt body from §10 of the
- * design doc with the cutoff timestamp templated in. Care, judgment, and the
+ * Consolidation runs as the assistant: `runBackgroundJob()` bootstraps a
+ * background conversation and routes the cutoff-templated prompt through
+ * `processMessage`, so the standard system prompt (SOUL.md + IDENTITY.md +
+ * persona + memory/* autoloads) and tool surface (read_file, write_file,
+ * edit_file, list_files, bash) are loaded. Care, judgment, and the
  * assistant's voice are the point — there is no "consolidator persona" to
  * substitute in.
  *
  * Lifecycle:
- *   1. Bail if the `memory-v2-enabled` feature flag is off (the worker may
- *      have claimed a stale row at flag-flip time).
+ *   1. Bail if `config.memory.v2.enabled` is false (the worker may have
+ *      claimed a stale row from before v2 was disabled).
  *   2. Acquire a single-process lock at `memory/.v2-state/consolidation.lock`
  *      so two overlapping schedule windows can't fight over the same files.
  *      The lock contains the holder's PID + timestamp so a crashed run leaves
@@ -26,21 +26,29 @@
  *      the next pass.
  *   4. Read `memory/buffer.md`. Bail if empty (no work to do, but the lock
  *      and skip path still log so operators can confirm the schedule fired).
- *   5. Bootstrap a background conversation (mirrors `runUpdateBulletinJobIfNeeded`)
- *      and call `wakeAgentForOpportunity()` with the templated hint. The wake
- *      reuses the assistant's full system prompt + tools.
- *   6. On wake success, enqueue `memory_v2_reembed` to re-index any pages the
- *      agent touched. Tracking touched pages via mtime would be more precise
- *      but is fragile across filesystems; the embedder's content-hash cache
- *      makes a conservative full-reembed effectively free. On wake failure
- *      no follow-ups are enqueued — the agent didn't run, so there's nothing
- *      to re-embed.
- *   7. Release the lock.
+ *   5. Hand off to `runBackgroundJob()` with the templated prompt. The runner
+ *      handles bootstrap + processMessage + timeout + error classification,
+ *      and (because we set `suppressFailureNotifications: true`) does NOT
+ *      emit an `activity.failed` notification on transient failures —
+ *      consolidation runs on tight intervals, so a network blip or model
+ *      hiccup should not spam the home feed. Sentry-side reporting is
+ *      unchanged. The prompt body is loaded via `resolveConsolidationPrompt`
+ *      which bounds any operator-provided override to a regular file under
+ *      1 MiB before substitution.
+ *   6. On success, enqueue `memory_v2_reembed` (re-index any pages the agent
+ *      touched). Tracking touched pages via mtime would be more precise but
+ *      is fragile across filesystems; the embedder's content-hash cache makes
+ *      a conservative full-reembed effectively free. On failure no follow-ups
+ *      are enqueued — the agent's writes may be partial and re-embedding
+ *      partial state would be misleading.
+ *   7. Release the lock. If a prior holder's PID is no longer running, the
+ *      stale lock is taken over automatically (single-writer per workspace,
+ *      so a holder whose process died is unambiguously stale).
  *
- * The handler never propagates a wake exception: it logs, cleans up the
- * orphan conversation, releases the lock, and returns `wake_failed` so the
- * next scheduled run can re-attempt. A thrown bootstrap error bubbles up and
- * the jobs-worker treats it as a retryable failure.
+ * The handler never propagates exceptions from the run path — `runBackgroundJob`
+ * absorbs them and returns a structured result. A thrown error before the
+ * runner is invoked (e.g. mkdir failures) bubbles up and the jobs-worker
+ * treats it as a retryable failure.
  */
 
 import {
@@ -53,15 +61,12 @@ 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 { INTERNAL_GUARDIAN_TRUST_CONTEXT } from "../../daemon/trust-context.js";
-import { wakeAgentForOpportunity } from "../../runtime/agent-wake.js";
+import { runBackgroundJob } from "../../runtime/background-job-runner.js";
 import { getLogger } from "../../util/logger.js";
 import { getWorkspaceDir } from "../../util/platform.js";
 import { isProcessAlive } from "../../util/process-liveness.js";
-import { bootstrapConversation } from "../conversation-bootstrap.js";
-import { deleteConversation } from "../conversation-crud.js";
+import { formatBufferTimestamp } from "../graph/tool-handlers.js";
 import {
   enqueueMemoryJob,
   type MemoryJob,
@@ -72,6 +77,17 @@ import { resolveConsolidationPrompt } from "./prompts/consolidation.js";
 
 const log = getLogger("memory-v2-consolidate");
 
+/** Stable identifier surfaced in `runBackgroundJob` logs and notifications. */
+const JOB_NAME = "memory.consolidate";
+
+/**
+ * Hard timeout for the consolidation run. Consolidation reads the buffer,
+ * rewrites several files, and re-encodes essentials/threads — generous
+ * upper bound so a slow run isn't killed mid-edit, but bounded so a stuck
+ * provider can't pin the worker indefinitely.
+ */
+const CONSOLIDATION_TIMEOUT_MS = 15 * 60 * 1000;
+
 /**
  * Follow-up jobs to fan out after a successful consolidation.
  *
@@ -85,14 +101,14 @@ const FOLLOW_UP_JOB_TYPES: readonly MemoryJobType[] = [
 
 /**
  * Job handler. See file header for the full lifecycle. Returns a discriminated
- * union so tests can assert on the path taken (flag-off / locked / empty /
- * invoked) without having to spy on the filesystem.
+ * union so tests can assert on the path taken (disabled / locked / empty /
+ * invoked / failed) without having to spy on the filesystem.
  */
 export type ConsolidationOutcome =
-  | { kind: "flag_off" }
+  | { kind: "disabled" }
   | { kind: "locked"; holder: string }
   | { kind: "empty_buffer" }
-  | { kind: "wake_failed"; reason?: string }
+  | { kind: "run_failed"; reason?: string }
   | {
       kind: "invoked";
       conversationId: string;
@@ -104,9 +120,9 @@ export async function memoryV2ConsolidateJob(
   _job: MemoryJob,
   config: AssistantConfig,
 ): Promise<ConsolidationOutcome> {
-  if (!isAssistantFeatureFlagEnabled("memory-v2-enabled", config)) {
-    log.debug("memory-v2-enabled flag off; consolidation skipped");
-    return { kind: "flag_off" };
+  if (!config.memory.v2.enabled) {
+    log.debug("memory.v2.enabled is false; consolidation skipped");
+    return { kind: "disabled" };
   }
 
   const memoryDir = join(getWorkspaceDir(), "memory");
@@ -122,11 +138,13 @@ export async function memoryV2ConsolidateJob(
   }
 
   try {
-    // Step 2: capture cutoff. ISO-8601 is the convention; it's a total order
-    // string that compares correctly via lexicographic <, which is all the
-    // prompt asks the agent to do. Captured here (not at enqueue time) so
-    // late-claimed rows still get a fresh cutoff.
-    const cutoff = new Date().toISOString();
+    // Step 2: capture cutoff. Formatted to match `buffer.md` entry timestamps
+    // (`Mon D, h:mm AM/PM`, see `formatBufferTimestamp`) so the agent's
+    // "timestamp ≥ cutoff" check compares like-with-like at minute precision.
+    // Same-minute entries land on the next pass — conservative but loss-free.
+    // Captured here (not at enqueue time) so late-claimed rows get a fresh
+    // cutoff.
+    const cutoff = formatBufferTimestamp(new Date());
 
     // Step 3: bail on empty buffer. Nothing for the agent to consolidate.
     // The lock is released in finally below.
@@ -136,57 +154,45 @@ export async function memoryV2ConsolidateJob(
       return { kind: "empty_buffer" };
     }
 
-    // Step 4: bootstrap a background conversation and wake the assistant
-    // with the cutoff-templated prompt. Mirrors the UPDATES.md pattern in
-    // `runUpdateBulletinJobIfNeeded` — the wake runs `mainAgent` against
-    // the assistant's full system prompt, so consolidation thinks and
-    // writes in the assistant's voice.
-    const conversation = bootstrapConversation({
-      conversationType: "background",
+    // Step 4: hand off to the centralized background-job runner. The runner
+    // bootstraps the conversation, drives `processMessage`, applies the
+    // timeout policy, classifies errors, and — because we opt out via
+    // `suppressFailureNotifications` — does NOT emit an `activity.failed`
+    // notification on transient failures. Consolidation runs on tight
+    // intervals; a network blip or model hiccup should not spam the feed.
+    // Sentry-side reporting is unchanged.
+    //
+    // The prompt body comes from `resolveConsolidationPrompt`, which honors
+    // the `memory.v2.consolidation_prompt_path` config override but bounds
+    // 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.
+    const runResult = await runBackgroundJob({
+      jobName: JOB_NAME,
       source: MEMORY_V2_CONSOLIDATION_SOURCE,
+      prompt: resolveConsolidationPrompt(
+        config.memory.v2.consolidation_prompt_path,
+        cutoff,
+      ),
+      trustContext: { sourceChannel: "vellum", trustClass: "guardian" },
+      callSite: "mainAgent",
+      timeoutMs: CONSOLIDATION_TIMEOUT_MS,
       origin: "memory_consolidation",
-      systemHint: "Running memory consolidation",
-      groupId: "system:background",
+      suppressFailureNotifications: true,
     });
 
-    let wakeInvoked = false;
-    let failureReason: string | undefined;
-    try {
-      const result = await wakeAgentForOpportunity({
-        conversationId: conversation.id,
-        hint: resolveConsolidationPrompt(
-          config.memory.v2.consolidation_prompt_path,
-          cutoff,
-        ),
-        source: MEMORY_V2_CONSOLIDATION_SOURCE,
-        trustContext: INTERNAL_GUARDIAN_TRUST_CONTEXT,
-      });
-      wakeInvoked = result.invoked;
-      failureReason = result.reason;
-    } catch (err) {
-      failureReason = err instanceof Error ? err.message : String(err);
+    if (!runResult.ok) {
       log.error(
-        { err, conversationId: conversation.id },
-        "consolidation wake threw; cleaning up and re-enqueuing follow-ups skipped",
+        {
+          conversationId: runResult.conversationId,
+          errorKind: runResult.errorKind,
+          err: runResult.error?.message,
+        },
+        "consolidation run failed; follow-ups skipped",
       );
-    }
-
-    // If the wake never ran (resolver missing, conversation archived,
-    // timeout, exception), clean up the orphan background conversation —
-    // matches the cleanup logic in `runUpdateBulletinJobIfNeeded`. We
-    // do NOT enqueue follow-ups in this branch because no pages changed.
-    if (!wakeInvoked) {
-      try {
-        deleteConversation(conversation.id);
-      } catch (err) {
-        log.warn(
-          { err, conversationId: conversation.id },
-          "consolidation: failed to delete orphan background conversation; continuing",
-        );
-      }
-      return failureReason !== undefined
-        ? { kind: "wake_failed", reason: failureReason }
-        : { kind: "wake_failed" };
+      return runResult.error?.message !== undefined
+        ? { kind: "run_failed", reason: runResult.error.message }
+        : { kind: "run_failed" };
     }
 
     // Step 5: enqueue follow-up jobs. Enqueueing now keeps the dispatch
@@ -208,7 +214,7 @@ export async function memoryV2ConsolidateJob(
 
     log.info(
       {
-        conversationId: conversation.id,
+        conversationId: runResult.conversationId,
         cutoff,
         followUpJobIds,
       },
@@ -216,7 +222,7 @@ export async function memoryV2ConsolidateJob(
     );
     return {
       kind: "invoked",
-      conversationId: conversation.id,
+      conversationId: runResult.conversationId,
       cutoff,
       followUpJobIds,
     };
@@ -336,7 +342,7 @@ function isHolderStale(holder: string): boolean {
 
 /**
  * Idempotent unlink of the lock file. Called from the `finally` block so a
- * crash in the wake path doesn't leave the lock stranded. ENOENT is swallowed
+ * crash in the run path doesn't leave the lock stranded. ENOENT is swallowed
  * because the lock may have been released by an operator or never created
  * (acquire failed before reaching the lock-write step).
  */