@vellumai/assistant 0.10.5-dev.202607060745.b26cd90 → 0.10.5-dev.202607061137.28aab2f

package/openapi.yaml

@@ -19830,6 +19830,36 @@ paths:
                                   - freeMb
                                 additionalProperties: false
                               - type: "null"
+                          activeConversations:
+                            anyOf:
+                              - type: array
+                                items:
+                                  type: object
+                                  properties:
+                                    conversationId:
+                                      type: string
+                                    title:
+                                      anyOf:
+                                        - type: string
+                                        - type: "null"
+                                    originChannel:
+                                      anyOf:
+                                        - type: string
+                                        - type: "null"
+                                    originInterface:
+                                      anyOf:
+                                        - type: string
+                                        - type: "null"
+                                    processingStartedAt:
+                                      type: number
+                                  required:
+                                    - conversationId
+                                    - title
+                                    - originChannel
+                                    - originInterface
+                                    - processingStartedAt
+                                  additionalProperties: false
+                              - type: "null"
                         required:
                           - ts
                           - memory
@@ -19839,6 +19869,7 @@ paths:
                           - events
                           - deltas
                           - disk
+                          - activeConversations
                         additionalProperties: false
                       - type: "null"
                 required:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.10.5-dev.202607060745.b26cd90",
+  "version": "0.10.5-dev.202607061137.28aab2f",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/__tests__/background-workers-disk-pressure.test.ts

@@ -213,7 +213,8 @@ mock.module("../persistence/cleanup-schedule-state.js", () => ({
   markScheduledCleanupEnqueued: mock(() => {}),
 }));
 
-const { runMemoryJobsOnce } = await import("../persistence/jobs-worker.js");
+const { runMemoryJobsOnce } =
+  await import("../plugins/defaults/memory/jobs-worker.js");
 const { WorkspaceHeartbeatService } =
   await import("../workspace/heartbeat-service.js");
 

package/src/__tests__/job-handler-registration-guard.test.ts

@@ -1,7 +1,7 @@
 import { afterEach, describe, expect, it, spyOn } from "bun:test";
 
-import * as jobsWorker from "../persistence/jobs-worker.js";
 import { registerMemoryPluginJobHandlers } from "../plugins/defaults/memory/job-handler-registration.js";
