@vellumai/assistant 0.10.9 → 0.10.10-dev.202607162206.d08e98e

package/src/live-voice/protocol.ts

@@ -4,6 +4,7 @@ const LIVE_VOICE_CLIENT_FRAME_TYPES = [
   "ptt_release",
   "interrupt",
   "end",
+  "update_config",
 ] as const;
 
 type LiveVoiceClientFrameType = (typeof LIVE_VOICE_CLIENT_FRAME_TYPES)[number];
@@ -78,8 +79,36 @@ export interface LiveVoiceClientStartFrame {
    * utterance boundaries and runs repeated utterance→turn cycles.
    */
   readonly turnDetection?: LiveVoiceTurnDetectionMode;
+  /**
+   * Per-session override for the trailing-silence duration (ms) that ends the
+   * user's turn — the "pause before reply" the client exposes as a setting.
+   * Absent falls back to the daemon `liveVoice.vad.silenceThresholdMs` config.
+   * Only meaningful for `turnDetection: "server_vad"`. Bounded to
+   * [{@link MIN_SILENCE_THRESHOLD_MS}, {@link MAX_SILENCE_THRESHOLD_MS}].
+   */
+  readonly silenceThresholdMs?: number;
+  /**
+   * Per-session override for the sustained speech (ms) required before the
+   * user's speech interrupts the assistant mid-reply — the "interrupt
+   * sensitivity" the client exposes as a setting (higher = harder to
+   * interrupt; 0 disables the guard so barge-in is immediate). Absent falls
+   * back to the daemon `liveVoice.vad.bargeInMinSpeechMs` config. Bounded to
+   * [{@link MIN_BARGE_IN_MIN_SPEECH_MS}, {@link MAX_BARGE_IN_MIN_SPEECH_MS}].
+   */
+  readonly bargeInMinSpeechMs?: number;
 }
 
