@vellumai/assistant 0.6.4 → 0.6.5

package/src/ipc/routes/watcher.ts

@@ -0,0 +1,203 @@
+/**
+ * IPC routes for watcher CRUD operations.
+ *
+ * Exposes create/list/update/delete/digest operations so CLI commands
+ * and external processes can manage watchers via the daemon IPC socket.
+ *
+ * Each operation is registered under both a slash-style method name
+ * (e.g. `watcher/create`) and an underscore alias (`watcher_create`).
+ */
+
+import { z } from "zod";
+
+import {
+  getWatcherProvider,
+  listWatcherProviders,
+} from "../../watcher/provider-registry.js";
+import {
+  createWatcher,
+  deleteWatcher,
+  getWatcher,
+  listWatcherEvents,
+  listWatchers,
+  updateWatcher,
+} from "../../watcher/watcher-store.js";
+import type { IpcRoute } from "../cli-server.js";
+
+// -- Param schemas ------------------------------------------------------------
+
+const WatcherCreateParams = z.object({
+  name: z.string().min(1),
+  provider: z.string().min(1),
+  action_prompt: z.string().min(1),
+  poll_interval_ms: z.number().int().min(15000).optional(),
+  config: z.record(z.string(), z.unknown()).optional(),
+  credential_service: z.string().optional(),
+});
+
+const WatcherListParams = z.object({
+  watcher_id: z.string().optional(),
+  enabled_only: z.boolean().optional().default(false),
+});
+
+const WatcherUpdateParams = z.object({
+  watcher_id: z.string().min(1),
+  name: z.string().optional(),
+  action_prompt: z.string().optional(),
+  poll_interval_ms: z.number().int().min(15000).optional(),
+  enabled: z.boolean().optional(),
+  config: z.record(z.string(), z.unknown()).optional(),
+});
+
+const WatcherDeleteParams = z.object({
+  watcher_id: z.string().min(1),
+});
+
+const WatcherDigestParams = z.object({
+  watcher_id: z.string().optional(),
+  hours: z.number().positive().optional().default(24),
+  limit: z.number().int().positive().optional().default(50),
+});
+
+// -- Handlers -----------------------------------------------------------------
+
+function handleWatcherCreate(params?: Record<string, unknown>): unknown {
+  const {
+    name,
+    provider: providerId,
+    action_prompt: actionPrompt,
+    poll_interval_ms: pollIntervalMs,
+    config,
+    credential_service: credentialServiceOverride,
+  } = WatcherCreateParams.parse(params);
+
+  const provider = getWatcherProvider(providerId);
+  if (!provider) {
+    const available =
+      listWatcherProviders()
+        .map((p) => p.id)
+        .join(", ") || "none";
+    throw new Error(
+      `Unknown provider "${providerId}". Available: ${available}`,
+    );
+  }
+
+  const credentialService =
+    credentialServiceOverride ?? provider.requiredCredentialService;
+
+  const watcher = createWatcher({
+    name,
+    providerId,
+    actionPrompt,
+    credentialService,
+    pollIntervalMs,
+    configJson: config ? JSON.stringify(config) : null,
+  });
+
+  return watcher;
+}
+
+function handleWatcherList(params?: Record<string, unknown>): unknown {
+  const { watcher_id: watcherId, enabled_only: enabledOnly } =
+    WatcherListParams.parse(params ?? {});
+
+  if (watcherId) {
+    const watcher = getWatcher(watcherId);
+    if (!watcher) {
+      throw new Error(`Watcher not found: ${watcherId}`);
+    }
+    const events = listWatcherEvents({ watcherId, limit: 10 });
+    return { watcher, events };
+  }
+
+  return listWatchers({ enabledOnly });
+}
+
+function handleWatcherUpdate(params?: Record<string, unknown>): unknown {
+  const {
+    watcher_id: watcherId,
+    name,
+    action_prompt: actionPrompt,
+    poll_interval_ms: pollIntervalMs,
+    enabled,
+    config,
+  } = WatcherUpdateParams.parse(params);
+
+  const updates: {
+    name?: string;
+    actionPrompt?: string;
+    pollIntervalMs?: number;
+    enabled?: boolean;
+    configJson?: string | null;
+  } = {};
+
+  if (name !== undefined) updates.name = name;
+  if (actionPrompt !== undefined) updates.actionPrompt = actionPrompt;
+  if (pollIntervalMs !== undefined) updates.pollIntervalMs = pollIntervalMs;
+  if (enabled !== undefined) updates.enabled = enabled;
+  if (config !== undefined) updates.configJson = JSON.stringify(config);
+
+  if (Object.keys(updates).length === 0) {
+    throw new Error(
+      "No updates provided. Specify at least one field to update.",
+    );
+  }
+
+  const watcher = updateWatcher(watcherId, updates);
+  if (!watcher) {
+    throw new Error(`Watcher not found: ${watcherId}`);
+  }
+
+  return watcher;
+}
+
+function handleWatcherDelete(params?: Record<string, unknown>): unknown {
+  const { watcher_id: watcherId } = WatcherDeleteParams.parse(params);
+
+  const watcher = getWatcher(watcherId);
+  if (!watcher) {
+    throw new Error(`Watcher not found: ${watcherId}`);
+  }
+
+  deleteWatcher(watcherId);
+
+  // Evict any in-process provider state (e.g. Linear issue-state cache)
+  const provider = getWatcherProvider(watcher.providerId);
+  provider?.cleanup?.(watcherId);
+
+  return { deleted: true, name: watcher.name };
+}
+
+function handleWatcherDigest(params?: Record<string, unknown>): unknown {
+  const {
+    watcher_id: watcherId,
+    hours,
+    limit,
+  } = WatcherDigestParams.parse(params ?? {});
+
+  const since = Date.now() - hours * 3_600_000;
+  const events = listWatcherEvents({ watcherId, limit, since });
+
+  const allWatchers = listWatchers();
+  const watcherNames: Record<string, string> = {};
+  for (const w of allWatchers) {
+    watcherNames[w.id] = w.name;
+  }
+
+  return { events, watcherNames };
+}
+
+// -- Route definitions --------------------------------------------------------
+
+export const watcherRoutes: IpcRoute[] = [
+  { method: "watcher/create", handler: handleWatcherCreate },
+  { method: "watcher_create", handler: handleWatcherCreate },
+  { method: "watcher/list", handler: handleWatcherList },
+  { method: "watcher_list", handler: handleWatcherList },
+  { method: "watcher/update", handler: handleWatcherUpdate },
+  { method: "watcher_update", handler: handleWatcherUpdate },
+  { method: "watcher/delete", handler: handleWatcherDelete },
+  { method: "watcher_delete", handler: handleWatcherDelete },
+  { method: "watcher/digest", handler: handleWatcherDigest },
+  { method: "watcher_digest", handler: handleWatcherDigest },
+];

