@vellumai/assistant 0.7.1 → 0.7.3

package/src/mcp/mcp-auth-state.ts

@@ -0,0 +1,133 @@
+/**
+ * In-memory MCP OAuth flow status map.
+ *
+ * Tracks the current state of daemon-owned MCP OAuth flows so the CLI can
+ * poll for completion via the IPC route.
+ */
+
+/**
+ * Sibling: `assistant/src/security/oauth-callback-registry.ts`. The two look
+ * similar (in-memory map, supersede semantics, ~5 min TTL) but live at
+ * different layers. The callback registry stores the deferred resolve/reject
+ * pair for a single OAuth code arrival, keyed by OAuth `state`. This file
+ * stores observable status (pending / complete / error) keyed by serverId so
+ * the polling CLI can render progress without holding a long-lived IPC
+ * connection.
+ */
+type McpAuthState =
+  | { status: "pending"; authUrl: string; attemptId: string; expiresAt: number }
+  | {
+      status: "complete";
+      serverId: string;
+      attemptId: string;
+      completedAt: number;
+    }
+  | { status: "error"; error: string; attemptId: string; failedAt: number };
+
+const activeMcpAuthFlows = new Map<string, McpAuthState>();
+
+const PENDING_TTL_MS = 5 * 60 * 1000; // 5 min — matches oauth-callback-registry.ts
+const COMPLETION_GRACE_MS = 60 * 1000; // 60s so the polling CLI gets one final read
+
+/**
+ * Record that an OAuth flow is pending authorization.
+ * Overwrites any prior state for the same serverId (supersede semantics
+ * matching registerPendingCallback). The caller must pass an `attemptId`
+ * (a unique token per attempt) so that fire-and-forget completion writes
+ * can verify they still own the slot before mutating shared state — see
+ * `setMcpAuthComplete` / `setMcpAuthError`.
+ */
+export function setMcpAuthPending(
+  serverId: string,
+  authUrl: string,
+  attemptId: string,
+): void {
+  activeMcpAuthFlows.set(serverId, {
+    status: "pending",
+    authUrl,
+    attemptId,
+    expiresAt: Date.now() + PENDING_TTL_MS,
+  });
+}
+
+/**
+ * Record that an OAuth flow completed successfully. Returns true if the
+ * write was applied; false if the attempt has been superseded by a newer
+ * one (in which case the caller's tail should silently exit without
+ * touching state).
+ */
+export function setMcpAuthComplete(
+  serverId: string,
+  attemptId: string,
+): boolean {
+  const current = activeMcpAuthFlows.get(serverId);
+  if (current && current.attemptId !== attemptId) {
+    return false; // superseded
+  }
+  activeMcpAuthFlows.set(serverId, {
+    status: "complete",
+    serverId,
+    attemptId,
+    completedAt: Date.now(),
+  });
+  return true;
+}
+
+/**
+ * Record that an OAuth flow failed. Returns true if the write was applied;
+ * false if the attempt has been superseded.
+ */
+export function setMcpAuthError(
+  serverId: string,
+  error: string,
+  attemptId: string,
+): boolean {
+  const current = activeMcpAuthFlows.get(serverId);
+  if (current && current.attemptId !== attemptId) {
+    return false; // superseded
+  }
+  activeMcpAuthFlows.set(serverId, {
+    status: "error",
+    error,
+    attemptId,
+    failedAt: Date.now(),
+  });
+  return true;
+}
+
+/**
+ * Get the current state of an OAuth flow, or null if none exists.
+ */
+export function getMcpAuthState(serverId: string): McpAuthState | null {
+  clearExpiredMcpAuthStates();
+  return activeMcpAuthFlows.get(serverId) ?? null;
+}
+
+/**
+ * Remove expired entries from the auth flow map.
+ */
+export function clearExpiredMcpAuthStates(): void {
+  const now = Date.now();
+  for (const [serverId, state] of activeMcpAuthFlows) {
+    if (state.status === "pending" && now > state.expiresAt) {
+      activeMcpAuthFlows.delete(serverId);
+    } else if (
+      state.status === "complete" &&
+      now > state.completedAt + COMPLETION_GRACE_MS
+    ) {
+      activeMcpAuthFlows.delete(serverId);
+    } else if (
+      state.status === "error" &&
+      now > state.failedAt + COMPLETION_GRACE_MS
+    ) {
+      activeMcpAuthFlows.delete(serverId);
+    }
+  }
+}
+
+/**
+ * Test-only helper — clears all auth flow state for test isolation.
+ */
+export function _clearAllMcpAuthStates(): void {
+  activeMcpAuthFlows.clear();
+}

