@vellumai/assistant 0.8.2 → 0.8.3

package/src/ipc/cli-client.ts

@@ -135,19 +135,26 @@ export async function cliIpcCall<T = unknown>(
 
     const reqId = crypto.randomUUID();
 
-    opts?.signal?.addEventListener("abort", () => {
-      finish({ ok: false, error: "Request aborted" });
-    }, { once: true });
+    opts?.signal?.addEventListener(
+      "abort",
+      () => {
+        finish({ ok: false, error: "Request aborted" });
+      },
+      { once: true },
+    );
 
     const reader = new IpcFrameReader(
       (envelope) => {
         if (envelope.id !== reqId) return;
         const msg = envelope as IpcResponse;
         if (msg.error) {
-          finish({ ok: false, error: msg.error,
+          finish({
+            ok: false,
+            error: msg.error,
             ...(msg.statusCode != null && { statusCode: msg.statusCode }),
             ...(msg.errorCode != null && { errorCode: msg.errorCode }),
-            ...(msg.errorDetails != null && { errorDetails: msg.errorDetails }) });
+            ...(msg.errorDetails != null && { errorDetails: msg.errorDetails }),
+          });
         } else {
           finish({ ok: true, result: msg.result as T });
         }
@@ -199,7 +206,13 @@ export async function cliIpcCallBinary(
   opts?: { timeoutMs?: number; signal?: AbortSignal },
 ): Promise<
   | { ok: true; headers: Record<string, string>; bytes: Uint8Array }
-  | { ok: false; error: string; statusCode?: number; errorCode?: string; errorDetails?: unknown }
+  | {
+      ok: false;
+      error: string;
+      statusCode?: number;
+      errorCode?: string;
+      errorDetails?: unknown;
+    }
 > {
   if (opts?.signal?.aborted) {
     throw opts.signal.reason ?? new DOMException("Aborted", "AbortError");
@@ -215,7 +228,13 @@ export async function cliIpcCallBinary(
     const finish = (
       result:
         | { ok: true; headers: Record<string, string>; bytes: Uint8Array }
-        | { ok: false; error: string; statusCode?: number; errorCode?: string; errorDetails?: unknown },
+        | {
+            ok: false;
+            error: string;
+            statusCode?: number;
+            errorCode?: string;
+            errorDetails?: unknown;
+          },
     ) => {
       if (settled) return;
       settled = true;
@@ -226,8 +245,14 @@ export async function cliIpcCallBinary(
     };
 
     const connectTimer = setTimeout(() => {
-      log.debug({ method, socketPath, timeoutMs: CONNECT_TIMEOUT_MS }, "CLI IPC binary connect timed out");
-      finish({ ok: false, error: `Could not connect to the assistant at ${socketPath}.\nRun \`assistant status\` to check, or \`assistant gateway start\` to start it.` });
+      log.debug(
+        { method, socketPath, timeoutMs: CONNECT_TIMEOUT_MS },
+        "CLI IPC binary connect timed out",
+      );
+      finish({
+        ok: false,
+        error: `Could not connect to the assistant at ${socketPath}.\nRun \`assistant status\` to check, or \`assistant gateway start\` to start it.`,
+      });
     }, CONNECT_TIMEOUT_MS);
 
     const socket = new Socket();
@@ -235,7 +260,10 @@ export async function cliIpcCallBinary(
 
     socket.on("error", (err) => {
       const code = (err as NodeJS.ErrnoException).code;
-      log.debug({ err, code, method, socketPath }, "CLI IPC binary socket error");
+      log.debug(
+        { err, code, method, socketPath },
+        "CLI IPC binary socket error",
+      );
       finish({
         ok: false,
         error:
@@ -258,23 +286,37 @@ export async function cliIpcCallBinary(
 
     const reqId = crypto.randomUUID();
 
-    opts?.signal?.addEventListener("abort", () => {
-      finish({ ok: false, error: "Request aborted" });
-    }, { once: true });
+    opts?.signal?.addEventListener(
+      "abort",
+      () => {
+        finish({ ok: false, error: "Request aborted" });
+      },
+      { once: true },
+    );
 
     const reader = new IpcFrameReader(
       (envelope, binary) => {
         if (envelope.id !== reqId) return;
         const msg = envelope as IpcResponse;
         if (msg.error) {
-          finish({ ok: false, error: msg.error,
+          finish({
+            ok: false,
+            error: msg.error,
             ...(msg.statusCode != null && { statusCode: msg.statusCode }),
             ...(msg.errorCode != null && { errorCode: msg.errorCode }),
-            ...(msg.errorDetails != null && { errorDetails: msg.errorDetails }) });
+            ...(msg.errorDetails != null && { errorDetails: msg.errorDetails }),
+          });
         } else if (binary === undefined) {
-          finish({ ok: false, error: "Expected binary frame but received JSON-only response" });
+          finish({
+            ok: false,
+            error: "Expected binary frame but received JSON-only response",
+          });
         } else {
-          finish({ ok: true, headers: (envelope.headers ?? {}) as Record<string, string>, bytes: binary });
+          finish({
+            ok: true,
+            headers: (envelope.headers ?? {}) as Record<string, string>,
+            bytes: binary,
+          });
         }
       },
       (err) => finish({ ok: false, error: err.message }),
@@ -285,7 +327,10 @@ export async function cliIpcCallBinary(
       writeMessage(socket, { id: reqId, method, params });
 
       callTimer = setTimeout(() => {
-        log.debug({ method, socketPath, timeoutMs: callTimeoutMs }, "CLI IPC binary call timed out");
+        log.debug(
+          { method, socketPath, timeoutMs: callTimeoutMs },
+          "CLI IPC binary call timed out",
+        );
         finish({ ok: false, error: "Request timed out" });
       }, callTimeoutMs);
 
@@ -323,24 +368,42 @@ export async function cliIpcCallStream(
   params?: Record<string, unknown>,
   opts?: { firstByteTimeoutMs?: number; signal?: AbortSignal },
 ): Promise<
-  | { ok: true; headers: Record<string, string>; body: ReadableStream<Uint8Array>; abort: () => void }
-  | { ok: false; error: string; statusCode?: number; errorCode?: string; errorDetails?: unknown }
+  | {
+      ok: true;
+      headers: Record<string, string>;
+      body: ReadableStream<Uint8Array>;
+      abort: () => void;
+    }
+  | {
+      ok: false;
+      error: string;
+      statusCode?: number;
+      errorCode?: string;
+      errorDetails?: unknown;
+    }
 > {
   if (opts?.signal?.aborted) {
     throw opts.signal.reason ?? new DOMException("Aborted", "AbortError");
   }
 
   const socketPath = getAssistantSocketPath();
-  const firstByteTimeoutMs = opts?.firstByteTimeoutMs ?? DEFAULT_FIRST_BYTE_TIMEOUT_MS;
+  const firstByteTimeoutMs =
+    opts?.firstByteTimeoutMs ?? DEFAULT_FIRST_BYTE_TIMEOUT_MS;
 
   return new Promise((resolve) => {
     let settled = false;
     let firstByteTimer: ReturnType<typeof setTimeout> | undefined;
-    let streamController: ReadableStreamDefaultController<Uint8Array> | undefined;
-
-    const finishError = (
-      result: { ok: false; error: string; statusCode?: number; errorCode?: string; errorDetails?: unknown },
-    ) => {
+    let streamController:
+      | ReadableStreamDefaultController<Uint8Array>
+      | undefined;
+
+    const finishError = (result: {
+      ok: false;
+      error: string;
+      statusCode?: number;
+      errorCode?: string;
+      errorDetails?: unknown;
+    }) => {
       if (settled) return;
       settled = true;
       clearTimeout(connectTimer);
@@ -366,8 +429,14 @@ export async function cliIpcCallStream(
     };
 
     const connectTimer = setTimeout(() => {
-      log.debug({ method, socketPath, timeoutMs: CONNECT_TIMEOUT_MS }, "CLI IPC stream connect timed out");
-      finishError({ ok: false, error: `Could not connect to the assistant at ${socketPath}.\nRun \`assistant status\` to check, or \`assistant gateway start\` to start it.` });
+      log.debug(
+        { method, socketPath, timeoutMs: CONNECT_TIMEOUT_MS },
+        "CLI IPC stream connect timed out",
+      );
+      finishError({
+        ok: false,
+        error: `Could not connect to the assistant at ${socketPath}.\nRun \`assistant status\` to check, or \`assistant gateway start\` to start it.`,
+      });
     }, CONNECT_TIMEOUT_MS);
 
     const socket = new Socket();
@@ -375,7 +444,10 @@ export async function cliIpcCallStream(
 
     socket.on("error", (err) => {
       const code = (err as NodeJS.ErrnoException).code;
-      log.debug({ err, code, method, socketPath }, "CLI IPC stream socket error");
+      log.debug(
+        { err, code, method, socketPath },
+        "CLI IPC stream socket error",
+      );
       if (!settled) {
         finishError({
           ok: false,
@@ -399,24 +471,35 @@ export async function cliIpcCallStream(
             : "Connection closed before response",
         });
       } else if (streamController) {
-        streamController.error(new Error("Connection closed before stream ended"));
+        streamController.error(
+          new Error("Connection closed before stream ended"),
+        );
         streamController = undefined;
       }
     });
 
     const reqId = crypto.randomUUID();
 
-    opts?.signal?.addEventListener("abort", () => { abort(); }, { once: true });
+    opts?.signal?.addEventListener(
+      "abort",
+      () => {
+        abort();
+      },
+      { once: true },
+    );
 
     const reader = new IpcFrameReader(
       (envelope) => {
         // Non-streaming envelope with error (e.g. method not found, auth failure)
         if (envelope.id !== reqId) return;
         const msg = envelope as IpcResponse;
-        finishError({ ok: false, error: msg.error ?? "Unexpected non-streaming response",
+        finishError({
+          ok: false,
+          error: msg.error ?? "Unexpected non-streaming response",
           ...(msg.statusCode != null && { statusCode: msg.statusCode }),
           ...(msg.errorCode != null && { errorCode: msg.errorCode }),
-          ...(msg.errorDetails != null && { errorDetails: msg.errorDetails }) });
+          ...(msg.errorDetails != null && { errorDetails: msg.errorDetails }),
+        });
       },
       (err) => finishError({ ok: false, error: err.message }),
       {
@@ -437,7 +520,12 @@ export async function cliIpcCallStream(
           });
           settled = true;
           clearTimeout(connectTimer);
-          resolve({ ok: true, headers: (envelope.headers ?? {}) as Record<string, string>, body, abort });
+          resolve({
+            ok: true,
+            headers: (envelope.headers ?? {}) as Record<string, string>,
+            body,
+            abort,
+          });
         },
         onStreamChunk: (chunk) => {
           streamController?.enqueue(chunk);
@@ -455,8 +543,14 @@ export async function cliIpcCallStream(
       writeMessage(socket, { id: reqId, method, params });
 
       firstByteTimer = setTimeout(() => {
-        log.debug({ method, socketPath, timeoutMs: firstByteTimeoutMs }, "CLI IPC stream first-byte timeout");
-        finishError({ ok: false, error: "Stream timed out waiting for first byte" });
+        log.debug(
+          { method, socketPath, timeoutMs: firstByteTimeoutMs },
+          "CLI IPC stream first-byte timeout",
+        );
+        finishError({
+          ok: false,
+          error: "Stream timed out waiting for first byte",
+        });
       }, firstByteTimeoutMs);
 
       socket.on("data", (chunk) => {
@@ -491,13 +585,21 @@ export function exitFromIpcResult(
   _cmd?: unknown,
 ): never {
   process.stderr.write((r.error ?? "Unknown error") + "\n");
-  if (r.statusCode === undefined) {
-    process.exit(10);
-  } else if (r.statusCode >= 500) {
-    process.exit(3);
-  } else if (r.statusCode >= 400) {
-    process.exit(2);
-  } else {
-    process.exit(1);
-  }
+  process.exit(exitCodeFromIpcResult(r));
+}
+
+/**
+ * Map an IPC error result to its CLI process exit code without exiting.
+ *
+ * Use this when callers want to emit a structured response (e.g. a JSON
+ * error envelope in `--json` mode) before terminating with the same status
+ * code that {@link exitFromIpcResult} would produce.
+ *
+ * Exit code matrix matches {@link exitFromIpcResult}.
+ */
+export function exitCodeFromIpcResult(r: { statusCode?: number }): number {
+  if (r.statusCode === undefined) return 10;
+  if (r.statusCode >= 500) return 3;
+  if (r.statusCode >= 400) return 2;
+  return 1;
 }

package/src/memory/__tests__/conversation-queries.test.ts

@@ -14,7 +14,9 @@ import {
   buildExcerpt,
   buildRecallEvidenceExcerpt,
   countConversations,
+  getMessageRoleStatsByConversation,
   listConversations,
+  listConversationsBySource,
 } from "../conversation-queries.js";
 import { getDb } from "../db-connection.js";
 import { initializeDb } from "../db-init.js";
@@ -261,3 +263,221 @@ describe("listConversations", () => {
     expect(fgList).toHaveLength(0);
   });
 });
+
+describe("listConversationsBySource", () => {
+  beforeEach(() => {
+    resetTables();
+  });
+
+  test("returns only conversations whose source matches exactly", () => {
+    createConversation({
+      title: "consol-1",
+      source: "memory_v2_consolidation",
+    });
+    createConversation({
+      title: "consol-2",
+      source: "memory_v2_consolidation",
+    });
+    createConversation({ title: "heartbeat-1", source: "heartbeat" });
+    createConversation({ title: "user-1", source: "user" });
+
+    const results = listConversationsBySource("memory_v2_consolidation");
+
+    expect(results).toHaveLength(2);
+    expect(results.map((r) => r.title).sort()).toEqual([
+      "consol-1",
+      "consol-2",
+    ]);
+  });
+
+  test("orders by createdAt descending", () => {
+    const a = createConversation({
+      title: "a",
+      source: "memory_v2_consolidation",
+    });
+    const b = createConversation({
+      title: "b",
+      source: "memory_v2_consolidation",
+    });
+    const c = createConversation({
+      title: "c",
+      source: "memory_v2_consolidation",
+    });
+    // Force distinct createdAt regardless of ms-clock granularity.
+    rawRun("UPDATE conversations SET created_at = ? WHERE id = ?", 1000, a.id);
+    rawRun("UPDATE conversations SET created_at = ? WHERE id = ?", 3000, b.id);
+    rawRun("UPDATE conversations SET created_at = ? WHERE id = ?", 2000, c.id);
+
+    const results = listConversationsBySource("memory_v2_consolidation");
+
+    expect(results.map((r) => r.id)).toEqual([b.id, c.id, a.id]);
+  });
+
+  test("honors the limit parameter", () => {
+    for (let i = 0; i < 5; i++) {
+      createConversation({
+        title: `consol-${i}`,
+        source: "memory_v2_consolidation",
+      });
+    }
+
+    const results = listConversationsBySource("memory_v2_consolidation", 3);
+
+    expect(results).toHaveLength(3);
+  });
+
+  test("includes archived rows by default", () => {
+    const conv = createConversation({
+      title: "archived",
+      source: "memory_v2_consolidation",
+    });
+    rawRun(
+      "UPDATE conversations SET archived_at = ? WHERE id = ?",
+      Date.now(),
+      conv.id,
+    );
+
+    const results = listConversationsBySource("memory_v2_consolidation");
+
+    expect(results).toHaveLength(1);
+    expect(results[0]!.archivedAt).not.toBeNull();
+  });
+
+  test("excludes archived rows when includeArchived is false", () => {
+    const archived = createConversation({
+      title: "archived",
+      source: "memory_v2_consolidation",
+    });
+    createConversation({ title: "live", source: "memory_v2_consolidation" });
+    rawRun(
+      "UPDATE conversations SET archived_at = ? WHERE id = ?",
+      Date.now(),
+      archived.id,
+    );
+
+    const results = listConversationsBySource("memory_v2_consolidation", 20, {
+      includeArchived: false,
+    });
+
+    expect(results).toHaveLength(1);
+    expect(results[0]!.title).toBe("live");
+  });
+
+  test("does not apply the subagent-exclusion that listConversations does", () => {
+    // The defensive `source != 'subagent'` carve-out in listConversations is
+    // a foreground/background bucketing concern. A caller asking for the
+    // exact `subagent` source via this query gets exactly that.
+    createConversation({ title: "sub-1", source: "subagent" });
+
+    const results = listConversationsBySource("subagent");
+
+    expect(results).toHaveLength(1);
+    expect(results[0]!.title).toBe("sub-1");
+  });
+});
+
+describe("getMessageRoleStatsByConversation", () => {
+  beforeEach(() => {
+    resetTables();
+  });
+
+  function insertMessage(
+    conversationId: string,
+    role: string,
+    createdAt: number,
+  ): void {
+    rawRun(
+      "INSERT INTO messages (id, conversation_id, role, content, created_at) VALUES (?, ?, ?, ?, ?)",
+      `msg-${conversationId}-${role}-${createdAt}`,
+      conversationId,
+      role,
+      "x",
+      createdAt,
+    );
+  }
+
+  test("returns empty map for empty input", () => {
+    const result = getMessageRoleStatsByConversation([]);
+    expect(result.size).toBe(0);
+  });
+
+  test("returns empty map when conversations exist but no matching role", () => {
+    const a = createConversation("a");
+    insertMessage(a.id, "user", 1000);
+
+    const result = getMessageRoleStatsByConversation([a.id], "assistant");
+
+    expect(result.size).toBe(0);
+  });
+
+  test("counts assistant messages and returns max createdAt", () => {
+    const a = createConversation("a");
+    insertMessage(a.id, "user", 1000);
+    insertMessage(a.id, "assistant", 1500);
+    insertMessage(a.id, "assistant", 2500);
+    insertMessage(a.id, "assistant", 2000);
+
+    const result = getMessageRoleStatsByConversation([a.id], "assistant");
+
+    expect(result.size).toBe(1);
+    expect(result.get(a.id)).toEqual({ count: 3, lastAt: 2500 });
+  });
+
+  test("does not count messages from other roles", () => {
+    const a = createConversation("a");
+    insertMessage(a.id, "user", 1000);
+    insertMessage(a.id, "user", 2000);
+    insertMessage(a.id, "system", 1500);
+    insertMessage(a.id, "assistant", 3000);
+
+    const result = getMessageRoleStatsByConversation([a.id], "assistant");
+
+    expect(result.get(a.id)).toEqual({ count: 1, lastAt: 3000 });
+  });
+
+  test("scopes to the supplied conversation ids", () => {
+    const a = createConversation("a");
+    const b = createConversation("b");
+    insertMessage(a.id, "assistant", 1000);
+    insertMessage(b.id, "assistant", 2000);
+
+    const result = getMessageRoleStatsByConversation([a.id], "assistant");
+
+    expect(result.size).toBe(1);
+    expect(result.has(a.id)).toBe(true);
+    expect(result.has(b.id)).toBe(false);
+  });
+
+  test("aggregates per-conversation across many ids in a single query", () => {
+    const a = createConversation("a");
+    const b = createConversation("b");
+    const c = createConversation("c");
+    insertMessage(a.id, "assistant", 1000);
+    insertMessage(a.id, "assistant", 1500);
+    insertMessage(b.id, "assistant", 2000);
+    // c has no assistant messages → absent from the result.
+
+    const result = getMessageRoleStatsByConversation(
+      [a.id, b.id, c.id],
+      "assistant",
+    );
+
+    expect(result.size).toBe(2);
+    expect(result.get(a.id)).toEqual({ count: 2, lastAt: 1500 });
+    expect(result.get(b.id)).toEqual({ count: 1, lastAt: 2000 });
+    expect(result.has(c.id)).toBe(false);
+  });
+
+  test("role parameter selects the counted role (defaults to assistant)", () => {
+    const a = createConversation("a");
+    insertMessage(a.id, "user", 1000);
+    insertMessage(a.id, "user", 2000);
+    insertMessage(a.id, "assistant", 1500);
+
+    const assistants = getMessageRoleStatsByConversation([a.id]);
+    expect(assistants.get(a.id)).toEqual({ count: 1, lastAt: 1500 });
+
+    const users = getMessageRoleStatsByConversation([a.id], "user");
+    expect(users.get(a.id)).toEqual({ count: 2, lastAt: 2000 });
+  });
+});

package/src/memory/__tests__/memory-retrospective-enqueue.test.ts

@@ -11,26 +11,12 @@ mock.module("../../util/logger.js", () => ({
 // Mock state — reset between tests.
 // ---------------------------------------------------------------------------
 
-let flagEnabled = true;
 let sourceTag: string | null = null;
-let getConfigThrows = false;
 const upsertCalls: Array<{
   payload: { conversationId: string };
   runAfter: number;
 }> = [];
 
-mock.module("../../config/loader.js", () => ({
-  getConfig: () => {
-    if (getConfigThrows) throw new Error("boom");
-    return {};
-  },
-}));
-
-mock.module("../../config/assistant-feature-flags.js", () => ({
-  isAssistantFeatureFlagEnabled: (_key: string, _config: unknown) =>
-    flagEnabled,
-}));
-
 mock.module("../conversation-crud.js", () => ({
   getConversationSource: (_id: string) => sourceTag,
 }));
@@ -59,26 +45,11 @@ import {
 
 describe("enqueueMemoryRetrospectiveIfEnabled", () => {
   beforeEach(() => {
-    flagEnabled = true;
     sourceTag = null;
-    getConfigThrows = false;
     upsertCalls.length = 0;
   });
 
-  test("flag off — no upsert for any trigger", () => {
-    flagEnabled = false;
-    for (const trigger of [
-      "interval",
-      "message_count",
-      "compaction",
-      "lifecycle",
-    ] as const) {
-      enqueueMemoryRetrospectiveIfEnabled({ conversationId: "c1", trigger });
-    }
-    expect(upsertCalls).toHaveLength(0);
-  });
-
-  test("flag on, standard source — interval trigger enqueues with runAfter ≈ now", () => {
+  test("standard source — interval trigger enqueues with runAfter ≈ now", () => {
     const before = Date.now();
     enqueueMemoryRetrospectiveIfEnabled({
       conversationId: "c1",
@@ -113,17 +84,6 @@ describe("enqueueMemoryRetrospectiveIfEnabled", () => {
     });
     expect(upsertCalls).toHaveLength(0);
   });
-
-  test("getConfig throws — no enqueue, no propagation", () => {
-    getConfigThrows = true;
-    expect(() =>
-      enqueueMemoryRetrospectiveIfEnabled({
-        conversationId: "c1",
-        trigger: "interval",
-      }),
-    ).not.toThrow();
-    expect(upsertCalls).toHaveLength(0);
-  });
 });
 
 describe("isMemoryRetrospectiveConversation", () => {
@@ -149,9 +109,7 @@ describe("isMemoryRetrospectiveConversation", () => {
 
 describe("enqueueMemoryRetrospectiveOnCompaction", () => {
   beforeEach(() => {
-    flagEnabled = true;
     sourceTag = null;
-    getConfigThrows = false;
     upsertCalls.length = 0;
   });
 
@@ -162,16 +120,10 @@ describe("enqueueMemoryRetrospectiveOnCompaction", () => {
     expect(upsertCalls).toHaveLength(0);
   });
 
-  test("guardian trust + flag on — enqueues with compaction debounce", () => {
+  test("guardian trust — enqueues with compaction debounce", () => {
     const before = Date.now();
     enqueueMemoryRetrospectiveOnCompaction("c1", "guardian");
     expect(upsertCalls).toHaveLength(1);
     expect(upsertCalls[0]!.runAfter).toBeGreaterThan(before + 100);
   });
-
-  test("guardian trust + flag off — no enqueue", () => {
-    flagEnabled = false;
-    enqueueMemoryRetrospectiveOnCompaction("c1", "guardian");
-    expect(upsertCalls).toHaveLength(0);
-  });
 });