package/src/ipc/socket-path.ts

@@ -0,0 +1,100 @@
+import { createHash } from "node:crypto";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { getWorkspaceDir } from "../util/platform.js";
+
+const DARWIN_UNIX_SOCKET_MAX_PATH_BYTES = 103;
+const DEFAULT_UNIX_SOCKET_MAX_PATH_BYTES = 107;
+const IPC_TMP_DIR_NAME = "vellum-ipc";
+const IPC_BASE_DATA_DIR_NAME = "ipc";
+
+export type IpcSocketPathSource =
+  | "workspace"
+  | "base-data-dir"
+  | "tmp-hash"
+  | "tmp-short-hash";
+
+export interface IpcSocketPathResolution {
+  path: string;
+  source: IpcSocketPathSource;
+  workspacePath: string;
+  maxPathBytes: number;
+}
+
+function getUnixSocketMaxPathBytes(): number {
+  return process.platform === "darwin"
+    ? DARWIN_UNIX_SOCKET_MAX_PATH_BYTES
+    : DEFAULT_UNIX_SOCKET_MAX_PATH_BYTES;
+}
+
+function isPathWithinSocketLimit(path: string, maxPathBytes: number): boolean {
+  return Buffer.byteLength(path, "utf8") <= maxPathBytes;
+}
+
+function buildBaseDataDirCandidate(socketFileName: string): string | null {
+  const baseDataDir = process.env.BASE_DATA_DIR?.trim();
+  if (!baseDataDir) return null;
+  return join(baseDataDir, IPC_BASE_DATA_DIR_NAME, socketFileName);
+}
+
+function buildTmpCandidate(
+  workspacePath: string,
+  socketFileName: string,
+): { hashedPath: string; shortPath: string } {
+  const hash = createHash("sha256")
+    .update(workspacePath)
+    .digest("hex")
+    .slice(0, 12);
+  return {
+    hashedPath: join(tmpdir(), IPC_TMP_DIR_NAME, `${hash}-${socketFileName}`),
+    shortPath: join(tmpdir(), `v-${hash}.sock`),
+  };
+}
+
+export function resolveIpcSocketPath(
+  socketFileName: string,
+  workspaceDir: string = getWorkspaceDir(),
+): IpcSocketPathResolution {
+  const maxPathBytes = getUnixSocketMaxPathBytes();
+  const workspacePath = join(workspaceDir, socketFileName);
+
+  if (isPathWithinSocketLimit(workspacePath, maxPathBytes)) {
+    return {
+      path: workspacePath,
+      source: "workspace",
+      workspacePath,
+      maxPathBytes,
+    };
+  }
+
+  const baseDataDirCandidate = buildBaseDataDirCandidate(socketFileName);
+  if (
+    baseDataDirCandidate &&
+    isPathWithinSocketLimit(baseDataDirCandidate, maxPathBytes)
+  ) {
+    return {
+      path: baseDataDirCandidate,
+      source: "base-data-dir",
+      workspacePath,
+      maxPathBytes,
+    };
+  }
+
+  const tmpCandidate = buildTmpCandidate(workspacePath, socketFileName);
+  if (isPathWithinSocketLimit(tmpCandidate.hashedPath, maxPathBytes)) {
+    return {
+      path: tmpCandidate.hashedPath,
+      source: "tmp-hash",
+      workspacePath,
+      maxPathBytes,
+    };
+  }
+
+  return {
+    path: tmpCandidate.shortPath,
+    source: "tmp-short-hash",
+    workspacePath,
+    maxPathBytes,
+  };
+}

