@vellumai/assistant 0.7.3 → 0.8.0

package/src/ipc/skill-server.ts

@@ -37,9 +37,13 @@
  * back to a shorter deterministic path via the shared socket-path resolver.
  */
 
-import { existsSync, mkdirSync, unlinkSync } from "node:fs";
+import { existsSync, unlinkSync } from "node:fs";
 import { createServer, type Server, type Socket } from "node:net";
-import { dirname } from "node:path";
+
+import {
+  ensureSocketDir,
+  SocketWatchdog,
+} from "@vellumai/ipc-server-utils";
 
 import {
   type SkillRouteHandle,
@@ -233,6 +237,15 @@ class SkillIpcConnectionState implements SkillIpcConnection {
 // Server
 // ---------------------------------------------------------------------------
 
+/** Optional configuration for {@link SkillIpcServer}. */
+export interface SkillIpcServerOptions {
+  /**
+   * How often the socket-file watchdog stats the listening socket path.
+   * Set to `0` to disable. Defaults to {@link SocketWatchdog}'s 5000ms.
+   */
+  watchdogIntervalMs?: number;
+}
+
 export class SkillIpcServer {
   private server: Server | null = null;
   private clients = new Set<Socket>();
@@ -252,8 +265,15 @@ export class SkillIpcServer {
   private connections = new WeakMap<Socket, SkillIpcConnectionState>();
   private nextConnectionId = 1;
   private socketPath: string;
+  private watchdog: SocketWatchdog;
+  /**
+   * Servers whose listener path has been replaced by a re-bind. Kept around
+   * so already-connected sockets continue to work; closed gracefully once
+   * their accept loops drain.
+   */
+  private legacyServers = new Set<Server>();
 
-  constructor() {
+  constructor(options?: SkillIpcServerOptions) {
     const resolution = resolveSkillIpcSocketPath();
     this.socketPath = resolution.path;
     log.info(
@@ -266,6 +286,21 @@ export class SkillIpcServer {
     for (const route of skillIpcStreamingRoutes) {
       this.streamingMethods.set(route.method, route.handler);
     }
+
+    this.watchdog = new SocketWatchdog({
+      socketPath: this.socketPath,
+      intervalMs: options?.watchdogIntervalMs,
+      getServer: () => this.server,
+      createServer: () => this.createListeningServer(),
+      onRebind: (newServer, oldServer) => {
+        this.server = newServer;
+        this.legacyServers.add(oldServer);
+        oldServer.close(() => {
+          this.legacyServers.delete(oldServer);
+        });
+      },
+      log,
+    });
   }
 
   /** Register an additional method handler after construction. */
@@ -349,17 +384,71 @@ export class SkillIpcServer {
   /** Start listening on the Unix domain socket. */
   async start(): Promise<void> {
     // Ensure the parent directory exists before listening.
-    const socketDir = dirname(this.socketPath);
-    if (!existsSync(socketDir)) {
-      mkdirSync(socketDir, { recursive: true, mode: 0o700 });
-    }
+    ensureSocketDir(this.socketPath);
 
     // Probe before unlink so a second daemon can't silently orphan an active
     // listener (Unix lets you unlink a still-bound socket file). See
     // `ensureSocketPathFree` for the behavior matrix.
     await ensureSocketPathFree(this.socketPath);
 
-    this.server = createServer((socket) => {
+    this.server = this.createListeningServer();
+    this.server.listen(this.socketPath, () => {
+      log.info({ path: this.socketPath }, "Skill IPC server listening");
+    });
+
+    this.watchdog.start();
+  }
+
+  /** Stop the server and disconnect all clients. */
+  stop(): void {
+    this.watchdog.stop();
+
+    for (const client of this.clients) {
+      this.teardownSubscriptions(client);
+      this.teardownConnection(client);
+      if (!client.destroyed) client.destroy();
+    }
+    this.clients.clear();
+
+    for (const legacy of this.legacyServers) {
+      legacy.close();
+    }
+    this.legacyServers.clear();
+
+    if (this.server) {
+      this.server.close();
+      this.server = null;
+    }
+
+    if (existsSync(this.socketPath)) {
+      try {
+        unlinkSync(this.socketPath);
+      } catch {
+        // Ignore
+      }
+    }
+  }
+
+  /** Get the socket path (for diagnostics). */
+  getSocketPath(): string {
+    return this.socketPath;
+  }
+
+  /**
+   * Re-bind the listening socket if its path entry is missing on disk.
+   *
+   * Public for tests so the watchdog can be exercised deterministically
+   * without waiting for the interval. Returns `true` when a re-bind was
+   * performed, `false` otherwise.
+   */
+  async rebindIfMissing(): Promise<boolean> {
+    return this.watchdog.rebindIfMissing();
+  }
+
+  // ── Internal ──────────────────────────────────────────────────────────
+
+  private createListeningServer(): Server {
+    const server = createServer((socket) => {
       this.clients.add(socket);
       const connection = new SkillIpcConnectionState(
         `skill-ipc-${this.nextConnectionId++}`,
@@ -406,45 +495,13 @@ export class SkillIpcServer {
       });
     });
 
-    this.server.on("error", (err) => {
+    server.on("error", (err) => {
       log.error({ err }, "Skill IPC server error");
     });
 
-    this.server.listen(this.socketPath, () => {
-      log.info({ path: this.socketPath }, "Skill IPC server listening");
-    });
-  }
-
-  /** Stop the server and disconnect all clients. */
-  stop(): void {
-    for (const client of this.clients) {
-      this.teardownSubscriptions(client);
-      this.teardownConnection(client);
-      if (!client.destroyed) client.destroy();
-    }
-    this.clients.clear();
-
-    if (this.server) {
-      this.server.close();
-      this.server = null;
-    }
-
-    if (existsSync(this.socketPath)) {
-      try {
-        unlinkSync(this.socketPath);
-      } catch {
-        // Ignore
-      }
-    }
-  }
-
-  /** Get the socket path (for diagnostics). */
-  getSocketPath(): string {
-    return this.socketPath;
+    return server;
   }
 
-  // ── Internal ──────────────────────────────────────────────────────────
-
   private handleMessage(socket: Socket, line: string): void {
     let frame: IpcRequest & { result?: unknown; error?: string };
     try {

package/src/memory/__tests__/jobs-worker-v2-schedule.test.ts

@@ -1,19 +1,16 @@
 /**
  * Tests for v1/v2 mutual exclusion in `maybeEnqueueGraphMaintenanceJobs`.
  *
- * The schedule is now mutually exclusive: when both the `memory-v2-enabled`
- * flag and `memory.v2.enabled` config are on, only `memory_v2_consolidate`
- * is scheduled; otherwise the four v1 entries (decay, consolidate,
- * pattern_scan, narrative) fire and the v2 entry does not.
+ * The schedule is mutually exclusive: when `memory.v2.enabled` is true,
+ * only `memory_v2_consolidate` is scheduled; otherwise the four v1
+ * entries (decay, consolidate, pattern_scan, narrative) fire and the v2
+ * entry does not.
  *
  * Coverage:
- *   - Flag off → only v1 entries fire (no `memory_v2_consolidate`).
- *   - Flag on + config off → only v1 entries fire.
- *   - Flag on + config on, no prior checkpoint → only the v2 entry fires.
- *   - Flag on + config on, recent checkpoint → no v2 row (interval not
- *     yet elapsed).
- *   - Flag on + config on, stale checkpoint → v2 row enqueued, checkpoint
- *     refreshed.
+ *   - Config off → only v1 entries fire (no `memory_v2_consolidate`).
+ *   - Config on, no prior checkpoint → only the v2 entry fires.
+ *   - Config on, recent checkpoint → no v2 row (interval not yet elapsed).
+ *   - Config on, stale checkpoint → v2 row enqueued, checkpoint refreshed.
  *
  * The sweep job is intentionally NOT scheduled here: it is wired into the
  * `graph_extract` debounce in `indexer.ts`. Those triggers are covered by
@@ -27,7 +24,6 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import {
   afterAll,
-  afterEach,
   beforeAll,
   beforeEach,
   describe,
@@ -69,8 +65,6 @@ const { getDb } = await import("../db-connection.js");
 const { initializeDb } = await import("../db-init.js");
 const { resetTestTables } = await import("../raw-query.js");
 const { memoryJobs } = await import("../schema.js");
-const { _setOverridesForTesting } =
-  await import("../../config/assistant-feature-flags.js");
 const { applyNestedDefaults } = await import("../../config/loader.js");
 const { setMemoryCheckpoint, deleteMemoryCheckpoint } =
   await import("../checkpoints.js");
@@ -111,26 +105,10 @@ beforeEach(() => {
   resetTestTables("memory_jobs", "memory_checkpoints");
 });
 
-afterEach(() => {
-  _setOverridesForTesting({});
-});
-
 // ---------------------------------------------------------------------------
 
 describe("maybeEnqueueGraphMaintenanceJobs — memory v2 consolidation", () => {
-  test("does not enqueue consolidate when memory-v2-enabled flag is off", () => {
-    _setOverridesForTesting({ "memory-v2-enabled": false });
-    const config = buildConfig({ v2Enabled: true, intervalHours: 1 });
-
-    // Force the interval to look elapsed. If the gate failed open, this
-    // would be enough to enqueue a job.
-    maybeEnqueueGraphMaintenanceJobs(config, Date.now());
-
-    expect(countPendingJobs("memory_v2_consolidate")).toBe(0);
-  });
-
   test("does not enqueue consolidate when config.memory.v2.enabled is off", () => {
-    _setOverridesForTesting({ "memory-v2-enabled": true });
     const config = buildConfig({ v2Enabled: false, intervalHours: 1 });
 
     maybeEnqueueGraphMaintenanceJobs(config, Date.now());
@@ -138,8 +116,7 @@ describe("maybeEnqueueGraphMaintenanceJobs — memory v2 consolidation", () => {
     expect(countPendingJobs("memory_v2_consolidate")).toBe(0);
   });
 
-  test("enqueues consolidate when both gates are on and no checkpoint exists", () => {
-    _setOverridesForTesting({ "memory-v2-enabled": true });
+  test("enqueues consolidate when v2 is on and no checkpoint exists", () => {
     const config = buildConfig({ v2Enabled: true, intervalHours: 1 });
 
     maybeEnqueueGraphMaintenanceJobs(config, Date.now());
@@ -153,7 +130,6 @@ describe("maybeEnqueueGraphMaintenanceJobs — memory v2 consolidation", () => {
   });
 
   test("does not enqueue consolidate before the interval has elapsed", () => {
-    _setOverridesForTesting({ "memory-v2-enabled": true });
     const config = buildConfig({ v2Enabled: true, intervalHours: 1 });
 
     const now = Date.now();
@@ -166,7 +142,6 @@ describe("maybeEnqueueGraphMaintenanceJobs — memory v2 consolidation", () => {
   });
 
   test("enqueues consolidate again once the interval elapses", () => {
-    _setOverridesForTesting({ "memory-v2-enabled": true });
     const config = buildConfig({ v2Enabled: true, intervalHours: 1 });
 
     const now = Date.now();
@@ -182,7 +157,6 @@ describe("maybeEnqueueGraphMaintenanceJobs — memory v2 consolidation", () => {
   });
 
   test("respects a custom consolidation_interval_hours value", () => {
-    _setOverridesForTesting({ "memory-v2-enabled": true });
     const config = buildConfig({ v2Enabled: true, intervalHours: 6 });
 
     const now = Date.now();
@@ -206,7 +180,6 @@ describe("maybeEnqueueGraphMaintenanceJobs — memory v2 consolidation", () => {
   });
 
   test("v1 maintenance entries are suppressed when v2 is active", () => {
-    _setOverridesForTesting({ "memory-v2-enabled": true });
     const config = buildConfig({ v2Enabled: true, intervalHours: 1 });
 
     // No checkpoints set — every entry would be due if it were scheduled.
@@ -225,27 +198,7 @@ describe("maybeEnqueueGraphMaintenanceJobs — memory v2 consolidation", () => {
     expect(countPendingJobs("memory_v2_consolidate")).toBe(1);
   });
 
-  test("flag-off path fires v1 entries and does not enqueue v2", () => {
-    _setOverridesForTesting({ "memory-v2-enabled": false });
-    const config = buildConfig({ v2Enabled: true, intervalHours: 1 });
-
-    deleteMemoryCheckpoint("graph_maintenance:decay:last_run");
-    deleteMemoryCheckpoint("graph_maintenance:consolidate:last_run");
-    deleteMemoryCheckpoint("graph_maintenance:pattern_scan:last_run");
-    deleteMemoryCheckpoint("graph_maintenance:narrative:last_run");
-    deleteMemoryCheckpoint(CONSOLIDATE_CHECKPOINT_KEY);
-
-    maybeEnqueueGraphMaintenanceJobs(config, Date.now());
-
-    expect(countPendingJobs("graph_decay")).toBe(1);
-    expect(countPendingJobs("graph_consolidate")).toBe(1);
-    expect(countPendingJobs("graph_pattern_scan")).toBe(1);
-    expect(countPendingJobs("graph_narrative_refine")).toBe(1);
-    expect(countPendingJobs("memory_v2_consolidate")).toBe(0);
-  });
-
-  test("config-gate-off path fires v1 entries and does not enqueue v2", () => {
-    _setOverridesForTesting({ "memory-v2-enabled": true });
+  test("v2-off path fires v1 entries and does not enqueue v2", () => {
     const config = buildConfig({ v2Enabled: false, intervalHours: 1 });
 
     deleteMemoryCheckpoint("graph_maintenance:decay:last_run");

package/src/memory/context-search/sources/memory-v2.ts

@@ -2,7 +2,7 @@
 // Memory v2 — `recall` adapter for the `memory` source
 // ---------------------------------------------------------------------------
 //
-// When the v2 flag is on, the `memory` recall source reads from the v2
+// When v2 is enabled, the `memory` recall source reads from the v2
 // concept-page subsystem (under `<workspace>/memory/concepts/`) instead of
 // the legacy graph. Two retrieval paths run in parallel and merge:
 //
@@ -26,8 +26,6 @@
 import { readdir, readFile, realpath, stat } from "node:fs/promises";
 import { extname, isAbsolute, join, relative } from "node:path";
 
-import { isAssistantFeatureFlagEnabled } from "../../../config/assistant-feature-flags.js";
-import type { AssistantConfig } from "../../../config/schema.js";
 import { getLogger } from "../../../util/logger.js";
 import { embedWithRetry } from "../../embed.js";
 import { generateSparseEmbedding } from "../../embedding-backend.js";
@@ -46,20 +44,6 @@ import type {
   RecallSearchResult,
 } from "../types.js";
 
-/**
- * True when both v2 gates are on. Single source of truth for whether v2 is
- * the active memory subsystem — used by recall sources (`memory`, `pkb`),
- * per-turn injectors, the indexer's v1 graph_extract suppression, and the
- * v1/v2 maintenance scheduler. The historical name retains "Read" but the
- * predicate now gates both read and write paths.
- */
-export function isMemoryV2ReadActive(config: AssistantConfig): boolean {
-  return (
-    isAssistantFeatureFlagEnabled("memory-v2-enabled", config) &&
-    config.memory.v2.enabled
-  );
-}
-
 const log = getLogger("context-search-memory-v2-source");
 
 /**

package/src/memory/context-search/sources/memory.ts

@@ -9,7 +9,7 @@ import type {
   RecallSearchContext,
   RecallSearchResult,
 } from "../types.js";
-import { isMemoryV2ReadActive, searchMemoryV2Source } from "./memory-v2.js";
+import { searchMemoryV2Source } from "./memory-v2.js";
 
 const log = getLogger("context-search-memory-source");
 
@@ -23,7 +23,7 @@ export async function searchMemorySource(
     return { evidence: [] };
   }
 
-  if (isMemoryV2ReadActive(context.config)) {
+  if (context.config.memory.v2.enabled) {
     return searchMemoryV2Source(query, context, normalizedLimit);
   }
 

package/src/memory/context-search/sources/pkb.ts

@@ -15,7 +15,6 @@ import type {
   RecallSearchContext,
   RecallSearchResult,
 } from "../types.js";
-import { isMemoryV2ReadActive } from "./memory-v2.js";
 
 const log = getLogger("context-search-pkb-source");
 
@@ -76,7 +75,7 @@ export async function searchPkbSource(
   context: RecallSearchContext,
   limit: number,
 ): Promise<RecallSearchResult> {
-  if (isMemoryV2ReadActive(context.config)) {
+  if (context.config.memory.v2.enabled) {
     return { evidence: [] };
   }
 
@@ -139,7 +138,7 @@ export async function searchPkbSource(
 export function readPkbContextEvidence(
   context: RecallSearchContext,
 ): RecallEvidence[] {
-  if (isMemoryV2ReadActive(context.config)) {
+  if (context.config.memory.v2.enabled) {
     return [];
   }