@vellumai/assistant 0.8.3 → 0.8.5

package/src/memory/external-conversation-store.ts

@@ -7,7 +7,7 @@
  * list APIs.
  */
 
-import { and, eq, inArray, isNull } from "drizzle-orm";
+import { and, eq, inArray, isNull, sql } from "drizzle-orm";
 
 import { getDb } from "./db-connection.js";
 import { externalConversationBindings } from "./schema.js";
@@ -16,6 +16,7 @@ export interface ExternalConversationBinding {
   conversationId: string;
   sourceChannel: string;
   externalChatId: string;
+  externalChatName?: string | null;
   externalThreadId?: string | null;
   externalUserId?: string | null;
   displayName?: string | null;
@@ -30,6 +31,7 @@ export interface UpsertBindingInput {
   conversationId: string;
   sourceChannel: string;
   externalChatId: string;
+  externalChatName?: string | null;
   externalThreadId?: string | null;
   externalUserId?: string | null;
   displayName?: string | null;
@@ -43,6 +45,13 @@ function normalizeExternalThreadId(
   return trimmed ? trimmed : null;
 }
 
+function normalizeExternalChatName(
+  externalChatName?: string | null,
+): string | null {
+  const trimmed = externalChatName?.trim();
+  return trimmed ? trimmed : null;
+}
+
 /**
  * Insert or update an external conversation binding on conflict (conversationId).
  * On conflict, updates channel metadata and timestamps.
@@ -51,6 +60,7 @@ export function upsertBinding(input: UpsertBindingInput): void {
   const db = getDb();
   const now = Date.now();
   const externalThreadId = normalizeExternalThreadId(input.externalThreadId);
+  const externalChatName = normalizeExternalChatName(input.externalChatName);
 
   // If a stale binding exists for this channel/chat/thread tuple under a
   // different conversationId, remove it first so the unique index is not violated.
@@ -75,6 +85,7 @@ export function upsertBinding(input: UpsertBindingInput): void {
       conversationId: input.conversationId,
       sourceChannel: input.sourceChannel,
       externalChatId: input.externalChatId,
+      externalChatName,
       externalThreadId,
       externalUserId: input.externalUserId ?? null,
       displayName: input.displayName ?? null,
@@ -88,6 +99,9 @@ export function upsertBinding(input: UpsertBindingInput): void {
       set: {
         sourceChannel: input.sourceChannel,
         externalChatId: input.externalChatId,
+        externalChatName:
+          externalChatName ??
+          sql`${externalConversationBindings.externalChatName}`,
         externalThreadId,
         externalUserId: input.externalUserId ?? null,
         displayName: input.displayName ?? null,
@@ -158,6 +172,23 @@ export function upsertOutboundBinding(input: {
     .run();
 }
 
+export function updateExternalChatName(
+  conversationId: string,
+  externalChatName: string,
+): void {
+  const db = getDb();
+  const trimmedName = externalChatName.trim();
+  if (!trimmedName) return;
+
+  db.update(externalConversationBindings)
+    .set({
+      externalChatName: trimmedName,
+      updatedAt: Date.now(),
+    })
+    .where(eq(externalConversationBindings.conversationId, conversationId))
+    .run();
+}
+
 /**
  * Look up an external binding by conversation ID.
  */

package/src/memory/graph/bootstrap.ts

@@ -20,7 +20,11 @@ import { getLogger } from "../../util/logger.js";
 import { getWorkspaceDir } from "../../util/platform.js";
 import { getMemoryCheckpoint, setMemoryCheckpoint } from "../checkpoints.js";
 import { getDb } from "../db-connection.js";
-import { enqueueMemoryJob, hasActiveJobOfType } from "../jobs-store.js";
+import {
+  enqueueMemoryJob,
+  hasActiveJobOfType,
+  isMemoryEnabled,
+} from "../jobs-store.js";
 import { initQdrantClient, resolveQdrantUrl } from "../qdrant-client.js";
 import { rawAll, rawGet, rawRun } from "../raw-query.js";
 import { conversations, memoryGraphNodes, memorySegments } from "../schema.js";
@@ -342,6 +346,8 @@ export function maybeEnqueueGraphBootstrap(): void {
   // Don't enqueue if already in progress
   if (hasActiveJobOfType("graph_bootstrap")) return;
 
+  if (!isMemoryEnabled()) return;
+
   log.info(
     { segmentCount, hasJournalFiles },
     "Graph empty with historical data — enqueueing bootstrap",
@@ -392,6 +398,7 @@ const KIND_TO_PREFIX: Record<string, string> = {
  */
 export function migrateToolCreatedItems(): void {
   if (getMemoryCheckpoint(MIGRATE_ITEMS_CHECKPOINT)) return;
+  if (!isMemoryEnabled()) return;
 
   const kinds = Object.keys(KIND_TO_PREFIX);
   const placeholders = kinds.map(() => "?").join(", ");

package/src/memory/graph/capability-seed.ts

@@ -23,7 +23,7 @@ import {
 } from "../../skills/skill-memory.js";
 import { getLogger } from "../../util/logger.js";
 import { getDb } from "../db-connection.js";
-import { enqueueMemoryJob } from "../jobs-store.js";
+import { enqueueMemoryJob, isMemoryEnabled } from "../jobs-store.js";
 import { memoryGraphNodes } from "../schema.js";
 import { createNode } from "./store.js";
 
@@ -268,7 +268,9 @@ function upsertCapabilityNode(sourceKey: string, content: string): void {
       })
       .where(eq(memoryGraphNodes.id, existing.id))
       .run();
-    enqueueMemoryJob("embed_graph_node", { nodeId: existing.id });
+    if (isMemoryEnabled()) {
+      enqueueMemoryJob("embed_graph_node", { nodeId: existing.id });
+    }
     return;
   }
 
@@ -301,7 +303,9 @@ function upsertCapabilityNode(sourceKey: string, content: string): void {
     scopeId: "default",
   });
 
-  enqueueMemoryJob("embed_graph_node", { nodeId: node.id });
+  if (isMemoryEnabled()) {
+    enqueueMemoryJob("embed_graph_node", { nodeId: node.id });
+  }
   log.info({ sourceKey, nodeId: node.id }, "Created capability graph node");
 }
 

package/src/memory/graph/conversation-graph-memory.ts

@@ -35,6 +35,7 @@ import {
   type InjectMemoryV2Mode,
 } from "../v2/injection.js";
 import { loadNowText } from "../v2/now-text.js";
+import type { RouterTurnPair } from "../v2/router.js";
 import {
   loadGraphMemoryState,
   saveGraphMemoryState,
@@ -440,8 +441,11 @@ export class ConversationGraphMemory {
       messages,
       config,
       "context-load",
+      // Context-load runs before the messages array necessarily contains
+      // the just-arrived user turn (post-compaction restore, turn 1
+      // sketch), so override with the resolved user text rather than
+      // walking back through `messages`.
       rawUserText ?? userQuery ?? "",
-      "",
       signal,
     );
 
@@ -605,8 +609,7 @@ export class ConversationGraphMemory {
       messages,
       config,
       "per-turn",
-      userLast,
-      assistantLast,
+      null,
       signal,
     );
     if (v2.routed) {
@@ -762,8 +765,14 @@ export class ConversationGraphMemory {
     messages: Message[],
     config: AssistantConfig,
     mode: InjectMemoryV2Mode,
-    userMessage: string,
-    assistantMessage: string,
+    /**
+     * Override for the just-arrived user message text. Used by
+     * `runContextLoad` where the conversation history may not yet contain
+     * the user message that triggered the load (e.g. turn 1 / post-
+     * compaction restoration). When provided, the extracted pairs array
+     * is replaced with `[{ assistantMessage: "", userMessage: override }]`.
+     */
+    userMessageOverride: string | null,
     signal: AbortSignal,
   ): Promise<{
     routed: boolean;
@@ -776,13 +785,17 @@ export class ConversationGraphMemory {
 
     const nowText = await loadNowText(getWorkspaceDir());
     const currentTurn = this.tracker.getTurn();
+    const historicalPairs = config.memory.v2.router.historical_pairs;
+    const recentTurnPairs =
+      userMessageOverride !== null
+        ? [{ assistantMessage: "", userMessage: userMessageOverride }]
+        : extractRecentTurnPairs(messages, historicalPairs);
 
     const result = await injectMemoryV2Block({
       database: getDb(),
       conversationId: this.conversationId,
       currentTurn,
-      userMessage,
-      assistantMessage,
+      recentTurnPairs,
       nowText,
       messageId: `${this.conversationId}:turn:${currentTurn}`,
       mode,
@@ -808,16 +821,22 @@ export class ConversationGraphMemory {
 
 /**
  * Count the leading content blocks on a user message that were added by
- * `injectMemoryBlock`. Memory-injected images use a 3-block pattern
- * (opening `<memory_image>` text + image + closing `</memory_image>` text),
- * followed by a `<memory>…</memory>` text block (legacy `<memory __injected>` is also accepted).
- * The bare `<memory>` form is matched only when the block also ends with
- * `\n</memory>`, so user-authored content that happens to begin with
- * `<memory>` (for example, a message discussing the XML-like markup) is not
- * mistaken for an injected prefix and stripped on re-injection. A legacy
- * 2-block image pattern (no closing tag) is also accepted for backward
- * compatibility. The injection prefix is always contiguous at the start,
- * so we stop at the first non-memory block.
+ * `injectMemoryBlock` or the `memory-v2-static` injector. Memory-injected
+ * images use a 3-block pattern (opening `<memory_image>` text + image +
+ * closing `</memory_image>` text), followed by a `<memory>…</memory>` text
+ * block (legacy `<memory __injected>` is also accepted). The static
+ * memory-v2 block uses `<info>…</info>` and is also counted here so that
+ * `after-memory-prefix` splices for subsequent injectors (e.g. `now-md`)
+ * land after both the dynamic and static blocks.
+ *
+ * The bare `<memory>` and `<info>` forms are matched only when the block
+ * also ends with the corresponding closing tag, so user-authored content
+ * that happens to begin with `<memory>` or `<info>` (for example, a
+ * message discussing the XML-like markup) is not mistaken for an injected
+ * prefix and stripped on re-injection. A legacy 2-block image pattern (no
+ * closing tag) is also accepted for backward compatibility. The injection
+ * prefix is always contiguous at the start, so we stop at the first
+ * non-memory block.
  */
 export function countMemoryPrefixBlocks(content: ContentBlock[]): number {
   let firstNonMemory = 0;
@@ -829,6 +848,8 @@ export function countMemoryPrefixBlocks(content: ContentBlock[]): number {
       block.type === "text" &&
       ((block.text.startsWith("<memory>\n") &&
         block.text.endsWith("\n</memory>")) ||
+        (block.text.startsWith("<info>\n") &&
+          block.text.endsWith("\n</info>")) ||
         block.text.startsWith("<memory __injected>\n"))
     ) {
       firstNonMemory++;
@@ -991,3 +1012,65 @@ function readRawUserText(message: Message | undefined): string | null {
   if (texts.length === 0) return null;
   return texts.join(" ");
 }
+
+/**
+ * Walk back through the conversation history and collect the most recent
+ * `K` `(assistant, user)` turn pairs for the router prompt. Each pair
+ * represents the assistant's reply followed by the user message that
+ * came after — the last pair's `userMessage` is the just-arrived turn
+ * that triggered this call.
+ *
+ * Behavior at K=1 is bit-identical to the pre-knob signature: one pair
+ * with the prior assistant reply + the just-arrived user message.
+ *
+ * Edge cases:
+ *   - If history has fewer than K full pairs available (e.g. early in a
+ *     conversation), returns however many pairs were found, oldest first.
+ *     The oldest pair may have `assistantMessage: ""` when there is a
+ *     user message with no preceding assistant reply — `runRouterBatch`
+ *     skips the `[assistant]:` line in that case.
+ *   - Non-text content (tool_use, tool_result, images) is collapsed by
+ *     joining all text blocks within a single message with spaces. This
+ *     matches the v1-style extraction the router has used since K=1.
+ */
+function extractRecentTurnPairs(
+  messages: Message[],
+  k: number,
+): RouterTurnPair[] {
+  const messageText = (msg: Message): string =>
+    msg.content
+      .filter(
+        (b): b is Extract<typeof b, { type: "text" }> => b.type === "text",
+      )
+      .map((b) => b.text)
+      .join(" ");
+
+  const pairs: RouterTurnPair[] = [];
+  let pendingUser: string | null = null;
+  for (let i = messages.length - 1; i >= 0 && pairs.length < k; i--) {
+    const msg = messages[i];
+    if (msg.role === "user" && pendingUser === null) {
+      pendingUser = messageText(msg);
+    } else if (msg.role === "assistant" && pendingUser !== null) {
+      pairs.unshift({
+        assistantMessage: messageText(msg),
+        userMessage: pendingUser,
+      });
+      pendingUser = null;
+    }
+  }
+  // Conversation start: a user message with no preceding assistant reply
+  // still belongs in the prompt as the just-arrived turn. Emit it with an
+  // empty `assistantMessage` so `runRouterBatch` renders only `[user]:`.
+  if (pendingUser !== null && pairs.length < k) {
+    pairs.unshift({ assistantMessage: "", userMessage: pendingUser });
+  }
+  // Defensive fallback: the router contract requires a non-empty array.
+  // This only fires when `messages` has no user-text content at all
+  // (currently impossible since the agent loop always appends a user
+  // turn before invoking the v2 path, but cheap to keep correct).
+  if (pairs.length === 0) {
+    pairs.push({ assistantMessage: "", userMessage: "" });
+  }
+  return pairs;
+}

package/src/memory/graph/extraction.ts

@@ -12,7 +12,6 @@ import { join } from "node:path";
 import { and, asc, desc, eq, gt } from "drizzle-orm";
 
 import type { AssistantConfig } from "../../config/types.js";
-import { resolveGuardianPersona } from "../../prompts/persona-resolver.js";
 import { buildCoreIdentityContext } from "../../prompts/system-prompt.js";
 import {
   extractToolUse,
@@ -1026,10 +1025,7 @@ export async function runGraphExtraction(
   const candidateNodeIds = new Set(candidateNodes.map((n) => n.id));
 
   // 4. Build prompt
-  const userPersona = resolveGuardianPersona();
-  const identityContext = buildCoreIdentityContext({
-    userPersona: userPersona ?? undefined,
-  });
+  const identityContext = buildCoreIdentityContext();
 
   const activeSet = opts?.activeContextNodeIds
     ? new Set(opts.activeContextNodeIds)

package/src/memory/graph/graph-search.ts

@@ -9,7 +9,11 @@ import { selectedBackendSupportsMultimodal } from "../embedding-backend.js";
 import type { EmbeddingInput } from "../embedding-types.js";
 import { embedAndUpsert } from "../job-utils.js";
 import { asString } from "../job-utils.js";
-import { enqueueMemoryJob, type MemoryJob } from "../jobs-store.js";
+import {
+  enqueueMemoryJob,
+  isMemoryEnabled,
+  type MemoryJob,
+} from "../jobs-store.js";
 import { isQdrantBreakerOpen } from "../qdrant-circuit-breaker.js";
 import { withQdrantBreaker } from "../qdrant-circuit-breaker.js";
 import {
@@ -238,6 +242,7 @@ export async function embedGraphNodeJob(
  * Enqueue an embedding job for a graph node (async, for live conversations).
  */
 export function enqueueGraphNodeEmbed(nodeId: string): void {
+  if (!isMemoryEnabled()) return;
   enqueueMemoryJob("embed_graph_node", { nodeId });
 }
 
@@ -282,5 +287,6 @@ export async function embedGraphTriggerJob(
  * Enqueue a trigger embedding job.
  */
 export function enqueueGraphTriggerEmbed(triggerId: string): void {
+  if (!isMemoryEnabled()) return;
   enqueueMemoryJob("graph_trigger_embed", { triggerId });
 }

package/src/memory/indexer.ts

@@ -11,7 +11,11 @@ import { isAutoAnalysisConversation } from "./auto-analysis-guard.js";
 import { getMemoryCheckpoint, setMemoryCheckpoint } from "./checkpoints.js";
 import { getDb } from "./db-connection.js";
 import { selectedBackendSupportsMultimodal } from "./embedding-backend.js";
-import { enqueueMemoryJob, upsertDebouncedJob } from "./jobs-store.js";
+import {
+  enqueueMemoryJob,
+  isMemoryEnabled,
+  upsertDebouncedJob,
+} from "./jobs-store.js";
 import { isMemoryRetrospectiveConversation } from "./memory-retrospective-enqueue.js";
 import { maybeEnqueueRetrospective } from "./memory-retrospective-trigger-check.js";
 import {
@@ -139,20 +143,22 @@ export async function indexMessageNow(
 
       if (existing?.contentHash === hash) {
         skippedEmbedJobs++;
-      } else {
+      } else if (isMemoryEnabled()) {
         enqueueMemoryJob("embed_segment", { segmentId }, Date.now(), tx);
       }
     }
 
     // Enqueue embed_attachment jobs for image content blocks when the
     // embedding provider supports multimodal (Gemini only).
-    for (const block of mediaBlocks) {
-      enqueueMemoryJob(
-        "embed_attachment",
-        { messageId: input.messageId, blockIndex: block.index },
-        Date.now(),
-        tx,
-      );
+    if (isMemoryEnabled()) {
+      for (const block of mediaBlocks) {
+        enqueueMemoryJob(
+          "embed_attachment",
+          { messageId: input.messageId, blockIndex: block.index },
+          Date.now(),
+          tx,
+        );
+      }
     }
   });
 
@@ -221,14 +227,16 @@ export async function indexMessageNow(
         extractRunAfter = graphBatchFired
           ? Date.now()
           : Date.now() + idleTimeoutMs;
-        upsertDebouncedJob(
-          "graph_extract",
-          {
-            conversationId: input.conversationId,
-            scopeId: input.scopeId ?? "default",
-          },
-          extractRunAfter,
-        );
+        if (isMemoryEnabled()) {
+          upsertDebouncedJob(
+            "graph_extract",
+            {
+              conversationId: input.conversationId,
+              scopeId: input.scopeId ?? "default",
+            },
+            extractRunAfter,
+          );
+        }
       } else {
         extractRunAfter = Date.now() + idleTimeoutMs;
       }
@@ -309,7 +317,7 @@ export async function indexMessageNow(
     // jobs-worker.ts. Debounced on the same idle timeout — no threshold
     // trigger needed since summaries compress the whole conversation, not
     // incremental batches.
-    if (v2Config == null) {
+    if (v2Config == null && isMemoryEnabled()) {
       upsertDebouncedJob(
         "build_conversation_summary",
         { conversationId: input.conversationId },
@@ -372,10 +380,12 @@ export async function indexMessageNow(
 }
 
 export function enqueueBackfillJob(force = false): string {
+  if (!isMemoryEnabled()) return "";
   return enqueueMemoryJob("backfill", { force });
 }
 
 export function enqueueRebuildIndexJob(): string {
+  if (!isMemoryEnabled()) return "";
   return enqueueMemoryJob("rebuild_index", {});
 }
 

package/src/memory/job-handlers/cleanup.ts

@@ -1,8 +1,9 @@
 import type { AssistantConfig } from "../../config/types.js";
 import { getLogger } from "../../util/logger.js";
+import { runAsyncSqlite } from "../db-async-query.js";
 import { getDb } from "../db-connection.js";
 import { enqueueMemoryJob, type MemoryJob } from "../jobs-store.js";
-import { rawAll, rawChanges, rawRun } from "../raw-query.js";
+import { rawAll, rawRun } from "../raw-query.js";
 
 const log = getLogger("memory-jobs-worker");
 
@@ -13,11 +14,18 @@ const PRUNE_LOG_BATCH_LIMIT = 1000;
  * Delete LLM request/response logs older than the configured retention period.
  * Processes in batches to avoid long DB locks and excessive WAL growth.
  * Re-enqueues itself if more rows remain.
+ *
+ * The DELETE is dispatched through `runAsyncSqlite` so it runs in a
+ * sqlite3 subprocess (when available) and does not block the daemon's
+ * main event loop. The two bind parameters (`cutoffMs`, batch limit)
+ * are integers — they're inlined directly into the SQL after a
+ * `Math.floor` + `Number.isFinite` guard so there is no string
+ * interpolation surface.
  */
-export function pruneOldLlmRequestLogsJob(
+export async function pruneOldLlmRequestLogsJob(
   job: MemoryJob,
   config: AssistantConfig,
-): void {
+): Promise<void> {
   const rawRetention = job.payload.retentionMs;
   const retentionMs =
     rawRetention === null
@@ -31,14 +39,29 @@ export function pruneOldLlmRequestLogsJob(
   // null means "keep forever" — skip pruning entirely
   if (retentionMs === null || retentionMs === undefined) return;
 
-  const cutoffMs = Date.now() - retentionMs;
-
-  rawRun(
-    `DELETE FROM llm_request_logs WHERE rowid IN (SELECT rowid FROM llm_request_logs WHERE created_at < ? LIMIT ?)`,
-    cutoffMs,
-    PRUNE_LOG_BATCH_LIMIT,
+  const cutoffMs = Math.floor(Date.now() - retentionMs);
+  if (!Number.isFinite(cutoffMs)) return;
+
+  // Inline the cutoff and batch limit (both integers, both validated)
+  // and chain `SELECT changes()` so we can read the row count from the
+  // subprocess's stdout. The sqlite3 CLI prints `changes()` as a bare
+  // integer on its own line in default output mode; the in-process
+  // fallback backend in `db-async-query.ts` synthesizes the same shape
+  // by capturing `changes()` atomically after `exec()`. Both backends
+  // end up on the parser path below.
+  const result = await runAsyncSqlite(
+    `DELETE FROM llm_request_logs WHERE rowid IN (SELECT rowid FROM llm_request_logs WHERE created_at < ${cutoffMs} LIMIT ${PRUNE_LOG_BATCH_LIMIT});
+SELECT changes();`,
   );
-  const deleted = rawChanges();
+  if (!result.ok) {
+    log.warn(
+      { error: result.error, backend: result.backend },
+      "pruneOldLlmRequestLogsJob: DELETE failed",
+    );
+    return;
+  }
+
+  const deleted = parseDeletedCount(result.stdout);
 
   if (deleted >= PRUNE_LOG_BATCH_LIMIT) {
     enqueueMemoryJob("prune_old_llm_request_logs", { retentionMs });
@@ -58,11 +81,14 @@ export function pruneOldLlmRequestLogsJob(
  * Delete trace events older than the configured retention period.
  * Processes in batches to avoid long DB locks and excessive WAL growth.
  * Re-enqueues itself if more rows remain.
+ *
+ * Same async dispatch + integer inlining shape as
+ * {@link pruneOldLlmRequestLogsJob}.
  */
-export function pruneOldTraceEventsJob(
+export async function pruneOldTraceEventsJob(
   job: MemoryJob,
   config: AssistantConfig,
-): void {
+): Promise<void> {
   const rawRetention = job.payload.retentionDays;
   const retentionDays =
     typeof rawRetention === "number" &&
@@ -74,14 +100,22 @@ export function pruneOldTraceEventsJob(
   // 0 means disabled
   if (retentionDays === 0) return;
 
-  const cutoffMs = Date.now() - retentionDays * 86_400_000;
+  const cutoffMs = Math.floor(Date.now() - retentionDays * 86_400_000);
+  if (!Number.isFinite(cutoffMs)) return;
 
-  rawRun(
-    `DELETE FROM trace_events WHERE rowid IN (SELECT rowid FROM trace_events WHERE created_at < ? LIMIT ?)`,
-    cutoffMs,
-    PRUNE_LOG_BATCH_LIMIT,
+  const result = await runAsyncSqlite(
+    `DELETE FROM trace_events WHERE rowid IN (SELECT rowid FROM trace_events WHERE created_at < ${cutoffMs} LIMIT ${PRUNE_LOG_BATCH_LIMIT});
+SELECT changes();`,
   );
-  const deleted = rawChanges();
+  if (!result.ok) {
+    log.warn(
+      { error: result.error, backend: result.backend },
+      "pruneOldTraceEventsJob: DELETE failed",
+    );
+    return;
+  }
+
+  const deleted = parseDeletedCount(result.stdout);
 
   if (deleted >= PRUNE_LOG_BATCH_LIMIT) {
     enqueueMemoryJob("prune_old_trace_events", { retentionDays });
@@ -97,6 +131,30 @@ export function pruneOldTraceEventsJob(
   );
 }
 
+/**
+ * Parse the `SELECT changes()` result emitted by the sqlite3 CLI after
+ * the prune DELETE. Returns 0 if stdout is missing or unparseable —
+ * callers treat that the same as "no rows deleted, do not re-enqueue".
+ *
+ * In the CLI's default output mode the value is a bare integer on its
+ * own line. We tolerate trailing whitespace/blank lines and pick the
+ * last numeric line so any incidental output (warnings, etc.) above it
+ * doesn't throw the parse off.
+ */
+export function _parseDeletedCount(stdout: string | undefined): number {
+  return parseDeletedCount(stdout);
+}
+
+function parseDeletedCount(stdout: string | undefined): number {
+  if (!stdout) return 0;
+  const lines = stdout.split(/\r?\n/).filter((s) => s.trim().length > 0);
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const n = parseInt(lines[i].trim(), 10);
+    if (Number.isFinite(n) && n >= 0) return n;
+  }
+  return 0;
+}
+
 /**
  * Delete conversations that have had no activity (updatedAt) for longer than
  * the configured retention period. Processes in batches so a single job doesn't

package/src/memory/job-handlers/conversation-starters.ts

@@ -9,7 +9,6 @@ import { and, desc, eq, sql } from "drizzle-orm";
 import { v4 as uuid } from "uuid";
 
 import { loadSkillCatalog } from "../../config/skills.js";
-import { resolveGuardianPersona } from "../../prompts/persona-resolver.js";
 import { buildCoreIdentityContext } from "../../prompts/system-prompt.js";
 import {
   createTimeout,
@@ -200,9 +199,7 @@ async function generateStarters(scopeId: string): Promise<GeneratedStarter[]> {
 
   // Truncate identity context to prevent oversized prompts when SOUL.md /
   // IDENTITY.md / users/<slug>.md are large.
-  const rawIdentityContext = buildCoreIdentityContext({
-    userPersona: resolveGuardianPersona(),
-  });
+  const rawIdentityContext = buildCoreIdentityContext();
   const identityContext = rawIdentityContext
     ? truncate(rawIdentityContext, 2000, "\n…[truncated]")
     : null;

package/src/memory/jobs/embed-pkb-file.ts

@@ -1,6 +1,10 @@
 import type { AssistantConfig } from "../../config/types.js";
 import { asString } from "../job-utils.js";
-import { enqueueMemoryJob, type MemoryJob } from "../jobs-store.js";
+import {
+  enqueueMemoryJob,
+  isMemoryEnabled,
+  type MemoryJob,
+} from "../jobs-store.js";
 import { indexPkbFile } from "../pkb/pkb-index.js";
 
 /**
@@ -46,6 +50,7 @@ export async function embedPkbFileJob(
  * Enqueue an `embed_pkb_file` job (async, fire-and-forget).
  */
 export function enqueuePkbIndexJob(input: EmbedPkbFileJobInput): string {
+  if (!isMemoryEnabled()) return "";
   return enqueueMemoryJob("embed_pkb_file", {
     pkbRoot: input.pkbRoot,
     absPath: input.absPath,