@vellumai/assistant 0.10.8 → 0.10.9-dev.202607152225.ec6fdbf

package/src/plugins/defaults/memory/v2/cli-command-content.ts

@@ -15,8 +15,10 @@ import type { CLI_COMMAND_HELP } from "@vellumai/plugin-api";
 
 /** Element type of the plugin-api's declarative CLI help constant. */
 type CliCommandHelp = (typeof CLI_COMMAND_HELP)[number];
+/** Subcommand element type — recursive via its own `subcommands` field. */
+type CliSubcommandHelp = NonNullable<CliCommandHelp["subcommands"]>[number];
 
-export function buildCliCommandContent(
+function buildCliCommandContent(
   name: string,
   description: string,
   helpText: string,
@@ -40,8 +42,33 @@ export function buildCliCommandHelpContent(help: CliCommandHelp): string {
   if (help.helpText) {
     sections.push(help.helpText.trim());
   }
-  for (const sub of help.subcommands ?? []) {
-    const lines = [`${help.name} ${sub.name} — ${sub.description}`];
+  collectSubcommandSections(help.name, help.subcommands, sections);
+  return buildCliCommandContent(
+    help.name,
+    help.description,
+    sections.join("\n\n"),
+  );
+}
+
+/**
+ * Walk the subcommand tree depth-first, emitting one section per subcommand
+ * headed by its full command path (`backup destinations add <path> — …`) so
+ * nested groups index under the phrase a user would actually type.
+ */
+function collectSubcommandSections(
+  path: string,
+  subs: readonly CliSubcommandHelp[] | undefined,
+  sections: string[],
+): void {
+  for (const sub of subs ?? []) {
+    const subPath = `${path} ${sub.name}`;
+    const argSpec =
+      sub.args ?? sub.arguments?.map((argument) => argument.name).join(" ");
+    const heading = `${subPath}${argSpec ? ` ${argSpec}` : ""} — ${sub.description}`;
+    const lines = [heading];
+    for (const argument of sub.arguments ?? []) {
+      lines.push(`  ${argument.name}  ${argument.description}`);
+    }
     const options = renderOptionLines(sub.options);
     if (options) {
       lines.push(options);
@@ -50,12 +77,8 @@ export function buildCliCommandHelpContent(help: CliCommandHelp): string {
       lines.push(sub.helpText.trim());
     }
     sections.push(lines.join("\n"));
+    collectSubcommandSections(subPath, sub.subcommands, sections);
   }
-  return buildCliCommandContent(
-    help.name,
-    help.description,
-    sections.join("\n\n"),
-  );
 }
 
 function renderOptionLines(options: CliCommandHelp["options"]): string | null {
@@ -63,9 +86,17 @@ function renderOptionLines(options: CliCommandHelp["options"]): string | null {
     return null;
   }
   return options
-    .map(
-      (option) =>
-        `  ${option.flags}${option.required ? " (required)" : ""}  ${option.description}`,
-    )
+    .map((option) => {
+      const qualifiers = [
+        option.required ? " (required)" : "",
+        option.choices?.length
+          ? ` (choices: ${option.choices.join(", ")})`
+          : "",
+        option.defaultValue !== undefined
+          ? ` (default: ${option.defaultValue})`
+          : "",
+      ].join("");
+      return `  ${option.flags}${qualifiers}  ${option.description}`;
+    })
     .join("\n");
 }

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

@@ -2,22 +2,26 @@
 // Memory v2 — `assistant` CLI subcommands → embedded capability entries
 // ---------------------------------------------------------------------------
 //
-// Enumerate the top-level `assistant` CLI subcommands, render each as a prose
-// capability statement that wraps the full `helpInformation()` output, embed
-// dense + sparse, and upsert into `memory_v2_concept_pages` under the slug
-// `cli-commands/<name>`. The router scores these alongside concept pages and
-// skill entries; the injection layer surfaces hits under `### CLI Commands
-// You Can Use` so the model can semantically discover a CLI capability it
-// would not otherwise know to reach for.
+// Enumerate the top-level `assistant` CLI commands from their declarative help
+// (`CLI_COMMAND_HELP`, exposed via `@vellumai/plugin-api`), render each as a
+// prose capability statement, embed dense + sparse, and upsert into
+// `memory_v2_concept_pages` under the slug `cli-commands/<name>`. The router
+// scores these alongside concept pages and skill entries; the injection layer
+// surfaces hits under `### CLI Commands You Can Use` so the model can
+// semantically discover a CLI capability it would not otherwise know to reach
+// for.
+//
+// The declarative help is pure data, so the seed reads it without importing the
+// CLI's action graph (`cli/program.ts`) — the graph pulls in provider and
+// workspace modules that were a recurring source of test-mock cascades and
+// circular imports.
 //
 // Mirrors `skill-store.ts` deliberately: same single-flight + generation
 // coalescing, same dense + sparse + corpus-stats-aware sparse encoding, same
 // payload-kind discriminator, same atomic cache replacement. Differences:
-//   - No remote catalog — the source of truth is the local Commander tree.
-//   - No per-entry feature-flag filter — flag gating already happens during
-//     `buildCliProgramTree` (e.g. email/plugins commands are conditionally
-//     registered).
-//   - No MCP-style augmentation — Commander's description is the canonical
+//   - No remote catalog — the source of truth is the declarative CLI help.
+//   - No per-entry feature-flag filter.
+//   - No MCP-style augmentation — the declared description is the canonical
 //     summary.
 
 import { CLI_COMMAND_HELP } from "@vellumai/plugin-api";
@@ -27,10 +31,7 @@ import { generateSparseEmbedding } from "../../../../persistence/embeddings/embe
 import { applyCorrectionIfCalibrated } from "../anisotropy.js";
 import { embedWithBackend } from "../embeddings.js";
 import { getLogger } from "../logging.js";
-import {
-  buildCliCommandContent,
-  buildCliCommandHelpContent,
-} from "./cli-command-content.js";
+import { buildCliCommandHelpContent } from "./cli-command-content.js";
 import { invalidatePageIndex } from "./page-index.js";
 import {
   backfillKindOnPointsWithPrefix,
@@ -110,8 +111,12 @@ export async function seedV2CliCommandEntries(
 }
 
 function startSeedDrainIfNeeded(): void {
-  if (activeSeedDrain) return;
-  if (processedSeedGeneration >= requestedSeedGeneration) return;
+  if (activeSeedDrain) {
+    return;
+  }
+  if (processedSeedGeneration >= requestedSeedGeneration) {
+    return;
+  }
 
   activeSeedDrain = drainSeedQueue().finally(() => {
     activeSeedDrain = null;
@@ -131,7 +136,9 @@ async function drainSeedQueue(): Promise<void> {
 function resolveSeedWaiters(): void {
   for (let i = seedWaiters.length - 1; i >= 0; i -= 1) {
     const waiter = seedWaiters[i]!;
-    if (waiter.generation > processedSeedGeneration) continue;
+    if (waiter.generation > processedSeedGeneration) {
+      continue;
+    }
     seedWaiters.splice(i, 1);
     waiter.resolve();
   }
@@ -141,13 +148,13 @@ async function runSeedV2CliCommandEntries(generation: number): Promise<void> {
   try {
     const config = getConfig();
     const seeds: CliCommandEntry[] = [];
-    const declarativeNames = new Set<string>();
 
-    // Commands that have adopted the static-help split are read from their
-    // declarative help (exposed via `@vellumai/plugin-api`) — pure data, no CLI
-    // action graph. Content is rendered from that data here in the plugin.
+    // Every top-level `assistant` CLI command declares its help as pure data
+    // (`CLI_COMMAND_HELP`, exposed via `@vellumai/plugin-api`); render each into
+    // a capability statement here in the plugin. Reading declarative help keeps
+    // the CLI's action graph — and the daemon/provider modules it imports — out
+    // of this plugin's import tree, so the seed never touches `cli/program.ts`.
     for (const help of CLI_COMMAND_HELP) {
-      declarativeNames.add(help.name);
       seeds.push({
         id: help.name,
         description: help.description,
@@ -155,31 +162,6 @@ async function runSeedV2CliCommandEntries(generation: number): Promise<void> {
       });
     }
 
-    // Remaining commands still come from the Commander tree. Dynamic import so
-    // callers that only need `getCliCommandCapability` or `listCliCommandEntries`
-    // (e.g. the render path inside `injection.ts` and the `page-index.ts`
-    // dependency loader) never drag the full CLI command graph into their import
-    // tree. The CLI tree pulls in many provider and workspace modules whose
-    // presence has been a recurring source of test-mock cascades and
-    // circular-import surprises.
-    const { buildCliProgramTree } = await import("../../../../cli/program.js");
-    const program = buildCliProgramTree();
-
-    for (const cmd of program.commands) {
-      const name = cmd.name();
-      // Skip the `help` builtin Commander adds automatically — it carries no
-      // capability information of its own — and commands already sourced
-      // declaratively above.
-      if (name === "help" || declarativeNames.has(name)) continue;
-      const description = cmd.description();
-      const content = buildCliCommandContent(
-        name,
-        description,
-        cmd.helpInformation(),
-      );
-      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
@@ -342,7 +324,9 @@ export function isCliCommandSlug(slug: string): boolean {
  * copies on each call.
  */
 export function listCliCommandEntries(): CliCommandEntry[] {
-  if (!entries) return [];
+  if (!entries) {
+    return [];
+  }
   return [...entries.values()]
     .sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0))
     .map((entry) => Object.freeze({ ...entry }));

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

@@ -39,13 +39,23 @@
  *      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
+ *   6. Verify the run drained the buffer. `runResult.ok` only means the
+ *      background run completed — the trim itself is delegated to the agent.
+ *      A run that completes without shrinking the buffer is reported as
+ *      `invoked` with `noProgress: true` and enqueues no follow-ups.
+ *   7. On progress, 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
+ *      a conservative full-reembed effectively free. Each follow-up coalesces
+ *      with an already-pending job of the same type. 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. A stale lock is taken over automatically on the next
+ *      partial state would be misleading. Run outcome also drives the durable
+ *      consecutive-failure state (see
+ *      {@link CONSOLIDATION_FAILURE_CHECKPOINT_KEY}): a failed or
+ *      no-progress run increments it, a progressing run clears it, a skipped
+ *      run leaves it untouched, and the scheduler backs off automatic
+ *      re-enqueues while it is set.
+ *   8. Release the lock. A stale lock is taken over automatically on the next
  *      run (single-writer per workspace): when the holder's PID is no longer
  *      running, or — because the daemon runs as PID 1 in containers and a
  *      restarted daemon collides with the dead holder's PID — when the lock is
@@ -69,8 +79,14 @@ import { dirname, join } from "node:path";
 
 import { isMemoryV3Live } from "../../../../config/memory-v3-gate.js";
 import type { AssistantConfig } from "../../../../config/types.js";
+import {
+  deleteMemoryCheckpoint,
+  getMemoryCheckpoint,
+  setMemoryCheckpoint,
+} from "../../../../persistence/checkpoints.js";
 import {
   enqueueMemoryJob,
+  hasPendingJobOfType,
   type MemoryJob,
   type MemoryJobType,
 } from "../../../../persistence/jobs-store.js";
@@ -148,6 +164,109 @@ const CONSOLIDATION_TIMEOUT_MS = 15 * 60 * 1000;
  */
 const STALE_LOCK_TTL_MS = 4 * CONSOLIDATION_TIMEOUT_MS;
 
+/**
+ * Durable checkpoint tracking consecutive consolidation run failures.
+ *
+ * Written by this handler: incremented when the run fails or completes
+ * without draining the buffer, cleared when a run makes progress. Paths that
+ * bail before invoking the runner (disabled, locked, empty buffer) and
+ * skipped runs (`skipReason`) leave it untouched. The scheduler
+ * (`maybeEnqueueGraphMaintenanceJobs`) reads it to back off automatic
+ * re-enqueues while runs keep failing — without it, a fast-failing run whose
+ * buffer never trims re-fires the size trigger on every worker poll. Manual
+ * "run now" enqueues are not gated.
+ *
+ * `kind` reflects the MOST RECENT failure and selects the scheduler's backoff
+ * curve: `billing` (non-retryable `PROVIDER_BILLING` turn failures) backs off
+ * toward the long cap, `transient` (everything else) stays short so a network
+ * blip or model hiccup never meaningfully delays consolidation. The
+ * consecutive count spans both kinds.
+ *
+ * Value is JSON: `{ consecutiveFailures, lastFailureAt, kind }`.
+ */
+export const CONSOLIDATION_FAILURE_CHECKPOINT_KEY =
+  "memory_v2_consolidate_failure_state";
+
+export type ConsolidationFailureKind = "billing" | "transient";
+
+export interface ConsolidationFailureState {
+  consecutiveFailures: number;
+  lastFailureAt: number;
+  kind: ConsolidationFailureKind;
+}
+
+/**
+ * Read the persisted failure state. Missing, malformed, or out-of-range
+ * payloads read as `null` (no failures on record) — corruption self-heals on
+ * the next record/clear.
+ */
+export function readConsolidationFailureState(): ConsolidationFailureState | null {
+  const raw = getMemoryCheckpoint(CONSOLIDATION_FAILURE_CHECKPOINT_KEY);
+  if (raw === null) {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(raw) as Partial<ConsolidationFailureState>;
+    if (
+      typeof parsed.consecutiveFailures !== "number" ||
+      !Number.isFinite(parsed.consecutiveFailures) ||
+      parsed.consecutiveFailures < 1 ||
+      typeof parsed.lastFailureAt !== "number" ||
+      !Number.isFinite(parsed.lastFailureAt) ||
+      (parsed.kind !== "billing" && parsed.kind !== "transient")
+    ) {
+      return null;
+    }
+    return {
+      consecutiveFailures: parsed.consecutiveFailures,
+      lastFailureAt: parsed.lastFailureAt,
+      kind: parsed.kind,
+    };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Increment the consecutive-failure count, stamp the failure time, and set
+ * the kind to this (most recent) failure's classification.
+ * Best-effort: failure bookkeeping must never change the handler's outcome.
+ */
+function recordConsolidationFailure(
+  nowMs: number,
+  kind: ConsolidationFailureKind,
+): void {
+  try {
+    const prior = readConsolidationFailureState();
+    const state: ConsolidationFailureState = {
+      consecutiveFailures: (prior?.consecutiveFailures ?? 0) + 1,
+      lastFailureAt: nowMs,
+      kind,
+    };
+    setMemoryCheckpoint(
+      CONSOLIDATION_FAILURE_CHECKPOINT_KEY,
+      JSON.stringify(state),
+    );
+  } catch (err) {
+    log.warn(
+      { err },
+      "consolidation: failed to record failure state (best-effort)",
+    );
+  }
+}
+
+/** Clear the failure state after a progressing run. Best-effort. */
+function clearConsolidationFailureState(): void {
+  try {
+    deleteMemoryCheckpoint(CONSOLIDATION_FAILURE_CHECKPOINT_KEY);
+  } catch (err) {
+    log.warn(
+      { err },
+      "consolidation: failed to clear failure state (best-effort)",
+    );
+  }
+}
+
 /**
  * Follow-up jobs to fan out after a successful consolidation.
  *
@@ -181,6 +300,12 @@ export type ConsolidationOutcome =
        */
       deferredEntries: number;
       followUpJobIds: string[];
+      /**
+       * `true` when the run completed without shrinking the buffer — the
+       * agent never trimmed it, so nothing changed worth re-embedding and no
+       * follow-ups were enqueued.
+       */
+      noProgress: boolean;
     };
 
 export async function memoryV2ConsolidateJob(
@@ -218,6 +343,11 @@ export async function memoryV2ConsolidateJob(
       return { kind: "empty_buffer" };
     }
 
+    // Baseline for the post-run progress check — same metric the scheduler's
+    // size trigger uses, so "no progress" below means exactly "the trigger
+    // condition still holds".
+    const bufferLinesBefore = countNonEmptyLines(bufferContent);
+
     // Step 3: 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.
@@ -320,26 +450,88 @@ export async function memoryV2ConsolidateJob(
       // Wire-scope the guardian-trust background run to local memory-file
       // tools only — no network egress, no host proxy. See the constant.
       allowedTools: CONSOLIDATION_ALLOWED_TOOLS,
+      // The kickoff prompt is a static instruction manual; indexing it would
+      // write near-identical memory segments, embeddings, and a lexical
+      // entry on every run. The agent's replies still index normally.
+      skipPromptIndexing: true,
     });
 
     if (!runResult.ok) {
+      // Billing turn failures (`PROVIDER_BILLING` covers both exhausted
+      // managed credits and BYOK provider-account credits) are
+      // non-retryable and select the scheduler's long backoff curve;
+      // everything else (network blip, model hiccup, timeout) is transient
+      // and stays on the short curve.
+      const failureKind: ConsolidationFailureKind =
+        runResult.failureCode === "PROVIDER_BILLING" ? "billing" : "transient";
       log.error(
         {
           conversationId: runResult.conversationId,
           errorKind: runResult.errorKind,
+          failureCode: runResult.failureCode,
+          failureKind,
           err: runResult.error?.message,
         },
         "consolidation run failed; follow-ups skipped",
       );
+      recordConsolidationFailure(Date.now(), failureKind);
       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
-    // wiring exercised end-to-end so PR 21 only has to swap in the handler
-    // bodies. v3 maintenance is appended only while v3 is live, so it never
-    // fans out on v2-only installs.
+    // Step 5: verify the run drained the buffer. `runResult.ok` only means
+    // the background run completed — the trim itself is delegated to the
+    // agent, and nothing above checks that it happened. A run that completes
+    // without shrinking the buffer leaves the scheduler's size trigger armed
+    // (it re-fires while the buffer stays over threshold), so enqueuing
+    // follow-ups here would fan out one reembed per re-fire for pages that
+    // never changed. Entries arriving during the run can inflate the
+    // after-count into a false "no progress"; that is benign — the next
+    // progressing run enqueues the same follow-ups.
+    const bufferLinesAfter = countBufferLines(bufferPath);
+    const noProgress = bufferLinesAfter >= bufferLinesBefore;
+
+    // Failure-state bookkeeping. A skipped run (`skipReason`) never invoked
+    // the agent, so it neither clears nor records. A completed run that made
+    // no progress behaves like a failure for scheduling — the size trigger
+    // stays armed — so it records on the transient curve rather than
+    // re-firing every worker poll; only a progressing run clears the backoff.
+    if (runResult.skipReason === undefined) {
+      if (noProgress) {
+        recordConsolidationFailure(Date.now(), "transient");
+      } else {
+        clearConsolidationFailureState();
+      }
+    }
+
+    if (noProgress) {
+      log.warn(
+        {
+          conversationId: runResult.conversationId,
+          cutoff,
+          bufferLinesBefore,
+          bufferLinesAfter,
+        },
+        "consolidation run completed without draining the buffer; follow-ups skipped",
+      );
+      return {
+        kind: "invoked",
+        conversationId: runResult.conversationId,
+        cutoff,
+        deferredEntries,
+        followUpJobIds: [],
+        noProgress: true,
+      };
+    }
+
+    // Step 6: enqueue follow-up jobs. v3 maintenance is appended only while
+    // v3 is live, so it never fans out on v2-only installs. Each enqueue
+    // coalesces with an already-pending job of the same type: follow-ups
+    // carry no payload and read all state at execution time, so one pending
+    // row covers any number of completed consolidations. A running follow-up
+    // does not suppress — it may have snapshotted pre-run state, so a fresh
+    // pending row must be allowed to queue behind it.
     const followUpJobIds: string[] = [];
     const jobTypes: MemoryJobType[] = [...FOLLOW_UP_JOB_TYPES];
     if (memoryV3Live) {
@@ -347,6 +539,13 @@ export async function memoryV2ConsolidateJob(
     }
     for (const jobType of jobTypes) {
       try {
+        if (hasPendingJobOfType(jobType)) {
+          log.debug(
+            { jobType },
+            "consolidation: follow-up already pending; skipping duplicate enqueue",
+          );
+          continue;
+        }
         followUpJobIds.push(enqueueMemoryJob(jobType, {}));
       } catch (err) {
         // Best-effort: a failed enqueue here doesn't undo the agent's writes,
@@ -373,6 +572,7 @@ export async function memoryV2ConsolidateJob(
       cutoff,
       deferredEntries,
       followUpJobIds,
+      noProgress: false,
     };
   } finally {
     releaseLock(lockPath);
@@ -422,8 +622,14 @@ function extractBufferEntryTimestamp(line: string): string | null {
  * newlines don't inflate the count.
  */
 export function countBufferLines(bufferPath: string): number {
-  const content = readBufferContent(bufferPath);
-  if (content.length === 0) return 0;
+  return countNonEmptyLines(readBufferContent(bufferPath));
+}
+
+/** Non-empty-line count of buffer content already in hand. */
+function countNonEmptyLines(content: string): number {
+  if (content.length === 0) {
+    return 0;
+  }
   return content.split("\n").filter((line) => line.trim().length > 0).length;
 }
 

package/src/plugins/defaults/memory/v2/harness/router-retriever.ts

@@ -7,7 +7,6 @@
  * its own injected ground truth.
  */
 
-import type { DrizzleDb } from "../../../../../persistence/db-connection.js";
 import { runRouter } from "../router.js";
 import type {
   RetrievalInput,
@@ -15,12 +14,7 @@ import type {
   Retriever,
 } from "./retriever.js";
 
-/**
- * @param database optional handle for tier-2 EMA scoring, forwarded to
- * `runRouter`. Omit to exercise only the tier-1 / tier-3 paths (as the router's
- * own tests do).
- */
-export function createRouterRetriever(database?: DrizzleDb): Retriever {
+export function createRouterRetriever(): Retriever {
   return {
     name: "router",
     async retrieve(input: RetrievalInput): Promise<RetrievalOutput> {
@@ -31,7 +25,6 @@ export function createRouterRetriever(database?: DrizzleDb): Retriever {
         priorEverInjected: input.priorEverInjected,
         config: input.config,
         ...(input.signal ? { signal: input.signal } : {}),
-        ...(database ? { database } : {}),
       });
       return {
         selectedSlugs: result.selectedSlugs,

package/src/plugins/defaults/memory/v2/injection-events.ts

@@ -1,6 +1,5 @@
-import type { DrizzleDb } from "../../../../persistence/db-connection.js";
-import { getSqliteFrom } from "../../../../persistence/db-connection.js";
 import { getLogger } from "../logging.js";
+import { memorySqliteOrNull } from "../memory-db.js";
 
 const log = getLogger("memory-v2-injection-events");
 
@@ -18,6 +17,7 @@ export const INJECTION_SCORE_LAMBDA =
 
 // Events past 6 half-lives contribute <1.6% each. Reads bound the scan to
 // this window so per-slug score computation stays cheap as history grows.
+// Migration 326 uses the same window to purge dead rows during relocation.
 const READ_WINDOW_MS = 6 * INJECTION_SCORE_HALF_LIFE_MS;
 
 function decayContribution(elapsedMs: number): number {
@@ -30,13 +30,13 @@ function decayContribution(elapsedMs: number): number {
  * caller depends on.
  */
 export function recordInjectionEvents(
-  database: DrizzleDb,
   slugs: readonly string[],
   injectedAt: number,
 ): void {
   if (slugs.length === 0) return;
   try {
-    const raw = getSqliteFrom(database);
+    const raw = memorySqliteOrNull("recordInjectionEvents");
+    if (!raw) return;
     const insert = raw.prepare(
       `INSERT INTO memory_v2_injection_events (slug, injected_at) VALUES (?, ?)`,
     );
@@ -52,14 +52,14 @@ export function recordInjectionEvents(
   }
 }
 
-/** `score(now) = Σᵢ exp(-λ × (now - tᵢ))` over events within READ_WINDOW_MS. */
-export function computeInjectionScore(
-  database: DrizzleDb,
-  slug: string,
-  now: number,
-): number {
+/**
+ * `score(now) = Σᵢ exp(-λ × (now - tᵢ))` over events within READ_WINDOW_MS.
+ * Returns 0 when the memory database is unavailable.
+ */
+export function computeInjectionScore(slug: string, now: number): number {
+  const raw = memorySqliteOrNull("computeInjectionScore");
+  if (!raw) return 0;
   const cutoff = now - READ_WINDOW_MS;
-  const raw = getSqliteFrom(database);
   const rows = raw
     .query(
       `SELECT injected_at FROM memory_v2_injection_events
@@ -75,17 +75,19 @@ export function computeInjectionScore(
  * Batch variant of `computeInjectionScore` — single SQL pass scoped to the
  * requested slugs so tier assignment doesn't issue O(M) queries. Slugs
  * with no events in the read window are omitted from the result; callers
- * should treat a missing entry as score 0.
+ * should treat a missing entry as score 0. Returns an empty map when the
+ * memory database is unavailable, so a degraded connection reads as
+ * all-zero scores (tier 2 simply selects nothing).
  */
 export function computeInjectionScores(
-  database: DrizzleDb,
   slugs: readonly string[],
   now: number,
 ): Map<string, number> {
   const out = new Map<string, number>();
   if (slugs.length === 0) return out;
+  const raw = memorySqliteOrNull("computeInjectionScores");
+  if (!raw) return out;
   const cutoff = now - READ_WINDOW_MS;
-  const raw = getSqliteFrom(database);
   const placeholders = slugs.map(() => "?").join(",");
   const rows = raw
     .query(

package/src/plugins/defaults/memory/v2/injection.ts

@@ -612,7 +612,6 @@ async function injectViaRouter(args: {
     nowText,
     priorEverInjected,
     config,
-    database,
     ...(signal ? { signal } : {}),
   });
 
@@ -622,7 +621,7 @@ async function injectViaRouter(args: {
   // errors — a SQLite write must not abort the turn on top of a successful
   // routing decision the rest of this function depends on.
   if (routerResult.failureReason === null) {
-    recordInjectionEvents(database, routerResult.selectedSlugs, Date.now());
+    recordInjectionEvents(routerResult.selectedSlugs, Date.now());
   }
 
   if (routerResult.failureReason !== null) {

package/src/plugins/defaults/memory/v2/memory-v2-startup.test.ts

@@ -17,7 +17,6 @@
  */
 import { afterEach, describe, expect, mock, test } from "bun:test";
 
-import { makeMockLogger } from "../../../../__tests__/helpers/mock-logger.js";
 import type { AssistantConfig } from "../../../../config/schema.js";
 
 const proxyState = { prereqs: true };
@@ -28,10 +27,6 @@ const enqueueJob = mock(
   (_type: string, _payload: Record<string, unknown>) => 1,
 );
 
-mock.module("../../../../util/logger.js", () => ({
-  getLogger: () => makeMockLogger(),
-}));
-
 mock.module("../../../../providers/platform-proxy/context.js", () => ({
   hasManagedProxyPrereqs: async () => proxyState.prereqs,
 }));