+/**
+ * Bounds for the per-session turn-detection overrides carried on the start
+ * frame. Kept deliberately wide — they only reject nonsensical values (a
+ * sub-100 ms pause would end turns mid-word; a 10 s barge-in guard would make
+ * the assistant uninterruptible). The daemon config defaults sit inside these.
+ */
+export const MIN_SILENCE_THRESHOLD_MS = 100;
+export const MAX_SILENCE_THRESHOLD_MS = 5_000;
+export const MIN_BARGE_IN_MIN_SPEECH_MS = 0;
+export const MAX_BARGE_IN_MIN_SPEECH_MS = 3_000;
+
 export interface LiveVoiceClientAudioFrame {
   readonly type: "audio";
   readonly dataBase64: string;
@@ -97,12 +126,26 @@ export interface LiveVoiceClientEndFrame {
   readonly type: "end";
 }
 
+/**
+ * Mid-session tuning update: applies the same turn-detection knobs the start
+ * frame carries to the *running* session, so the client can retune "pause
+ * before reply" / "interrupt sensitivity" without reconnecting. Each field is
+ * optional and independently applied; the same bounds as the start frame apply.
+ * Only meaningful for `server_vad` sessions.
+ */
+export interface LiveVoiceClientUpdateConfigFrame {
+  readonly type: "update_config";
+  readonly silenceThresholdMs?: number;
+  readonly bargeInMinSpeechMs?: number;
+}
+
 export type LiveVoiceClientFrame =
   | LiveVoiceClientStartFrame
   | LiveVoiceClientAudioFrame
   | LiveVoiceClientPttReleaseFrame
   | LiveVoiceClientInterruptFrame
-  | LiveVoiceClientEndFrame;
+  | LiveVoiceClientEndFrame
+  | LiveVoiceClientUpdateConfigFrame;
 
 interface LiveVoiceBinaryAudioFrame {
   readonly type: "binary_audio";
@@ -358,9 +401,60 @@ export function validateLiveVoiceClientFrame(
       return { ok: true, frame: { type: "interrupt" } };
     case "end":
       return { ok: true, frame: { type: "end" } };
+    case "update_config":
+      return validateUpdateConfigFrame(value);
   }
 }
 
+function validateUpdateConfigFrame(
+  value: Record<string, unknown>,
+): LiveVoiceParseResult<LiveVoiceClientUpdateConfigFrame> {
+  if (
+    "silenceThresholdMs" in value &&
+    !isIntInRange(
+      value.silenceThresholdMs,
+      MIN_SILENCE_THRESHOLD_MS,
+      MAX_SILENCE_THRESHOLD_MS,
+    )
+  ) {
+    return protocolError(
+      "invalid_field",
+      `update_config field silenceThresholdMs must be an integer in [${MIN_SILENCE_THRESHOLD_MS}, ${MAX_SILENCE_THRESHOLD_MS}]`,
+      "silenceThresholdMs",
+      "update_config",
+    );
+  }
+
+  if (
+    "bargeInMinSpeechMs" in value &&
+    !isIntInRange(
+      value.bargeInMinSpeechMs,
+      MIN_BARGE_IN_MIN_SPEECH_MS,
+      MAX_BARGE_IN_MIN_SPEECH_MS,
+    )
+  ) {
+    return protocolError(
+      "invalid_field",
+      `update_config field bargeInMinSpeechMs must be an integer in [${MIN_BARGE_IN_MIN_SPEECH_MS}, ${MAX_BARGE_IN_MIN_SPEECH_MS}]`,
+      "bargeInMinSpeechMs",
+      "update_config",
+    );
+  }
+
+  return {
+    ok: true,
+    frame: {
+      type: "update_config",
+      ...(typeof value.silenceThresholdMs === "number"
+        ? { silenceThresholdMs: value.silenceThresholdMs }
+        : {}),
+      ...(typeof value.bargeInMinSpeechMs === "number"
+        ? { bargeInMinSpeechMs: value.bargeInMinSpeechMs }
+        : {}),
+    },
+  };
+}
+
 export function parseLiveVoiceBinaryAudioFrame(
   data: unknown,
 ): LiveVoiceParseResult<LiveVoiceBinaryAudioFrame> {
@@ -448,6 +542,38 @@ function validateStartFrame(
     );
   }
 
+  if (
+    "silenceThresholdMs" in value &&
+    !isIntInRange(
+      value.silenceThresholdMs,
+      MIN_SILENCE_THRESHOLD_MS,
+      MAX_SILENCE_THRESHOLD_MS,
+    )
+  ) {
+    return protocolError(
+      "invalid_field",
+      `start frame field silenceThresholdMs must be an integer in [${MIN_SILENCE_THRESHOLD_MS}, ${MAX_SILENCE_THRESHOLD_MS}]`,
+      "silenceThresholdMs",
+      "start",
+    );
+  }
+
+  if (
+    "bargeInMinSpeechMs" in value &&
+    !isIntInRange(
+      value.bargeInMinSpeechMs,
+      MIN_BARGE_IN_MIN_SPEECH_MS,
+      MAX_BARGE_IN_MIN_SPEECH_MS,
+    )
+  ) {
+    return protocolError(
+      "invalid_field",
+      `start frame field bargeInMinSpeechMs must be an integer in [${MIN_BARGE_IN_MIN_SPEECH_MS}, ${MAX_BARGE_IN_MIN_SPEECH_MS}]`,
+      "bargeInMinSpeechMs",
+      "start",
+    );
+  }
+
   return {
     ok: true,
     frame: {
@@ -459,10 +585,26 @@ function validateStartFrame(
       ...(isLiveVoiceTurnDetectionMode(value.turnDetection)
         ? { turnDetection: value.turnDetection }
         : {}),
+      ...(typeof value.silenceThresholdMs === "number"
+        ? { silenceThresholdMs: value.silenceThresholdMs }
+        : {}),
+      ...(typeof value.bargeInMinSpeechMs === "number"
+        ? { bargeInMinSpeechMs: value.bargeInMinSpeechMs }
+        : {}),
     },
   };
 }
 
+/** Whether `value` is an integer within the inclusive `[min, max]` range. */
+function isIntInRange(value: unknown, min: number, max: number): boolean {
+  return (
+    typeof value === "number" &&
+    Number.isInteger(value) &&
+    value >= min &&
+    value <= max
+  );
+}
+
 function validateAudioFrame(
   value: Record<string, unknown>,
 ): LiveVoiceParseResult<LiveVoiceClientAudioFrame> {

package/src/monitoring/__tests__/plugin-source-watch.test.ts

@@ -46,8 +46,10 @@ afterAll(() => {
   rmSync(ROOT, { recursive: true, force: true });
 });
 
-const { collectSourceVersions, createSourceWatchState, runSourceWatchPass } =
+const { createSourceWatchState, runSourceWatchPass } =
   await import("../plugin-source-watch.js");
+const { collectSourceVersions } =
+  await import("../../plugins/collect-source-versions.js");
 const { getSourceVersionsPath, readSourceVersions } =
   await import("../../plugins/source-versions.js");
 

package/src/monitoring/plugin-source-watch.ts

@@ -25,14 +25,14 @@
 import {
   existsSync,
   mkdirSync,
+  readdirSync,
   renameSync,
   statSync,
   writeFileSync,
 } from "node:fs";
-import { readdirSync } from "node:fs";
 import { join } from "node:path";
 
-import { snapshotPluginSource } from "../plugins/source-fingerprint.js";
+import { collectSourceVersions } from "../plugins/collect-source-versions.js";
 import type {
   PluginSourceVersion,
   SourceVersionsDocument,
@@ -43,69 +43,10 @@ import {
   SOURCE_VERSIONS_FORMAT,
 } from "../plugins/source-versions.js";
 import { getLogger } from "../util/logger.js";
-import {
-  getMonitoringDataDir,
-  getWorkspaceHooksDir,
-  getWorkspacePluginsDir,
-} from "../util/platform.js";
+import { getMonitoringDataDir } from "../util/platform.js";
 
 const log = getLogger("plugin-source-watch");
 
-/**
- * Collect the current source version of every watched directory: each
- * plugin directory under `<workspace>/plugins/` (same discovery rule as the
- * daemon's plugin scan — a directory with a `package.json`), plus the
- * standalone workspace hooks directory when it exists. Disabled plugins are
- * fingerprinted too: consumers need fresh state the moment a plugin is
- * re-enabled, and the `disabled` field is how they observe the toggle
- * itself (dotfiles are excluded from the fingerprint).
- */
-export function collectSourceVersions(): Record<string, PluginSourceVersion> {
-  const out: Record<string, PluginSourceVersion> = {};
-
-  const pluginsDir = getWorkspacePluginsDir();
-  let entries: string[] = [];
-  try {
-    entries = readdirSync(pluginsDir);
-  } catch {
-    // No plugins directory yet — nothing to watch there.
-  }
-  for (const entry of entries) {
-    if (entry.startsWith(".")) {
-      continue;
-    }
-    const dir = join(pluginsDir, entry);
-    try {
-      if (!statSync(dir).isDirectory()) {
-        continue;
-      }
-    } catch {
-      continue;
-    }
-    if (!existsSync(join(dir, "package.json"))) {
-      continue;
-    }
-    const snapshot = snapshotPluginSource(dir);
-    out[dir] = {
-      fingerprint: snapshot.fingerprint,
-      evictionPaths: snapshot.evictionPaths,
-      disabled: existsSync(join(dir, ".disabled")),
-    };
-  }
-
-  const workspaceHooksDir = getWorkspaceHooksDir();
-  if (existsSync(workspaceHooksDir)) {
-    const snapshot = snapshotPluginSource(workspaceHooksDir);
-    out[workspaceHooksDir] = {
-      fingerprint: snapshot.fingerprint,
-      evictionPaths: snapshot.evictionPaths,
-      disabled: false,
-    };
-  }
-
-  return out;
-}
-
 /**
  * Whether two version maps describe the same source state. Compares key
  * sets, fingerprints, and disabled flags; eviction paths are derived from

package/src/notifications/README.md

@@ -550,6 +550,6 @@ from the unified `llm` block. Override defaults by setting either of:
 | `llm.callSites.notificationDecision` | object | _(unset)_ | Provider/model/effort/etc. override for the decision engine call site      |
 | `llm.callSites.preferenceExtraction` | object | _(unset)_ | Provider/model/effort/etc. override for the preference extractor call site |
 
-When a call site override is unset, the resolver falls back to `llm.default`.
+When a call site override is unset, the resolver falls back to the shipped call-site default profile.
 
 The notification pipeline is always active -- signals are processed and dispatched as soon as the daemon is running. The audit trail (events, decisions, deliveries) is written for every signal.

package/src/permissions/checker.ts

@@ -6,7 +6,10 @@ import { getIsContainerized } from "../config/env-registry.js";
 import { getConfig } from "../config/loader.js";
 import { loadSkillCatalog, resolveSkillSelector } from "../config/skills.js";
 import { ipcClassifyRisk } from "../ipc/gateway-client.js";
-import { MEMORY_RETROSPECTIVE_ORIGIN } from "../plugins/defaults/memory/memory-retrospective-constants.js";
+import {
+  MEMORY_RETROSPECTIVE_ORIGIN,
+  SKILL_MANAGEMENT_SKILL_ID,
+} from "../plugins/defaults/memory/memory-retrospective-constants.js";
 import { indexCatalogById } from "../skills/include-graph.js";
 import { getSkillRoots } from "../skills/path-classifier.js";
 import { computeTransitiveSkillVersionHash } from "../skills/transitive-version-hash.js";
@@ -718,7 +721,10 @@ export async function classifyRisk(
     workingDir,
     manifestOverride,
   );
-  const gatewayResult = await ipcClassifyRisk(ipcParams);
+  const gatewayResult = await ipcClassifyRisk(ipcParams, signal);
+  // A mid-retry cancellation should surface as an AbortError, not the
+  // misleading fail-closed "gateway unreachable" message.
+  signal?.throwIfAborted();
 
   if (!gatewayResult) {
     throw new Error(
@@ -799,8 +805,6 @@ export async function classifyRisk(
 // The grant is intentionally narrow: it matches exactly these tools AND the
 // retrospective origin on a v3-live assistant, so no interactive session, other
 // origin, or non-v3-live install is affected.
-const SKILL_MANAGEMENT_SKILL_ID = "skill-management";
-
 function isRetrospectiveSkillAuthoringGrant(
   toolName: string,
   input: Record<string, unknown>,

package/src/persistence/__tests__/db-init-migrations-ok.test.ts

@@ -11,10 +11,36 @@
 import { describe, expect, test } from "bun:test";
 
 import { initializeDb } from "../db-init.js";
+import { migrationSteps } from "../steps.js";
 
 describe("initializeDb — migrationsOk return contract", () => {
   test("resolves to { migrationsOk: true } on a clean init", async () => {
     const result = await initializeDb();
     expect(result).toEqual({ migrationsOk: true });
   });
+
+  test("resolves to { migrationsOk: false } when a step is deferred", async () => {
+    // initializeDb reads the shared migrationSteps array, so appending a step
+    // whose dependsOn names a checkpoint that can never exist exercises the
+    // real deferral path end-to-end. The step is deferred (never run, never
+    // checkpointed), so removing it in finally leaves the ledger untouched.
+    const syntheticStep = {
+      name: "dbInitTestSyntheticDeferredStep",
+      run: () => {
+        throw new Error("deferred step must not run");
+      },
+      dependsOn: ["dbInitTestMissingPrerequisite"],
+    };
+    migrationSteps.push(syntheticStep);
+    try {
+      const result = await initializeDb();
+      expect(result).toEqual({ migrationsOk: false });
+    } finally {
+      migrationSteps.splice(migrationSteps.indexOf(syntheticStep), 1);
+    }
+
+    // The deferred step wrote nothing to the ledger, so a clean re-init
+    // reports ready again.
+    expect(await initializeDb()).toEqual({ migrationsOk: true });
+  });
 });

package/src/persistence/conversation-crud.ts

@@ -236,6 +236,25 @@ export const messageMetadataSchema = z
      * treat message text as organic user input.
      */
     hidden: z.boolean().optional(),
+    /**
+     * How the send was initiated when the user message was sent on the
+     * user's behalf by the UI rather than typed by hand (`body.source` on
+     * `POST /v1/messages`). Current value: `"nav_redirect"` — a navigation
+     * shortcut redirected the user into chat with a pre-filled message.
+     * Read back by turn telemetry (`turn-events-store`) so analytics can
+     * separate UI-initiated turns from hand-typed ones, and by the queue
+     * drain to steer the turn. Kept as a plain string so new sources never
+     * fail metadata validation. Absent on hand-typed messages.
+     */
+    userMessageSource: z.string().optional(),
+    /**
+     * Discriminates daemon-authored rows from ordinary turns.
+     * `"system_card"` marks pre-composed status cards (the /compact, /clean,
+     * and summarize-up-to results); see {@link SYSTEM_CARD_MESSAGE_KIND}.
+     * Kept as a plain string so unknown future kinds never fail metadata
+     * validation.
+     */
+    messageKind: z.string().optional(),
     /**
      * Structured terminal record stamped onto a `<background_event
      * source="background-tool">` wake so the web can rebuild the inline
@@ -291,6 +310,61 @@ export function isHiddenMessageMetadata(
   return metadata?.hidden === true;
 }
 
+/**
+ * Shared accessor for the send-source tag on user-message metadata (see the
+ * `userMessageSource` field on {@link messageMetadataSchema}). Returns the
+ * tag (e.g. `"nav_redirect"`) or undefined when the message was typed by
+ * hand or predates the field.
+ */
+export function getUserMessageSourceMetadata(
+  metadata: Record<string, unknown> | null | undefined,
+): string | undefined {
+  const source = metadata?.userMessageSource;
+  return typeof source === "string" && source.length > 0 ? source : undefined;
+}
+
+/**
+ * `messageKind` value marking a daemon-authored system card — a pre-composed
+ * status reply (the /compact, /clean, and summarize-up-to result cards) that
+ * bypasses the agent loop. Cards render as standalone system notices, never
+ * as the assistant persona speaking, and never merge into adjacent assistant
+ * display turns.
+ */
+export const SYSTEM_CARD_MESSAGE_KIND = "system_card";
+
+/**
+ * Shared predicate for the system-card marker on assistant-message metadata
+ * (see the `messageKind` field on {@link messageMetadataSchema}). One
+ * definition so display merging, transcript rendering, and turn grouping
+ * cannot drift.
+ */
+export function isSystemCardMetadata(
+  metadata: Record<string, unknown> | null | undefined,
+): boolean {
+  return metadata?.messageKind === SYSTEM_CARD_MESSAGE_KIND;
+}
+
+/**
+ * Row-level variant of {@link isSystemCardMetadata} for callers holding the
+ * raw persisted `metadata` JSON string. The single place the parse lives so
+ * display merging and turn grouping agree on what a card is.
+ */
+export function isSystemCardMessage(
+  role: string,
+  metadata: string | null,
+): boolean {
+  if (role !== "assistant" || !metadata) {
+    return false;
+  }
+  try {
+    return isSystemCardMetadata(
+      JSON.parse(metadata) as Record<string, unknown>,
+    );
+  } catch {
+    return false;
+  }
+}
+
 /**
  * Parse a persisted message's metadata JSON against {@link messageMetadataSchema}
  * — the single source of truth for its shape — returning the validated fields,
@@ -829,7 +903,7 @@ export function createConversation(
  * web client's `crypto.randomUUID()` / `draft-<ts>-<hex>` drafts while
  * rejecting anything with path separators, `..`, or other traversal vectors.
  */
-const ADOPTABLE_CONVERSATION_ID_RE = /^[A-Za-z0-9_-]{1,128}$/;
+export const ADOPTABLE_CONVERSATION_ID_RE = /^[A-Za-z0-9_-]{1,128}$/;
 
 /**
  * Ensure a `conversations` row exists for `id`, creating one with default
@@ -3830,6 +3904,12 @@ export function getAssistantMessageIdsInTurn(messageId: string): string[] {
     return [messageId];
   }
 
+  // A system card is its own single-row group — its linked calls (e.g. the
+  // summarize-up-to compaction call) never mix into a neighbouring turn.
+  if (isSystemCardMessage(target.role, target.metadata)) {
+    return [target.id];
+  }
+
   // Walk backward from the target message to find the turn boundary.
   // Limit to 50 rows — sufficient for even aggressive tool-use loops.
   const backwardRows = db
@@ -3838,6 +3918,7 @@ export function getAssistantMessageIdsInTurn(messageId: string): string[] {
       role: messages.role,
       content: messages.content,
       createdAt: messages.createdAt,
+      metadata: messages.metadata,
     })
     .from(messages)
     .where(
@@ -3855,6 +3936,12 @@ export function getAssistantMessageIdsInTurn(messageId: string): string[] {
 
   for (const row of backwardRows) {
     if (row.role === "assistant") {
+      if (isSystemCardMessage(row.role, row.metadata)) {
+        // A system card closes the groups on either side of it — rows
+        // before the card belong to an earlier display group.
+        boundaryCreatedAt = row.createdAt;
+        break;
+      }
       assistantIds.push(row.id);
     } else if (row.role === "user") {
       if (isToolResultMessage(row.role, row.content)) {
@@ -3876,6 +3963,7 @@ export function getAssistantMessageIdsInTurn(messageId: string): string[] {
       role: messages.role,
       content: messages.content,
       createdAt: messages.createdAt,
+      metadata: messages.metadata,
     })
     .from(messages)
     .where(
@@ -3890,6 +3978,15 @@ export function getAssistantMessageIdsInTurn(messageId: string): string[] {
 
   for (const row of forwardRows) {
     if (row.role === "assistant") {
+      if (isSystemCardMessage(row.role, row.metadata)) {
+        // A card that is the queried user message's only reply (e.g. the
+        // /compact result) IS the turn's response; otherwise the card
+        // closes the group.
+        if (assistantIds.length === 0) {
+          assistantIds.push(row.id);
+        }
+        break;
+      }
       if (!assistantIds.includes(row.id)) {
         assistantIds.push(row.id);
       }
@@ -3912,6 +4009,7 @@ export function getAssistantMessageIdsInTurn(messageId: string): string[] {
         id: messages.id,
         role: messages.role,
         createdAt: messages.createdAt,
+        metadata: messages.metadata,
       })
       .from(messages)
       .where(
@@ -3925,7 +4023,11 @@ export function getAssistantMessageIdsInTurn(messageId: string): string[] {
       .all();
 
     for (const row of gapRows) {
-      if (row.role === "assistant" && !assistantIds.includes(row.id)) {
+      if (
+        row.role === "assistant" &&
+        !isSystemCardMessage(row.role, row.metadata) &&
+        !assistantIds.includes(row.id)
+      ) {
         assistantIds.push(row.id);
       }
     }

package/src/persistence/db-init.ts

@@ -87,7 +87,7 @@ export async function initializeDb(): Promise<{ migrationsOk: boolean }> {
   // broken migration doesn't prevent independent later ones from succeeding.
   // The runner creates the checkpoint ledger, recovers crashed migrations, then
   // records each step so an already-migrated database skips it on later boots.
-  const { applied, failed, skipped } = await runMigrationSteps(
+  const { applied, failed, skipped, deferred } = await runMigrationSteps(
     database,
     migrationSteps,
   );
@@ -108,6 +108,13 @@ export async function initializeDb(): Promise<{ migrationsOk: boolean }> {
     );
   }
 
+  if (deferred.length > 0) {
+    log.error(
+      { deferredMigrations: deferred, count: deferred.length },
+      `DB initialization completed with ${deferred.length} deferred migration(s) whose prerequisites are not applied`,
+    );
+  }
+
   // A passing post-run validation is part of readiness: validateMigrationState
   // flags schema inconsistencies (e.g. a completed step missing a declared
   // dependsOn checkpoint) that no individual step body surfaces as a failure.
@@ -119,7 +126,11 @@ export async function initializeDb(): Promise<{ migrationsOk: boolean }> {
     log.error({ err }, "validateMigrationState failed");
   }
 
-  // migrationsOk reflects BOTH no failed migration steps AND a passing
+  // migrationsOk requires no failed steps, no deferred steps, and a passing
   // post-run validation, so an inconsistent schema keeps /readyz at 503.
-  return { migrationsOk: failed.length === 0 && validationOk };
+  // Deferrals count because a mis-declared dependsOn would otherwise leave a
+  // step silently never running while the daemon reports ready.
+  return {
+    migrationsOk: failed.length === 0 && deferred.length === 0 && validationOk,
+  };
 }

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

@@ -38,8 +38,13 @@ export async function pruneOldLlmRequestLogsJob(
         ? rawRetention
         : config.memory.cleanup.llmRequestLogRetentionMs;
 
-  // null means "keep forever" — skip pruning entirely
-  if (retentionMs === null || retentionMs === undefined) return;
+  // null/0 means "keep forever" — skip pruning entirely. 0 is excluded (not
+  // just null) to match the scheduler in maybeEnqueueScheduledCleanupJobs,
+  // which no longer enqueues a retention-0 prune; guarding here too ensures a
+  // job left pending from before that fix does not wipe every log on its next
+  // run.
+  if (retentionMs === null || retentionMs === undefined || retentionMs <= 0)
+    return;
 
   const cutoffMs = Math.floor(Date.now() - retentionMs);
   if (!Number.isFinite(cutoffMs)) return;
@@ -104,9 +109,10 @@ export async function pruneOldToolInvocationsJob(
       ? rawRetention
       : config.auditLog.retentionDays;
 
-  // 0 means disabled. rotateToolInvocations no-ops on this too, but
-  // short-circuit so we don't dispatch a pointless async query.
-  if (!retentionDays) return;
+  // 0 (or any non-positive window) means disabled — keep forever. Guarding
+  // <= 0 mirrors the LLM-log prune and short-circuits before dispatching a
+  // pointless async query (rotateToolInvocations no-ops on this too).
+  if (retentionDays <= 0) return;
 
   await rotateToolInvocations(retentionDays);
 }
@@ -158,8 +164,10 @@ export function pruneOldConversationsJob(
       ? job.payload.retentionDays
       : config.memory.cleanup.conversationRetentionDays;
 
-  // 0 means disabled
-  if (retentionDays === 0) return;
+  // 0 (or any non-positive window) means disabled — keep forever. Guarding
+  // <= 0 mirrors the LLM-log prune so a stray non-positive window can never
+  // produce a cutoff at/after `now` that deletes live conversations.
+  if (retentionDays <= 0) return;
 
   const cutoffMs = Date.now() - retentionDays * 86_400_000;