package/src/memory/__tests__/conversation-analyze-job.test.ts

@@ -64,6 +64,7 @@ mock.module("../auto-analysis-enqueue.js", () => ({
 
 import { DEFAULT_CONFIG } from "../../config/defaults.js";
 import type { AssistantConfig } from "../../config/types.js";
+import { BackendUnavailableError } from "../../util/errors.js";
 import { conversationAnalyzeJob } from "../conversation-analyze-job.js";
 import type { MemoryJob } from "../jobs-store.js";
 
@@ -121,20 +122,20 @@ describe("conversationAnalyzeJob", () => {
     expect(mockGetAnalysisDeps).not.toHaveBeenCalled();
   });
 
-  test("returns without calling the service when deps singleton is not yet initialized", async () => {
-    // Deps singleton is unset during slow daemon startup. The handler must
-    // NOT throw — a plain Error here is classified as fatal by
-    // classifyError() and the worker would mark the job permanently failed
-    // (failMemoryJob with maxAttempts: 1). Returning lets the next batch /
-    // idle / lifecycle trigger from enqueueAutoAnalysisIfEnabled() produce
-    // a fresh job once the daemon has fully started.
+  test("throws BackendUnavailableError when deps singleton is not yet initialized", async () => {
+    // Deps singleton is unset during slow daemon startup. The handler throws
+    // BackendUnavailableError so handleJobError() in the worker defers the
+    // job with exponential backoff (via deferMemoryJob) instead of completing
+    // it. Returning success here would permanently drop the job via
+    // completeMemoryJob — conversations with a pre-existing queued job
+    // during startup and no subsequent activity would never be analyzed.
     mockGetAnalysisDeps.mockImplementation(() => null);
     await expect(
       conversationAnalyzeJob(
         makeJob({ conversationId: "conv-1" }),
         TEST_CONFIG,
       ),
-    ).resolves.toBeUndefined();
+    ).rejects.toBeInstanceOf(BackendUnavailableError);
     expect(analyzeCalls).toHaveLength(0);
     expect(mockGetAnalysisDeps).toHaveBeenCalled();
   });

package/src/memory/__tests__/conversation-group-migration.test.ts

@@ -0,0 +1,99 @@
+import { beforeAll, describe, expect, mock, test } from "bun:test";
+
+mock.module("../../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+import { ensureGroupMigration } from "../conversation-group-migration.js";
+import { initializeDb, rawAll, rawExec, rawGet, rawRun } from "../db.js";
+
+initializeDb();
+
+// Simulate a legacy install that has the `system:reflections` system group
+// plus a conversation pointing at it. The migration must:
+//   1. Seed the current system groups (without `system:reflections`).
+//   2. Move the legacy conversation to `system:background` (step 6).
+//   3. Delete the orphaned `system:reflections` row (step 7).
+//
+// We pre-create the `conversation_groups` table and `group_id` column directly
+// because the migration's own CREATE TABLE IF NOT EXISTS / ALTER TABLE steps
+// would otherwise be the first to introduce them — there's no way to seed the
+// "legacy" row until they exist.
+describe("ensureGroupMigration — reflections cleanup", () => {
+  beforeAll(() => {
+    rawExec(`
+      CREATE TABLE IF NOT EXISTS conversation_groups (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL,
+        sort_position REAL NOT NULL DEFAULT 0,
+        is_system_group BOOLEAN NOT NULL DEFAULT FALSE,
+        created_at INTEGER NOT NULL DEFAULT (strftime('%s', 'now')),
+        updated_at INTEGER NOT NULL DEFAULT (strftime('%s', 'now'))
+      )
+    `);
+    try {
+      rawRun(
+        "ALTER TABLE conversations ADD COLUMN group_id TEXT REFERENCES conversation_groups(id) ON DELETE SET NULL",
+      );
+    } catch {
+      // column already present — ok
+    }
+    rawRun(
+      "INSERT OR IGNORE INTO conversation_groups (id, name, sort_position, is_system_group) VALUES ('system:reflections', 'Reflections', 100, TRUE)",
+    );
+    const now = Math.floor(Date.now() / 1000);
+    rawRun(
+      "INSERT INTO conversations (id, created_at, updated_at, group_id) VALUES (?, ?, ?, ?)",
+      "legacy-refl-1",
+      now,
+      now,
+      "system:reflections",
+    );
+
+    ensureGroupMigration();
+  });
+
+  test("moves legacy system:reflections conversations to system:background", () => {
+    const legacy = rawGet<{ group_id: string | null }>(
+      "SELECT group_id FROM conversations WHERE id = 'legacy-refl-1'",
+    );
+    expect(legacy?.group_id).toBe("system:background");
+  });
+
+  test("deletes the orphaned system:reflections group row", () => {
+    const refl = rawGet<{ id: string }>(
+      "SELECT id FROM conversation_groups WHERE id = 'system:reflections'",
+    );
+    expect(refl).toBeNull();
+  });
+
+  test("seeds the current system groups without system:reflections", () => {
+    const systemIds = rawAll<{ id: string }>(
+      "SELECT id FROM conversation_groups WHERE id LIKE 'system:%' ORDER BY id",
+    ).map((r) => r.id);
+    expect(systemIds).toEqual([
+      "system:all",
+      "system:background",
+      "system:pinned",
+      "system:scheduled",
+    ]);
+  });
+
+  test("records the cleanup sentinel so the step is idempotent", () => {
+    const sentinel = rawGet<{ id: string }>(
+      "SELECT id FROM conversation_groups WHERE id = '_reflections_group_deleted_complete'",
+    );
+    expect(sentinel?.id).toBe("_reflections_group_deleted_complete");
+  });
+
+  test("re-running ensureGroupMigration does not recreate the stale group", () => {
+    expect(() => ensureGroupMigration()).not.toThrow();
+    const refl = rawGet<{ id: string }>(
+      "SELECT id FROM conversation_groups WHERE id = 'system:reflections'",
+    );
+    expect(refl).toBeNull();
+  });
+});

package/src/memory/admin.ts

@@ -6,6 +6,11 @@ import { deleteMemoryCheckpoint } from "./checkpoints.js";
 import { getConversationMemoryScopeId } from "./conversation-crud.js";
 import { getDb, rawGet } from "./db.js";
 import { getMemoryBackendStatus } from "./embedding-backend.js";
+import {
+  type CompactionOptions,
+  type CompactionResult,
+  compactLongMemories,
+} from "./graph/compaction.js";
 import { handleRecall, type RecallResult } from "./graph/tool-handlers.js";
 import {
   enqueueBackfillJob,
@@ -138,6 +143,19 @@ export async function cleanupShortSegments(opts?: {
   return { removed, failed };
 }
 
+// ── Long-memory compaction ────────────────────────────────────────────
+
+/**
+ * One-off backfill that rewrites over-long memory node content to fit the
+ * extraction prompt's 1-3 sentence / ~300 character length cap. Preview
+ * mode (opts.apply=false) lists candidates without calling the LLM.
+ */
+export async function compactLongMemoryNodes(
+  opts: CompactionOptions = {},
+): Promise<CompactionResult> {
+  return compactLongMemories(opts);
+}
+
 // ── Re-extraction ──────────────────────────────────────────────────────
 
 export interface ReextractTarget {

package/src/memory/conversation-analyze-job.ts

@@ -3,9 +3,8 @@
 //
 // Bridges the jobs worker to the shared analyzeConversation() service. The
 // deps bundle is stashed on a module singleton during daemon startup; if it
-// isn't set yet we skip this iteration. The next batch / idle / lifecycle
-// trigger from `enqueueAutoAnalysisIfEnabled()` will produce a fresh job
-// once the daemon has fully started.
+// isn't set yet the handler throws BackendUnavailableError so the worker
+// defers with exponential backoff until deps become available.
 //
 // The service itself distinguishes manual vs. auto triggers: this handler
 // always invokes with `trigger: "auto"`, so the rolling analysis conversation
@@ -15,6 +14,7 @@
 import type { AssistantConfig } from "../config/types.js";
 import { analyzeConversation } from "../runtime/services/analyze-conversation.js";
 import { getAnalysisDeps } from "../runtime/services/analyze-deps-singleton.js";
+import { BackendUnavailableError } from "../util/errors.js";
 import { getLogger } from "../util/logger.js";
 import { enqueueAutoAnalysisIfEnabled } from "./auto-analysis-enqueue.js";
 import type { MemoryJob } from "./jobs-store.js";
@@ -33,19 +33,20 @@ export async function conversationAnalyzeJob(
 
   const deps = getAnalysisDeps();
   if (!deps) {
-    // Daemon hasn't finished startup. Return without throwing — a plain
-    // Error here would be classified as fatal by `classifyError()` and the
-    // worker would mark the job permanently failed. Throwing
-    // `BackendUnavailableError` would defer, but defer counters cap out and
-    // would still permanently fail in the worst case. Since
-    // `enqueueAutoAnalysisIfEnabled()` re-enqueues on the next batch / idle
-    // / lifecycle trigger, dropping this iteration is the safest choice and
-    // avoids retry storms during slow daemon startup.
+    // Daemon hasn't finished startup. Throw BackendUnavailableError so the
+    // worker defers the job with exponential backoff instead of completing
+    // it. Returning success here would permanently drop the job via
+    // completeMemoryJob — conversations with a pre-existing queued job
+    // during startup and no subsequent activity would never be analyzed.
+    // The deferral budget (50 × up to 5min backoff) is generous enough to
+    // outlast any realistic startup delay.
     log.warn(
       { jobId: job.id, conversationId },
-      "Skipping job: analysis deps not yet initialized; will retrigger",
+      "Deferring job: analysis deps not yet initialized",
+    );
+    throw new BackendUnavailableError(
+      "Analysis deps not yet initialized during daemon startup",
     );
-    return;
   }
 
   const result = await analyzeConversation(conversationId, deps, {

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

@@ -172,11 +172,8 @@ export function seedForkedConversationAttention(params: {
   latestAssistantMessageId: string | null;
   latestAssistantMessageAt: number | null;
 }): void {
-  const {
-    conversationId,
-    latestAssistantMessageId,
-    latestAssistantMessageAt,
-  } = params;
+  const { conversationId, latestAssistantMessageId, latestAssistantMessageAt } =
+    params;
 
   if (!latestAssistantMessageId || latestAssistantMessageAt == null) {
     return;
@@ -458,9 +455,15 @@ function resolveAssistantCursor(params: {
  * This uses the existing attention projection instead of adding a separate
  * manual-unread state machine.
  */
-export function markConversationUnread(conversationId: string): void {
+/**
+ * Returns `true` when the seen cursor was actually rewound (state changed),
+ * `false` when the conversation was already unread (no-op).
+ * Throws `UserError` when there is no assistant message to mark unread.
+ */
+export function markConversationUnread(conversationId: string): boolean {
   const db = getDb();
   const now = Date.now();
+  let changed = false;
 
   db.transaction((tx) => {
     const state = tx
@@ -511,6 +514,7 @@ export function markConversationUnread(conversationId: string): void {
           updatedAt: now,
         })
         .run();
+      changed = true;
       return;
     }
 
@@ -524,7 +528,10 @@ export function markConversationUnread(conversationId: string): void {
         eq(conversationAssistantAttentionState.conversationId, conversationId),
       )
       .run();
+    changed = true;
   });
+
+  return changed;
 }
 
 // ── getAttentionStateByConversationIds ───────────────────────────────