+import * as jobsWorker from "../plugins/defaults/memory/jobs-worker.js";
 import { registerDefaultPluginPersistenceHooks } from "../plugins/defaults/memory/persistence-hooks-registration.js";
 import {
   getMemoryPersistenceHooks,

package/src/__tests__/memory-jobs-worker-backoff.test.ts

@@ -41,7 +41,7 @@ import {
   POLL_INTERVAL_MAX_MS,
   POLL_INTERVAL_MIN_MS,
   startMemoryJobsWorker,
-} from "../persistence/jobs-worker.js";
+} from "../plugins/defaults/memory/jobs-worker.js";
 
 describe("memory jobs worker adaptive poll interval", () => {
   test("exports expected poll interval constants", () => {

package/src/__tests__/memory-jobs-worker-lanes.test.ts

@@ -114,9 +114,9 @@ import { getMemoryDb } from "../persistence/db-connection.js";
 import { initializeDb } from "../persistence/db-init.js";
 import { _resetQdrantBreaker } from "../persistence/embeddings/qdrant-circuit-breaker.js";
 import { enqueueMemoryJob } from "../persistence/jobs-store.js";
-import { runMemoryJobsOnce } from "../persistence/jobs-worker.js";
 import { memoryJobs } from "../persistence/schema/index.js";
 import { registerMemoryPluginJobHandlers } from "../plugins/defaults/memory/job-handler-registration.js";
+import { runMemoryJobsOnce } from "../plugins/defaults/memory/jobs-worker.js";
 
 describe("memory jobs worker lane scheduling", () => {
   beforeAll(async () => {

package/src/__tests__/memory-worker-tool-registry-guard.test.ts

@@ -1,7 +1,7 @@
 /**
  * Guard test: memory-worker tool registry bootstrap
  *
- * The standalone memory jobs worker (`src/jobs/worker.ts`) hosts real agent
+ * The standalone memory jobs worker (`src/plugins/defaults/memory/worker.ts`) hosts real agent
  * conversations — retrospective and consolidation passes, plus any subagents
  * they spawn — and those conversations resolve their tool surface from that
  * process's registry. The daemon and the schedule worker populate the
@@ -34,7 +34,7 @@ afterAll(() => {
 describe("memory worker tool registry", () => {
   test("worker entrypoint populates the tool registry at startup", () => {
     const source = readFileSync(
-      join(import.meta.dir, "..", "jobs", "worker.ts"),
+      join(import.meta.dir, "..", "plugins", "defaults", "memory", "worker.ts"),
       "utf8",
     );
     expect(source).toContain("await initializeTools()");

package/src/__tests__/mtime-cache.test.ts

@@ -438,10 +438,9 @@ describe("workspace hooks (<workspace>/hooks/)", () => {
   });
 
   // NB: each test below uses a distinct hook event name so the workspace
-  // hook file path is unique. Bun caches dynamic import() by URL and does not
-  // bust on content change, so reusing `<workspace>/hooks/<name>.ts` across
-  // tests would return a stale module (the existing plugin tests dodge this
-  // by using a fresh plugin directory per test).
+  // hook file path is unique and each test stays independent of the cache
+  // state its siblings leave behind (the plugin tests get the same isolation
+  // from a fresh plugin directory per test).
   test("plugin hooks run before the workspace hook for the same event", async () => {
     const dir = freshPluginDir("ordering-plugin");
     writePackageJson(dir, { ...SIMPLE_PKG, name: "ordering-plugin" });

package/src/__tests__/persistence-layering-guard.test.ts

@@ -45,10 +45,9 @@ const MEMORY_DIR = join(ASSISTANT_SRC, "plugins", "defaults", "memory");
  * (`persistence-lifecycle-seam.ts` — every event and query on it is
  * memory-domain), and these persistence call sites invoke the seam's
  * registered handlers through `getMemoryPersistenceHooks()` (no-op when
- * memory is not present). Decoupling plan: the memory jobs worker moves into
- * the memory plugin (retiring the jobs-worker entry), and the per-event
- * lifecycle notifications migrate to the first-class `hooks` system (retiring
- * the conversation-crud entry).
+ * memory is not present). Decoupling plan: the per-event lifecycle
+ * notifications migrate to the first-class `hooks` system, retiring the
+ * conversation-crud entry.
  *
  * Keyed by the importing persistence file (relative to repo root); the value
  * is the set of allowed `memory/<specifier>` module paths it may import.
@@ -57,9 +56,6 @@ const PERSISTENCE_TO_MEMORY_ALLOWLIST: Record<string, ReadonlySet<string>> = {
   "assistant/src/persistence/conversation-crud.ts": new Set([
     "persistence-lifecycle-seam",
   ]),
-  "assistant/src/persistence/jobs-worker.ts": new Set([
-    "persistence-lifecycle-seam",
-  ]),
 };
 
 /**

package/src/__tests__/plugin-import-boundary-guard.test.ts

@@ -168,6 +168,7 @@ const BASELINE: Record<string, readonly string[]> = {
     "../../../context/token-estimator.js",
     "../../../conversations/job-handlers/summarization.js",
     "../../../daemon/date-context.js",
+    "../../../daemon/disk-pressure-background-gate.js",
     "../../../daemon/embedding-reconcile.js",
     "../../../daemon/pkb-context-tracker.js",
     "../../../daemon/pkb-reminder-builder.js",
@@ -178,12 +179,16 @@ const BASELINE: Record<string, readonly string[]> = {
     "../../../media/job-handlers/media-processing.js",
     "../../../permissions/types.js",
     "../../../persistence/checkpoints.js",
+    "../../../persistence/cleanup-schedule-state.js",
     "../../../persistence/conversation-crud.js",
     "../../../persistence/db-connection.js",
+    "../../../persistence/db-maintenance.js",
     "../../../persistence/embeddings/embedding-backend.js",
+    "../../../persistence/embeddings/embedding-billing-breaker.js",
     "../../../persistence/embeddings/embedding-runtime-manager.js",
     "../../../persistence/embeddings/embedding-types.js",
     "../../../persistence/embeddings/messages-lexical-index.js",
+    "../../../persistence/embeddings/qdrant-circuit-breaker.js",
     "../../../persistence/embeddings/qdrant-client.js",
     "../../../persistence/embeddings/qdrant-manager.js",
     "../../../persistence/job-handlers/cleanup.js",
@@ -191,10 +196,10 @@ const BASELINE: Record<string, readonly string[]> = {
     "../../../persistence/job-handlers/message-lexical.js",
     "../../../persistence/job-utils.js",
     "../../../persistence/jobs-store.js",
-    "../../../persistence/jobs-worker.js",
     "../../../persistence/message-content.js",
     "../../../persistence/raw-query.js",
     "../../../persistence/schema/index.js",
+    "../../../persistence/worker-control.js",
     "../../../prompts/persona-resolver.js",
     "../../../prompts/system-prompt.js",
     "../../../runtime/actor-trust-resolver.js",
@@ -204,6 +209,7 @@ const BASELINE: Record<string, readonly string[]> = {
     "../../../runtime/services/auto-analysis-enqueue.js",
     "../../../runtime/services/auto-analysis-guard.js",
     "../../../runtime/services/conversation-analyze-job.js",
+    "../../../tools/registry.js",
     "../../../tools/types.js",
     "../../../types.js",
     "../../../util/logger.js",

package/src/cli/commands/monitoring.ts

@@ -76,6 +76,13 @@ interface LatestSample {
     totalMb: number;
     freeMb: number;
   } | null;
+  activeConversations: Array<{
+    conversationId: string;
+    title: string | null;
+    originChannel: string | null;
+    originInterface: string | null;
+    processingStartedAt: number;
+  }> | null;
 }
 
 interface StartResponse {
@@ -262,6 +269,15 @@ Examples:
               `  Disk (${sample.disk.path}): ${sample.disk.usedMb} / ${sample.disk.totalMb} MiB used`,
             );
           }
+          if (sample.activeConversations?.length) {
+            const items = sample.activeConversations
+              .map(
+                (c) =>
+                  `${c.conversationId}${c.title ? ` "${c.title}"` : ""}${c.originChannel ? ` via ${c.originChannel}` : ""}`,
+              )
+              .join(", ");
+            log.info(`  Processing: ${items}`);
+          }
         });
     },
   });

package/src/config/schemas/monitoring.ts

@@ -55,6 +55,16 @@ export const MonitoringConfigSchema = z
       .describe(
         "Minimum interval between high-memory snapshots, in milliseconds, so a sustained spike does not write a snapshot on every sample.",
       ),
+    baselineSnapshotIntervalMs: z
+      .number({
+        error: "monitoring.baselineSnapshotIntervalMs must be a number",
+      })
+      .int("monitoring.baselineSnapshotIntervalMs must be an integer")
+      .min(60_000, "monitoring.baselineSnapshotIntervalMs must be >= 60000ms")
+      .default(600_000)
+      .describe(
+        "Interval between periodic baseline snapshots, in milliseconds (default 10 minutes). Baselines capture the same forensics as high-memory snapshots but on a steady cadence, so a spike can be diffed against a healthy reference instead of only against other over-threshold captures. Retained separately from high-memory snapshots.",
+      ),
   })
   .describe("Resource monitor process configuration");
 

package/src/daemon/shutdown-handlers.ts

@@ -13,7 +13,6 @@ import {
 } from "../persistence/db-async-query.js";
 import { getSqlite, isDbOpen, resetDb } from "../persistence/db-connection.js";
 import { stopQdrantManager } from "../persistence/embeddings/qdrant-manager.js";
-import { stopMemoryJobsWorker } from "../persistence/jobs-worker.js";
 import { stopMemoryWorkerProcess } from "../persistence/worker-control.js";
 import { stopConsentRefresh } from "../platform/consent-cache.js";
 import { HOOKS } from "../plugin-api/constants.js";
@@ -165,10 +164,6 @@ async function shutdown(): Promise<void> {
   cleanupShellOutputTempFiles();
   stopScheduler();
 
-  // Stop the in-process memory worker supervisor if it was started on the
-  // daemon's event loop (memory.worker.enabled = false).
-  stopMemoryJobsWorker();
-
   // Stop the out-of-process memory worker if it's actually running. This is
   // keyed off live state rather than config: the worker may have been
   // spawned at startup (memory.worker.enabled = true) or out of band via

package/src/hooks/__tests__/hook-live-reload.test.ts

@@ -0,0 +1,153 @@
+/**
+ * End-to-end coverage for hook live-reload through the hook loader: an
+ * edited hook file takes effect on the next dispatch, without a daemon
+ * restart.
+ *
+ * The loader keys each hook on its source file's mtime; when the mtime
+ * moves it evicts the module from the runtime registry (`evictModule` in
+ * `../../plugins/surface-import.ts`) and re-imports, so the fresh content is
+ * what dispatches. These tests drive the public collection API against real
+ * hook files on disk, which also makes them the regression guard for the
+ * Bun behavior the eviction is built on — `require.cache` deletion
+ * invalidating dynamic `import()` is intended per
+ * github.com/oven-sh/bun/discussions/10162 but not spec-guaranteed, and a
+ * Bun upgrade that breaks it must fail here rather than silently degrade
+ * hook edits back to restart-required.
+ */
+
+import {
+  mkdirSync,
+  mkdtempSync,
+  rmSync,
+  unlinkSync,
+  utimesSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterAll, beforeEach, describe, expect, test } from "bun:test";
+
+import type { HookEntry } from "../../plugins/types.js";
+import { getWorkspaceHooksDir } from "../../util/platform.js";
+import {
+  collectUserHookEntries,
+  resetHookCacheForTests,
+} from "../hook-loader.js";
+
+const HOOK_NAME = "user-prompt-submit";
+
+const root = mkdtempSync(join(tmpdir(), "hook-live-reload-"));
+
+afterAll(() => {
+  rmSync(root, { recursive: true, force: true });
+});
+
+beforeEach(() => {
+  resetHookCacheForTests();
+});
+
+/**
+ * Each write gets an explicitly bumped, strictly increasing mtime: two
+ * writes can land inside the same filesystem-timestamp granule, which the
+ * loader's mtime check would read as "unchanged". Real edits arrive seconds
+ * apart; the tests must not race that granularity.
+ */
+let mtimeSeq = 1_750_000_000;
+function writeHookFile(hooksDir: string, marker: string): string {
+  const path = join(hooksDir, `${HOOK_NAME}.ts`);
+  writeFileSync(path, `export default () => ${JSON.stringify(marker)};\n`);
+  const stamp = new Date(++mtimeSeq * 1000);
+  utimesSync(path, stamp, stamp);
+  return path;
+}
+
+/** Fresh plugin fixture: `<root>/<name>/hooks/`, unique name per call. */
+let pluginSeq = 0;
+function makePlugin(): { dir: string; hooksDir: string; name: string } {
+  const name = `reload-plugin-${++pluginSeq}`;
+  const dir = join(root, name);
+  const hooksDir = join(dir, "hooks");
+  mkdirSync(hooksDir, { recursive: true });
+  return { dir, hooksDir, name };
+}
+
+/** Collect the hook chain for a plugin, exactly as dispatch does. */
+async function collect(
+  pluginDir: string,
+  pluginName: string,
+): Promise<HookEntry[]> {
+  return collectUserHookEntries(HOOK_NAME, [[pluginDir, pluginName]]);
+}
+
+/** Run the single expected hook in the chain and return its result. */
+async function dispatchOne(
+  pluginDir: string,
+  pluginName: string,
+): Promise<unknown> {
+  const entries = await collect(pluginDir, pluginName);
+  expect(entries).toHaveLength(1);
+  return (entries[0]!.fn as () => unknown)();
+}
+
+describe("hook live-reload", () => {
+  test("an edited hook file takes effect on the next dispatch, repeatably", async () => {
+    const plugin = makePlugin();
+    writeHookFile(plugin.hooksDir, "v1");
+    expect(await dispatchOne(plugin.dir, plugin.name)).toBe("v1");
+
+    // Two edit → dispatch cycles: the first proves reload works at all, the
+    // second proves a reloaded hook is itself reloadable (edits keep landing
+    // turn after turn, not just once).
+    for (const marker of ["v2", "v3"]) {
+      writeHookFile(plugin.hooksDir, marker);
+      expect(await dispatchOne(plugin.dir, plugin.name)).toBe(marker);
+    }
+  });
+
+  test("an unchanged hook file is served from the cache, not re-imported", async () => {
+    const plugin = makePlugin();
+    writeHookFile(plugin.hooksDir, "stable");
+
+    const first = await collect(plugin.dir, plugin.name);
+    const second = await collect(plugin.dir, plugin.name);
+
+    // Same function instance means the cache hit — dispatch after dispatch
+    // costs a stat, not an import.
+    expect(second[0]!.fn).toBe(first[0]!.fn);
+  });
+
+  test("a deleted hook stops dispatching; recreating it serves the new content", async () => {
+    const plugin = makePlugin();
+    const path = writeHookFile(plugin.hooksDir, "original");
+    expect(await dispatchOne(plugin.dir, plugin.name)).toBe("original");
+
+    unlinkSync(path);
+    expect(await collect(plugin.dir, plugin.name)).toHaveLength(0);
+
+    // The recreated file must dispatch its own content, not the module the
+    // registry cached for the deleted original.
+    writeHookFile(plugin.hooksDir, "recreated");
+    expect(await dispatchOne(plugin.dir, plugin.name)).toBe("recreated");
+  });
+
+  test("standalone workspace hooks reload the same way", async () => {
+    const wsHooksDir = getWorkspaceHooksDir();
+    mkdirSync(wsHooksDir, { recursive: true });
+    const path = writeHookFile(wsHooksDir, "ws-v1");
+
+    try {
+      const before = await collectUserHookEntries(HOOK_NAME, []);
+      expect(before).toHaveLength(1);
+      expect(before[0]!.owner.kind).toBe("workspace");
+      expect((before[0]!.fn as () => unknown)()).toBe("ws-v1");
+
+      writeHookFile(wsHooksDir, "ws-v2");
+      const after = await collectUserHookEntries(HOOK_NAME, []);
+      expect((after[0]!.fn as () => unknown)()).toBe("ws-v2");
+    } finally {
+      // The workspace hooks dir is shared per-process test state — leave it
+      // the way this test found it.
+      unlinkSync(path);
+    }
+  });
+});

package/src/hooks/hook-loader.ts

@@ -37,7 +37,11 @@ import type {
   ShutdownContext,
 } from "../plugin-api/types.js";
 import { listSurfaceDir } from "../plugins/external-plugin-loader.js";
-import { getMtime, importWithTimeout } from "../plugins/surface-import.js";
+import {
+  evictModule,
+  getMtime,
+  importWithTimeout,
+} from "../plugins/surface-import.js";
 import type { HookEntry } from "../plugins/types.js";
 import { getLogger } from "../util/logger.js";
 import { getWorkspaceDir, getWorkspaceHooksDir } from "../util/platform.js";
@@ -112,6 +116,18 @@ async function resolveCachedHook<TCtx>(
     return undefined;
   }
 
+  // The file is new, recreated, or edited since it was last imported. Evict
+  // it from the runtime module registry first: without this, the import
+  // below would return the module Bun cached at the old content and the
+  // edit would never take effect. No-op for a first-ever load.
+  //
+  // Note the reload swaps only the exported function for future dispatches.
+  // The hook file's top-level code runs again on re-import, and nothing
+  // tears down the previous instance — so hook files must keep long-lived
+  // side effects (timers, listeners) in the owner's `init`/`shutdown`
+  // lifecycle, not at module top level.
+  evictModule(filePath);
+
   try {
     const hook = await importWithTimeout<HookFunction>(filePath);
     if (hook === undefined || typeof hook !== "function") {
@@ -142,9 +158,12 @@ async function resolveCachedHook<TCtx>(
  * a plugin can shape the threaded context before a workspace-wide hook
  * observes or finalizes it.
  *
- * Added and removed hook files are picked up live (discovery is by directory
- * listing). A content edit to an existing file is only reflected after a
- * process restart, since Bun caches dynamic imports by resolved path.
+ * Added, removed, and edited hook files are all picked up live: discovery is
+ * by directory listing, and a changed source mtime evicts the module from
+ * the runtime registry before re-import, so the edited hook takes effect on
+ * the next dispatch without a daemon restart. Eviction is per-file — an edit
+ * to a helper module a hook imports is not detected (the hook file's own
+ * mtime is what's watched) and still needs a restart.
  *
  * `effectiveEnabledPlugins` carries the per-chat plugin scope: when non-null, a
  * plugin whose name is not in the set is skipped (its hooks do not run for this
@@ -168,7 +187,9 @@ export async function collectUserHookEntries<TCtx = unknown>(
     const hookFile = listSurfaceDir(join(pluginDir, "hooks")).find(
       (f) => f.name === hookName,
     );
-    if (hookFile === undefined) continue;
+    if (hookFile === undefined) {
+      continue;
+    }
 
     const hook = await resolveCachedHook<TCtx>(
       pluginName,
@@ -233,7 +254,14 @@ export async function preImportHooksDir(
   for (const file of listSurfaceDir(hooksDir)) {
     const key = hookKey(ownerName, file.name);
     const currentMtime = getMtime(file.path);
-    if (currentMtime === 0) continue;
+    if (currentMtime === 0) {
+      continue;
+    }
+
+    // A plugin directory can be removed and reinstalled while the daemon
+    // runs; evict any module cached from the prior install so the
+    // pre-import reflects what's on disk now. No-op at boot.
+    evictModule(file.path);
 
     try {
       const hook = await importWithTimeout<HookFunction>(file.path);
@@ -293,7 +321,9 @@ export async function runInitHook(
   pluginDir: string | null = null,
 ): Promise<void> {
   const initHookEntry = hookCache.get(hookKey(ownerName, HOOKS.INIT));
-  if (initHookEntry === undefined) return;
+  if (initHookEntry === undefined) {
+    return;
+  }
 
   try {
     const initContext: InitContext = {
@@ -323,7 +353,9 @@ export async function runShutdownHook(
   reason: string,
 ): Promise<void> {
   const shutdownHookEntry = hookCache.get(hookKey(ownerName, HOOKS.SHUTDOWN));
-  if (shutdownHookEntry === undefined) return;
+  if (shutdownHookEntry === undefined) {
+    return;
+  }
 
   try {
     await shutdownHookEntry.hook(context);

package/src/monitoring/__tests__/active-conversations.test.ts

@@ -0,0 +1,87 @@
+/**
+ * Tests for the monitor-side read of in-flight conversations. A minimal
+ * conversations table (the columns the query touches) is created in the
+ * per-test workspace database via a separate writer connection; the module
+ * under test reads it through its own read-only connection.
+ */
+
+import { mkdirSync } from "node:fs";
+import { dirname } from "node:path";
+import { Database } from "bun:sqlite";
+import { beforeEach, describe, expect, test } from "bun:test";
+
+import { getDbPath } from "../../util/platform.js";
+import { readActiveConversations } from "../active-conversations.js";
+
+function openWriter(): Database {
+  mkdirSync(dirname(getDbPath()), { recursive: true });
+  const db = new Database(getDbPath());
+  db.run(
+    `CREATE TABLE IF NOT EXISTS conversations (
+       id TEXT PRIMARY KEY,
+       title TEXT,
+       origin_channel TEXT,
+       origin_interface TEXT,
+       processing_started_at INTEGER
+     )`,
+  );
+  return db;
+}
+
+beforeEach(() => {
+  const db = openWriter();
+  db.run("DELETE FROM conversations");
+  db.close();
+});
+
+describe("readActiveConversations", () => {
+  test("returns processing conversations, longest-running first", () => {
+    const db = openWriter();
+    db.run(
+      "INSERT INTO conversations (id, title, origin_channel, origin_interface, processing_started_at) VALUES (?, ?, ?, ?, ?)",
+      ["conv-new", "Newer turn", "slack", "web", 2_000],
+    );
+    db.run(
+      "INSERT INTO conversations (id, title, origin_channel, origin_interface, processing_started_at) VALUES (?, ?, ?, ?, ?)",
+      ["conv-old", "Memory consolidation", null, null, 1_000],
+    );
+    db.run(
+      "INSERT INTO conversations (id, title, origin_channel, origin_interface, processing_started_at) VALUES (?, ?, ?, ?, ?)",
+      ["conv-idle", "Finished turn", null, null, null],
+    );
+    db.close();
+
+    expect(readActiveConversations()).toEqual([
+      {
+        conversationId: "conv-old",
+        title: "Memory consolidation",
+        originChannel: null,
+        originInterface: null,
+        processingStartedAt: 1_000,
+      },
+      {
+        conversationId: "conv-new",
+        title: "Newer turn",
+        originChannel: "slack",
+        originInterface: "web",
+        processingStartedAt: 2_000,
+      },
+    ]);
+  });
+
+  test("truncates long titles", () => {
+    const db = openWriter();
+    db.run(
+      "INSERT INTO conversations (id, title, processing_started_at) VALUES (?, ?, ?)",
+      ["conv-long", "x".repeat(500), 1_000],
+    );
+    db.close();
+
+    const active = readActiveConversations();
+    expect(active![0].title).toHaveLength(80);
+  });
+
+  test("returns null when nothing is processing", () => {
+    expect(readActiveConversations()).toBeNull();
+  });
+});

package/src/monitoring/__tests__/resource-sampler.test.ts

@@ -21,6 +21,7 @@ function makeSample(overrides: Partial<ResourceSample>): ResourceSample {
     events: null,
     deltas: null,
     disk: null,
+    activeConversations: null,
     ...overrides,
   };
 }

package/src/monitoring/__tests__/stall-capture.test.ts

@@ -28,6 +28,7 @@ function makeSample(ts: number): ResourceSample {
     events: null,
     deltas: null,
     disk: null,
+    activeConversations: null,
   };
 }