package/src/mcp/mcp-oauth-provider.ts

@@ -61,6 +61,16 @@ export interface McpOAuthCallbackResult {
 /** Which callback transport to use for receiving the OAuth redirect. */
 export type McpOAuthCallbackTransport = "loopback" | "gateway";
 
+export interface McpOAuthProviderOptions {
+  /**
+   * If provided, called with the authorization URL during
+   * redirectToAuthorization() instead of opening a browser.
+   * Used by the daemon-side orchestrator so it can return the
+   * URL to the IPC caller (CLI / web client).
+   */
+  onAuthorizationUrl?: (url: string) => void;
+}
+
 export class McpOAuthProvider implements OAuthClientProvider {
   private readonly serverId: string;
   private readonly serverUrl: string;
@@ -75,6 +85,7 @@ export class McpOAuthProvider implements OAuthClientProvider {
   /** Deferred resolver/rejector for the gateway code promise. */
   private _gatewayCodeResolve: ((code: string) => void) | undefined;
   private _gatewayCodeReject: ((err: Error) => void) | undefined;
+  private readonly _onAuthorizationUrl: ((url: string) => void) | undefined;
 
   /**
    * @param interactive When true (e.g. `mcp auth` CLI), opens browser for OAuth.
@@ -82,17 +93,20 @@ export class McpOAuthProvider implements OAuthClientProvider {
    * @param callbackTransport Which transport to use for the OAuth redirect.
    *   - `"loopback"` (default): localhost HTTP server — for desktop clients.
    *   - `"gateway"`: platform ingress + callback registry — for Docker/platform.
+   * @param options Additional options for the provider.
    */
   constructor(
     serverId: string,
     serverUrl: string,
     interactive = false,
     callbackTransport: McpOAuthCallbackTransport = "loopback",
+    options: McpOAuthProviderOptions = {},
   ) {
     this.serverId = serverId;
     this.serverUrl = serverUrl;
     this.interactive = interactive;
     this.callbackTransport = callbackTransport;
+    this._onAuthorizationUrl = options.onAuthorizationUrl;
   }
 
   // --- redirectUrl ---
@@ -269,6 +283,11 @@ export class McpOAuthProvider implements OAuthClientProvider {
       }
     }
 
+    if (this._onAuthorizationUrl) {
+      this._onAuthorizationUrl(url);
+      return;
+    }
+
     if (!this.interactive) {
       // Daemon mode — don't open browser, just log guidance
       log.info(

package/src/media/image-service.ts

@@ -76,10 +76,4 @@ export function providerForModel(
   return fallback;
 }
 
-export type {
-  GeneratedImage,
-  ImageGenCredentials,
-  ImageGenerationRequest,
-  ImageGenerationResult,
-  ImageGenProvider,
-} from "./types.js";
+export type { ImageGenCredentials } from "./types.js";

package/src/memory/__tests__/fixtures/memory-v2-activation-fixtures.ts

@@ -1,7 +1,6 @@
 import type {
   MemoryV2ConceptRowRecord,
   MemoryV2ConfigSnapshot,
-  MemoryV2SkillRowRecord,
 } from "../../memory-v2-activation-log-store.js";
 
 export const sampleConcepts: MemoryV2ConceptRowRecord[] = [
@@ -13,10 +12,28 @@ export const sampleConcepts: MemoryV2ConceptRowRecord[] = [
     simUser: 0.6,
     simAssistant: 0.4,
     simNow: 0.3,
+    simUserRerankBoost: 0,
+    simAssistantRerankBoost: 0,
+    inRerankPool: false,
     spreadContribution: 0.2,
     source: "both",
     status: "injected",
   },
+  {
+    slug: "skills/skill-1",
+    finalActivation: 0.8,
+    ownActivation: 0.8,
+    priorActivation: 0,
+    simUser: 0.5,
+    simAssistant: 0.4,
+    simNow: 0.3,
+    simUserRerankBoost: 0,
+    simAssistantRerankBoost: 0,
+    inRerankPool: false,
+    spreadContribution: 0,
+    source: "ann_top50",
+    status: "injected",
+  },
   {
     slug: "concept-b",
     finalActivation: 0.4,
@@ -25,23 +42,15 @@ export const sampleConcepts: MemoryV2ConceptRowRecord[] = [
     simUser: 0.2,
     simAssistant: 0.1,
     simNow: 0.05,
+    simUserRerankBoost: 0,
+    simAssistantRerankBoost: 0,
+    inRerankPool: false,
     spreadContribution: 0.0,
     source: "ann_top50",
     status: "not_injected",
   },
 ];
 
-export const sampleSkills: MemoryV2SkillRowRecord[] = [
-  {
-    id: "skill-1",
-    activation: 0.8,
-    simUser: 0.5,
-    simAssistant: 0.4,
-    simNow: 0.3,
-    status: "injected",
-  },
-];
-
 export const sampleConfig: MemoryV2ConfigSnapshot = {
   d: 0.85,
   c_user: 1.0,
@@ -50,6 +59,5 @@ export const sampleConfig: MemoryV2ConfigSnapshot = {
   k: 5,
   hops: 2,
   top_k: 10,
-  top_k_skills: 3,
   epsilon: 0.001,
 };

package/src/memory/__tests__/jobs-store-job-classes.test.ts

@@ -0,0 +1,24 @@
+import { describe, expect, test } from "bun:test";
+
+import { EMBED_JOB_TYPES, SLOW_LLM_JOB_TYPES } from "../jobs-store.js";
+
+describe("memory job classes", () => {
+  test("EMBED_JOB_TYPES and SLOW_LLM_JOB_TYPES are disjoint", () => {
+    const embedSet = new Set<string>(EMBED_JOB_TYPES);
+    const overlap = SLOW_LLM_JOB_TYPES.filter((t) => embedSet.has(t));
+    expect(overlap).toEqual([]);
+  });
+
+  test("SLOW_LLM_JOB_TYPES entries are non-empty strings", () => {
+    expect(SLOW_LLM_JOB_TYPES.length).toBeGreaterThan(0);
+    for (const t of SLOW_LLM_JOB_TYPES) {
+      expect(typeof t).toBe("string");
+      expect(t.length).toBeGreaterThan(0);
+    }
+  });
+
+  test("SLOW_LLM_JOB_TYPES has no duplicate entries", () => {
+    const set = new Set(SLOW_LLM_JOB_TYPES);
+    expect(set.size).toBe(SLOW_LLM_JOB_TYPES.length);
+  });
+});

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

@@ -1,23 +1,23 @@
 /**
- * Tests for the v2 consolidation entry in `maybeEnqueueGraphMaintenanceJobs`.
+ * Tests for v1/v2 mutual exclusion in `maybeEnqueueGraphMaintenanceJobs`.
  *
- * Coverage matrix (from PR 24 acceptance criteria):
- *   - Flag off → no `memory_v2_consolidate` row enqueued, even after the
- *     interval has elapsed.
- *   - Flag on + config off → still no row enqueued (both gates required).
- *   - Flag on + config on, no prior checkpoint → row enqueued, checkpoint
- *     stamped to `nowMs`.
- *   - Flag on + config on, recent checkpoint → no row enqueued (interval
- *     not yet elapsed).
- *   - Flag on + config on, stale checkpoint → row enqueued, checkpoint
+ * 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.
+ *
+ * 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.
- *   - The v1 maintenance entries (decay, consolidate, pattern_scan,
- *     narrative) still fire under the v2 path — adding the v2 entry must
- *     not regress v1 scheduling.
  *
- * The sweep job is intentionally NOT scheduled here: PR 24 wires it into
- * the `graph_extract` debounce in `indexer.ts`. Those triggers are covered
- * by the separate trigger-path tests; this file owns only the cron entries.
+ * The sweep job is intentionally NOT scheduled here: it is wired into the
+ * `graph_extract` debounce in `indexer.ts`. Those triggers are covered by
+ * the separate trigger-path tests; this file owns only the cron entries.
  *
  * Tests use a temp workspace pinned via `VELLUM_WORKSPACE_DIR` so the DB
  * lives under `tmpdir()` and `~/.vellum/` is never touched.
@@ -145,6 +145,11 @@ describe("maybeEnqueueGraphMaintenanceJobs — memory v2 consolidation", () => {
     maybeEnqueueGraphMaintenanceJobs(config, Date.now());
 
     expect(countPendingJobs("memory_v2_consolidate")).toBe(1);
+    // v1 entries are suppressed when v2 is active.
+    expect(countPendingJobs("graph_decay")).toBe(0);
+    expect(countPendingJobs("graph_consolidate")).toBe(0);
+    expect(countPendingJobs("graph_pattern_scan")).toBe(0);
+    expect(countPendingJobs("graph_narrative_refine")).toBe(0);
   });
 
   test("does not enqueue consolidate before the interval has elapsed", () => {
@@ -200,11 +205,30 @@ describe("maybeEnqueueGraphMaintenanceJobs — memory v2 consolidation", () => {
     expect(countPendingJobs("memory_v2_consolidate")).toBe(1);
   });
 
-  test("v1 graph maintenance entries still fire alongside the v2 entry", () => {
+  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 should be due.
+    // No checkpoints set — every entry would be due if it were scheduled.
+    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(0);
+    expect(countPendingJobs("graph_consolidate")).toBe(0);
+    expect(countPendingJobs("graph_pattern_scan")).toBe(0);
+    expect(countPendingJobs("graph_narrative_refine")).toBe(0);
+    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");
@@ -217,19 +241,25 @@ describe("maybeEnqueueGraphMaintenanceJobs — memory v2 consolidation", () => {
     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(1);
+    expect(countPendingJobs("memory_v2_consolidate")).toBe(0);
   });
 
-  test("flag-off path does not enqueue v2 but still fires the v1 entries", () => {
-    _setOverridesForTesting({ "memory-v2-enabled": false });
-    const config = buildConfig({ v2Enabled: true, intervalHours: 1 });
+  test("config-gate-off path fires v1 entries and does not enqueue v2", () => {
+    _setOverridesForTesting({ "memory-v2-enabled": true });
+    const config = buildConfig({ v2Enabled: false, 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);
   });
 });

package/src/memory/__tests__/memory-v2-activation-log-store.test.ts

@@ -29,7 +29,6 @@ import { memoryV2ActivationLogs } from "../schema.js";
 import {
   sampleConcepts,
   sampleConfig,
-  sampleSkills,
 } from "./fixtures/memory-v2-activation-fixtures.js";
 
 initializeDb();
@@ -53,7 +52,6 @@ describe("memory-v2-activation-log-store", () => {
       turn: 3,
       mode: "per-turn",
       concepts: sampleConcepts,
-      skills: sampleSkills,
       config: sampleConfig,
     });
 
@@ -65,7 +63,6 @@ describe("memory-v2-activation-log-store", () => {
     expect(result!.turn).toBe(3);
     expect(result!.mode).toBe("per-turn");
     expect(result!.concepts).toEqual(sampleConcepts);
-    expect(result!.skills).toEqual(sampleSkills);
     expect(result!.config).toEqual(sampleConfig);
   });
 
@@ -82,7 +79,6 @@ describe("memory-v2-activation-log-store", () => {
       turn: 1,
       mode: "context-load",
       concepts: sampleConcepts,
-      skills: sampleSkills,
       config: sampleConfig,
     });
     recordMemoryV2ActivationLog({
@@ -90,7 +86,6 @@ describe("memory-v2-activation-log-store", () => {
       turn: 2,
       mode: "per-turn",
       concepts: sampleConcepts,
-      skills: sampleSkills,
       config: sampleConfig,
     });
 
@@ -110,7 +105,6 @@ describe("memory-v2-activation-log-store", () => {
       turn: 3,
       mode: "per-turn",
       concepts: sampleConcepts,
-      skills: sampleSkills,
       config: sampleConfig,
     });