@vellumai/assistant 0.7.3 → 0.8.0

package/src/runtime/routes/__tests__/memory-v2-routes.test.ts

@@ -0,0 +1,147 @@
+/**
+ * Tests for the memory v2 route handlers in `memory-v2-routes.ts`.
+ *
+ * Currently focused on `memory_v2_list_concept_pages`:
+ *   - empty workspace → returns no pages
+ *   - populated workspace → surfaces slug, bodyBytes, edgeCount, updatedAtMs
+ *   - corrupt page on disk → logged-and-skipped, does not poison listing
+ */
+
+import { mkdtempSync, rmSync } from "node:fs";
+import { mkdir, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import { writePage } from "../../../memory/v2/page-store.js";
+import type { ConceptPage } from "../../../memory/v2/types.js";
+import type { MemoryV2ListConceptPagesResult } from "../memory-v2-routes.js";
+import { ROUTES } from "../memory-v2-routes.js";
+import type { RouteDefinition } from "../types.js";
+
+// ─── Setup ─────────────────────────────────────────────────────────────────
+
+let workspaceDir: string;
+let origWorkspaceDir: string | undefined;
+
+function findHandler(operationId: string): RouteDefinition["handler"] {
+  const route = ROUTES.find((r) => r.operationId === operationId);
+  if (!route) throw new Error(`Route ${operationId} not found`);
+  return route.handler;
+}
+
+beforeEach(() => {
+  workspaceDir = mkdtempSync(join(tmpdir(), "vellum-memv2-list-"));
+  origWorkspaceDir = process.env.VELLUM_WORKSPACE_DIR;
+  process.env.VELLUM_WORKSPACE_DIR = workspaceDir;
+});
+
+afterEach(() => {
+  if (origWorkspaceDir === undefined) {
+    delete process.env.VELLUM_WORKSPACE_DIR;
+  } else {
+    process.env.VELLUM_WORKSPACE_DIR = origWorkspaceDir;
+  }
+  try {
+    rmSync(workspaceDir, { recursive: true, force: true });
+  } catch {
+    // best-effort cleanup
+  }
+});
+
+// ─── Tests ─────────────────────────────────────────────────────────────────
+
+describe("memory_v2_list_concept_pages handler", () => {
+  test("returns empty list for an empty workspace", async () => {
+    const handler = findHandler("memory_v2_list_concept_pages");
+    const result = (await handler({
+      body: {},
+    })) as MemoryV2ListConceptPagesResult;
+
+    expect(result).toEqual({ pages: [] });
+  });
+
+  test("returns slugs, body bytes, edge counts, and mtimes for populated workspace", async () => {
+    const before = Date.now();
+
+    const pages: ConceptPage[] = [
+      {
+        slug: "alice",
+        frontmatter: { edges: ["bob", "carol"], ref_files: [] },
+        body: "Alice prefers VS Code.\n",
+      },
+      {
+        slug: "bob",
+        frontmatter: { edges: [], ref_files: [] },
+        body: "Bob ships at end of day.\nLikes async standups.\n",
+      },
+      {
+        slug: "people/carol",
+        frontmatter: { edges: ["alice"], ref_files: [] },
+        body: "Carol leads the platform team.\n",
+      },
+    ];
+    for (const page of pages) {
+      await writePage(workspaceDir, page);
+    }
+
+    const handler = findHandler("memory_v2_list_concept_pages");
+    const result = (await handler({
+      body: {},
+    })) as MemoryV2ListConceptPagesResult;
+
+    expect(result.pages).toHaveLength(3);
+
+    const bySlug = new Map(result.pages.map((p) => [p.slug, p]));
+
+    const alice = bySlug.get("alice");
+    expect(alice).toBeDefined();
+    expect(alice!.bodyBytes).toBe(Buffer.byteLength(pages[0]!.body, "utf8"));
+    expect(alice!.edgeCount).toBe(2);
+    expect(alice!.updatedAtMs).toBeGreaterThanOrEqual(before);
+    // updatedAtMs must be an integer on the wire — Swift clients decode it as
+    // Int64 and a sub-millisecond float (which fs.Stats.mtimeMs returns by
+    // default) breaks JSONDecoder strict number parsing.
+    expect(Number.isInteger(alice!.updatedAtMs)).toBe(true);
+
+    const bob = bySlug.get("bob");
+    expect(bob).toBeDefined();
+    expect(bob!.bodyBytes).toBe(Buffer.byteLength(pages[1]!.body, "utf8"));
+    expect(bob!.edgeCount).toBe(0);
+    expect(bob!.updatedAtMs).toBeGreaterThanOrEqual(before);
+    expect(Number.isInteger(bob!.updatedAtMs)).toBe(true);
+
+    const carol = bySlug.get("people/carol");
+    expect(carol).toBeDefined();
+    expect(carol!.bodyBytes).toBe(Buffer.byteLength(pages[2]!.body, "utf8"));
+    expect(carol!.edgeCount).toBe(1);
+    expect(carol!.updatedAtMs).toBeGreaterThanOrEqual(before);
+    expect(Number.isInteger(carol!.updatedAtMs)).toBe(true);
+  });
+
+  test("tolerates a single corrupt page — returns valid pages and skips the broken one", async () => {
+    await writePage(workspaceDir, {
+      slug: "valid-page",
+      frontmatter: { edges: [], ref_files: [] },
+      body: "Body of the valid page.\n",
+    });
+
+    // A `.md` file with frontmatter that fails schema validation — `edges`
+    // must be a list of strings, not a single number — so `readPage` throws.
+    const conceptsDir = join(workspaceDir, "memory", "concepts");
+    await mkdir(conceptsDir, { recursive: true });
+    await writeFile(
+      join(conceptsDir, "broken.md"),
+      "---\nedges: 42\n---\nbroken body\n",
+      "utf-8",
+    );
+
+    const handler = findHandler("memory_v2_list_concept_pages");
+    const result = (await handler({
+      body: {},
+    })) as MemoryV2ListConceptPagesResult;
+
+    expect(result.pages).toHaveLength(1);
+    expect(result.pages.map((p) => p.slug)).toEqual(["valid-page"]);
+  });
+});

package/src/runtime/routes/approval-routes.ts

@@ -62,8 +62,9 @@ function handleConfirm({ body }: RouteHandlerArgs) {
     throw new BadRequestError("decision must resolve to allow or deny");
   }
 
-  // Validation passed — consume the pending interaction.
-  const interaction = pendingInteractions.resolve(requestId)!;
+  // Validation passed. Use get() here — the prompter (or ACP directResolve path)
+  // owns deregistration via pendingInteractions.resolve().
+  const interaction = peeked;
 
   log.info(
     {
@@ -93,7 +94,9 @@ function handleConfirm({ body }: RouteHandlerArgs) {
   });
 
   // ACP permissions: resolve directly without a Conversation object.
+  // No PermissionPrompter involved, so the route owns deregistration.
   if (interaction.directResolve) {
+    pendingInteractions.resolve(requestId);
     interaction.directResolve(effectiveDecision as UserDecision);
     return { accepted: true };
   }
@@ -139,7 +142,8 @@ function handleSecret({ body }: RouteHandlerArgs) {
     throw new BadRequestError('delivery must be "store" or "transient_send"');
   }
 
-  const interaction = pendingInteractions.resolve(requestId);
+  // Use get() — SecretPrompter.resolveSecret() owns deregistration.
+  const interaction = pendingInteractions.get(requestId);
   if (!interaction) {
     throw new NotFoundError("No pending interaction found for this requestId");
   }

package/src/runtime/routes/consolidation-routes.ts

@@ -8,13 +8,13 @@
  * only surface its config and provide an on-demand trigger for the Settings UI.
  *
  * `available` mirrors the filing route's `available` field: it reflects which
- * background memory job is active for this instance. When `memory-v2-enabled`
- * is off, consolidation returns `available: false` and the UI hides the row.
+ * background memory job is active for this instance. When
+ * `config.memory.v2.enabled` is false, consolidation returns
+ * `available: false` and the UI hides the row.
  */
 
 import { z } from "zod";
 
-import { isAssistantFeatureFlagEnabled } from "../../config/assistant-feature-flags.js";
 import { getConfig } from "../../config/loader.js";
 import { getMemoryCheckpoint } from "../../memory/checkpoints.js";
 import {
@@ -26,7 +26,7 @@ import { BadRequestError } from "./errors.js";
 import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
 
 function isConsolidationAvailable(): boolean {
-  return isAssistantFeatureFlagEnabled("memory-v2-enabled", getConfig());
+  return getConfig().memory.v2.enabled;
 }
 
 function consolidationIntervalMs(): number {
@@ -66,14 +66,13 @@ export const ROUTES: RouteDefinition[] = [
       success: z.boolean(),
     }),
     handler: async (_args: RouteHandlerArgs) => {
-      const available = isConsolidationAvailable();
-      const v2Config = getConfig().memory.v2;
+      const enabled = getConfig().memory.v2.enabled;
       const intervalMs = consolidationIntervalMs();
       const lastRunAt = readLastRunAt();
       const nextRunAt = lastRunAt != null ? lastRunAt + intervalMs : null;
       return {
-        available,
-        enabled: available && v2Config.enabled,
+        available: enabled,
+        enabled,
         intervalMs,
         nextRunAt,
         lastRunAt,
@@ -99,7 +98,7 @@ export const ROUTES: RouteDefinition[] = [
     handler: async (_args: RouteHandlerArgs) => {
       if (!isConsolidationAvailable()) {
         throw new BadRequestError(
-          "Consolidation is not available (memory-v2-enabled is off)",
+          "Consolidation is not available (memory.v2.enabled is false)",
         );
       }
       // Coalesce: don't pile up duplicate jobs if the worker hasn't picked up

package/src/runtime/routes/conversation-query-routes.ts

@@ -22,7 +22,9 @@ import { z } from "zod";
 
 import {
   deepMergeOverwrite,
+  fillContextDefaultsForMissingKeys,
   getConfig,
+  getDeploymentContextDefaults,
   invalidateConfigCache,
   loadRawConfig,
   saveRawConfig,
@@ -312,9 +314,50 @@ async function handleSetEmbeddingConfig({ body }: RouteHandlerArgs) {
   }
 }
 
+/**
+ * Apply deployment-context defaults to a raw config payload before it goes
+ * out over the wire from `GET /v1/config`. The in-memory `loadConfig()`
+ * already layers these defaults for daemon-internal consumers; the GET
+ * response needs the same treatment so external clients (macOS, web, CLI)
+ * see the effective value rather than `undefined` when the daemon hasn't
+ * persisted an explicit choice yet. Without this, macOS's
+ * `loadServiceModes(config:)` short-circuits when `services.inference.mode`
+ * is missing and falls back to the SwiftUI `@Published` default of
+ * "your-own", which renders the wrong segment selection on freshly-hatched
+ * platform-managed assistants.
+ *
+ * Guards against `loadRawConfig()` handing us a value that is technically
+ * valid JSON but not a plain object (e.g. literal `null`, a number, or an
+ * array). `loadRawConfig` is typed `Record<string, unknown>` but `JSON.parse`
+ * itself doesn't enforce that — a malformed-but-parseable `config.json`
+ * would blow up `fillContextDefaultsForMissingKeys` on its `target[key]` /
+ * `fileConfig[key]` accesses, turning `GET /v1/config` into a 500 where it
+ * used to succeed (returning the malformed payload as-is). When `raw` is
+ * not a plain object, we return it unchanged.
+ *
+ * Exported for direct unit testing.
+ */
+export function applyContextDefaultsToRawConfig(raw: unknown): unknown {
+  const contextDefaults = getDeploymentContextDefaults();
+  if (
+    Object.keys(contextDefaults).length === 0 ||
+    raw === null ||
+    typeof raw !== "object" ||
+    Array.isArray(raw)
+  ) {
+    return raw;
+  }
+  fillContextDefaultsForMissingKeys(
+    raw as Record<string, unknown>,
+    raw as Record<string, unknown>,
+    contextDefaults,
+  );
+  return raw;
+}
+
 function handleGetConfig() {
   try {
-    return loadRawConfig();
+    return applyContextDefaultsToRawConfig(loadRawConfig());
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
     throw new InternalError(`Failed to read config: ${message}`);

package/src/runtime/routes/debug-bash-routes.ts

@@ -15,6 +15,7 @@ import { spawn } from "node:child_process";
 import { z } from "zod";
 
 import { getIsContainerized } from "../../config/env-registry.js";
+import { buildSanitizedEnv } from "../../tools/terminal/safe-env.js";
 import { getWorkspaceDir } from "../../util/platform.js";
 import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
 
@@ -92,6 +93,7 @@ function handleDebugBash({ body }: RouteHandlerArgs): Promise<DebugBashResult> {
       cwd: getWorkspaceDir(),
       stdio: ["ignore", "pipe", "pipe"],
       detached: true,
+      env: buildSanitizedEnv(),
     });
 
     const timer = setTimeout(() => {

package/src/runtime/routes/filing-routes.ts

@@ -2,14 +2,13 @@
  * Route handlers for filing management.
  *
  * `available` reflects whether the filing service is the active background
- * memory job for this instance. When the `memory-v2-enabled` flag is on,
+ * memory job for this instance. When `config.memory.v2.enabled` is true,
  * filing yields to the consolidation job (see consolidation-routes.ts) and
  * returns `available: false` so the UI can hide the row.
  */
 
 import { z } from "zod";
 
-import { isAssistantFeatureFlagEnabled } from "../../config/assistant-feature-flags.js";
 import { getConfig } from "../../config/loader.js";
 import { FilingService } from "../../filing/filing-service.js";
 import { getLogger } from "../../util/logger.js";
@@ -19,7 +18,7 @@ import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
 const log = getLogger("filing-routes");
 
 function isFilingAvailable(): boolean {
-  return !isAssistantFeatureFlagEnabled("memory-v2-enabled", getConfig());
+  return !getConfig().memory.v2.enabled;
 }
 
 // ---------------------------------------------------------------------------

package/src/runtime/routes/inbound-stages/guardian-reply-intercept.ts

@@ -174,9 +174,6 @@ export async function handleGuardianReplyIntercept(
         eventId,
         canonicalRouter: routerResult.type,
         requestId: routerResult.requestId,
-        ...(routerResult.activatedContact
-          ? { activatedContact: routerResult.activatedContact }
-          : {}),
       }),
       skipApprovalInterception: false,
     };

package/src/runtime/routes/memory-item-routes.test.ts

@@ -6,13 +6,6 @@
  */
 import { beforeAll, beforeEach, describe, expect, mock, test } from "bun:test";
 
-import { _setOverridesForTesting } from "../../config/assistant-feature-flags.js";
-
-// This test exercises v1 memory CRUD routes. The `memory-v2-enabled` flag
-// (registry default `true`) flips memory routing to v2 — disable it here so
-// the v1 paths under test stay active.
-_setOverridesForTesting({ "memory-v2-enabled": false });
-
 mock.module("../../util/logger.js", () => ({
   getLogger: () =>
     new Proxy({} as Record<string, unknown>, {
@@ -20,7 +13,8 @@ mock.module("../../util/logger.js", () => ({
     }),
 }));
 
-// Stub config loader — returns a config with memory enabled by default
+// Stub config loader — return a config with memory.v2.enabled=false so the
+// v1 paths under test stay active.
 mock.module("../../config/loader.js", () => ({
   loadConfig: () => mockConfig,
   getConfig: () => mockConfig,
@@ -28,7 +22,7 @@ mock.module("../../config/loader.js", () => ({
 }));
 
 // ── Controllable mocks for semantic search ─────────────────────────────
-const mockConfig: unknown = {};
+const mockConfig: unknown = { memory: { v2: { enabled: false } } };
 
 let mockBackendStatus: {
   enabled: boolean;

package/src/runtime/routes/memory-item-routes.ts

@@ -25,7 +25,6 @@ import {
 import { z } from "zod";
 
 import { getConfig } from "../../config/loader.js";
-import { isMemoryV2ReadActive } from "../../memory/context-search/sources/memory-v2.js";
 import { getDb } from "../../memory/db-connection.js";
 import {
   embedWithBackend,
@@ -176,11 +175,11 @@ async function searchNodesSemantic(
 ): Promise<{ ids: string[]; total: number } | null> {
   try {
     const config = getConfig();
-    // v2 owns the read path when both gates are on. Fall back to SQL search
-    // (the caller's `null` branch) instead of querying the v1 collection,
-    // which is in active retirement and a corrupted sparse segment can
-    // OOM-crash the shared Qdrant process.
-    if (isMemoryV2ReadActive(config)) return null;
+    // v2 owns the read path when enabled. Fall back to SQL search (the
+    // caller's `null` branch) instead of querying the v1 collection, which
+    // is in active retirement and a corrupted sparse segment can OOM-crash
+    // the shared Qdrant process.
+    if (config.memory.v2.enabled) return null;
     const backendStatus = await getMemoryBackendStatus(config);
     if (!backendStatus.provider) return null;
 

package/src/runtime/routes/memory-v2-routes.ts

@@ -4,9 +4,11 @@
  * Migrated from `ipc/routes/memory-v2-backfill.ts` and
  * `ipc/routes/memory-v2-validate.ts` into the shared ROUTES array.
  */
+import { stat } from "node:fs/promises";
+import { join } from "node:path";
+
 import { z } from "zod";
 
-import { isAssistantFeatureFlagEnabled } from "../../config/assistant-feature-flags.js";
 import { loadConfig } from "../../config/loader.js";
 import {
   applyCorrectionIfCalibrated,
@@ -32,6 +34,7 @@ import {
   validateEdgeTargets,
 } from "../../memory/v2/edge-index.js";
 import {
+  getConceptsDir,
   listPages,
   readPage,
   renderPageContent,
@@ -47,11 +50,37 @@ import {
   getConceptPageCorpusStats,
   rebuildConceptPageCorpusStats,
 } from "../../memory/v2/sparse-bm25.js";
+import { getLogger } from "../../util/logger.js";
 import { getWorkspaceDir } from "../../util/platform.js";
 import { RouteError } from "./errors.js";
 import type { RouteDefinition } from "./types.js";
 import type { RouteHandlerArgs } from "./types.js";
 
+const log = getLogger("memory-v2-routes");
+
+/**
+ * Wire-format error code emitted when v2 routes reject a request because
+ * `memory.v2.enabled` is false. Exported so tests and the macOS client can
+ * reference the same string without drift.
+ */
+export const MEMORY_V2_DISABLED_CODE = "MEMORY_V2_DISABLED";
+
+/**
+ * Reject the request when memory v2 is not active. Returning 409 (rather
+ * than serving a partial response) keeps clients honest — the desktop
+ * Memories panel reads this code to render an explicit "disabled in
+ * config" empty state.
+ */
+function requireMemoryV2Enabled(): void {
+  if (!loadConfig().memory.v2.enabled) {
+    throw new RouteError(
+      "Memory v2 is not enabled — set memory.v2.enabled to true to use this command.",
+      MEMORY_V2_DISABLED_CODE,
+      409,
+    );
+  }
+}
+
 // ── Backfill ────────────────────────────────────────────────────────────
 
 const MemoryV2BackfillParams = z
@@ -76,6 +105,7 @@ const OP_TO_JOB_TYPE: Record<MemoryV2BackfillOp, MemoryJobType> = {
 async function handleBackfill({
   body = {},
 }: RouteHandlerArgs): Promise<MemoryV2BackfillResult> {
+  requireMemoryV2Enabled();
   const { op, force } = MemoryV2BackfillParams.parse(body);
   const payload: Record<string, unknown> =
     op === "migrate" && force === true ? { force: true } : {};
@@ -102,6 +132,7 @@ export type MemoryV2ValidateResult = {
 async function handleValidate({
   body = {},
 }: RouteHandlerArgs): Promise<MemoryV2ValidateResult> {
+  requireMemoryV2Enabled();
   MemoryV2ValidateParams.parse(body);
 
   const workspaceDir = getWorkspaceDir();
@@ -158,6 +189,7 @@ export type MemoryV2GetConceptPageResult = {
 async function handleGetConceptPage({
   body = {},
 }: RouteHandlerArgs): Promise<MemoryV2GetConceptPageResult> {
+  requireMemoryV2Enabled();
   const { slug } = MemoryV2GetConceptPageParams.parse(body);
   const workspaceDir = getWorkspaceDir();
   let page;
@@ -180,6 +212,59 @@ async function handleGetConceptPage({
   return { slug, rendered: renderPageContent(page) };
 }
 
+// ── List concept pages ──────────────────────────────────────────────────
+
+const MemoryV2ListConceptPagesParams = z.object({}).strict();
+
+export type MemoryV2ListConceptPagesResult = {
+  pages: Array<{
+    slug: string;
+    bodyBytes: number;
+    edgeCount: number;
+    updatedAtMs: number;
+  }>;
+};
+
+async function handleListConceptPages({
+  body = {},
+}: RouteHandlerArgs): Promise<MemoryV2ListConceptPagesResult> {
+  requireMemoryV2Enabled();
+  MemoryV2ListConceptPagesParams.parse(body);
+
+  const workspaceDir = getWorkspaceDir();
+  const conceptsDir = getConceptsDir(workspaceDir);
+  const slugs = await listPages(workspaceDir);
+
+  const settled = await Promise.all(
+    slugs.map(async (slug) => {
+      try {
+        const page = await readPage(workspaceDir, slug);
+        if (!page) return null;
+        const stats = await stat(join(conceptsDir, `${slug}.md`));
+        return {
+          slug,
+          bodyBytes: Buffer.byteLength(page.body, "utf8"),
+          edgeCount: page.frontmatter.edges.length,
+          updatedAtMs: Math.floor(stats.mtimeMs),
+        };
+      } catch (err) {
+        // A single corrupt page (bad YAML, schema mismatch, etc.) shouldn't
+        // poison the whole listing — the validate route is the place to
+        // surface those; this one is read-only and best-effort.
+        log.warn(
+          `Skipping concept page '${slug}' in list-concept-pages: ${err instanceof Error ? err.message : String(err)}`,
+        );
+        return null;
+      }
+    }),
+  );
+  const pages = settled.filter(
+    (p): p is MemoryV2ListConceptPagesResult["pages"][number] => p !== null,
+  );
+
+  return { pages };
+}
+
 // ── Rebuild BM25 corpus stats ───────────────────────────────────────────
 
 const MemoryV2RebuildCorpusStatsParams = z.object({}).strict();
@@ -194,6 +279,7 @@ export interface MemoryV2RebuildCorpusStatsResult {
 async function handleRebuildCorpusStats({
   body = {},
 }: RouteHandlerArgs): Promise<MemoryV2RebuildCorpusStatsResult> {
+  requireMemoryV2Enabled();
   MemoryV2RebuildCorpusStatsParams.parse(body);
   const workspaceDir = getWorkspaceDir();
   await rebuildConceptPageCorpusStats(workspaceDir);
@@ -225,23 +311,9 @@ export type MemoryV2ReembedSkillsResult = {
 async function handleReembedSkills({
   body = {},
 }: RouteHandlerArgs): Promise<MemoryV2ReembedSkillsResult> {
+  requireMemoryV2Enabled();
   MemoryV2ReembedSkillsParams.parse(body);
 
-  // Gate the route on both the feature flag and the per-workspace config
-  // toggle so the v2 skill collection never gets re-seeded against a
-  // workspace whose v2 subsystem is intentionally off.
-  const config = loadConfig();
-  if (
-    !isAssistantFeatureFlagEnabled("memory-v2-enabled", config) ||
-    !config.memory.v2.enabled
-  ) {
-    throw new RouteError(
-      "Memory v2 is not enabled — flip both the memory-v2-enabled feature flag and memory.v2.enabled to use this command.",
-      "MEMORY_V2_DISABLED",
-      409,
-    );
-  }
-
   // Unlike the queued backfill jobs above, this is a CLI-driven sync
   // request: the operator wants the cache replaced before the next prompt
   // assembly, so we await the seed inline rather than enqueueing it.
@@ -416,6 +488,7 @@ async function scoreChannel(
 async function handleExplainSimilarity({
   body = {},
 }: RouteHandlerArgs): Promise<MemoryV2ExplainSimilarityResult> {
+  requireMemoryV2Enabled();
   const params = MemoryV2ExplainSimilarityParams.parse(body);
   const config = loadConfig();
   const { dense_weight: denseWeight, sparse_weight: sparseWeight } =
@@ -475,6 +548,7 @@ const MemoryV2ConceptFrequencyParams = z
 async function handleConceptFrequency({
   body = {},
 }: RouteHandlerArgs): Promise<ConceptFrequencyResponse> {
+  requireMemoryV2Enabled();
   const { conversationId, sinceMs } =
     MemoryV2ConceptFrequencyParams.parse(body);
   const workspaceDir = getWorkspaceDir();
@@ -517,6 +591,7 @@ export interface MemoryV2FitAnisotropyResult {
 async function handleFitAnisotropy({
   body = {},
 }: RouteHandlerArgs): Promise<MemoryV2FitAnisotropyResult> {
+  requireMemoryV2Enabled();
   const { k, sample } = MemoryV2FitAnisotropyParams.parse(body);
   const config = loadConfig();
 
@@ -603,6 +678,17 @@ export const ROUTES: RouteDefinition[] = [
     tags: ["memory"],
     requestBody: MemoryV2GetConceptPageParams,
   },
+  {
+    operationId: "memory_v2_list_concept_pages",
+    method: "POST",
+    endpoint: "memory/v2/list-concept-pages",
+    handler: handleListConceptPages,
+    summary: "List all memory v2 concept pages with metadata",
+    description:
+      "Returns slugs, body sizes, edge counts, and last-modified timestamps for every concept page on disk. Read-only; used by the desktop About → Memories surface to render a browse-able list.",
+    tags: ["memory"],
+    requestBody: MemoryV2ListConceptPagesParams,
+  },
   {
     operationId: "memory_v2_reembed_skills",
     method: "POST",
@@ -610,7 +696,7 @@ export const ROUTES: RouteDefinition[] = [
     handler: handleReembedSkills,
     summary: "Re-seed v2 skill entries from the current skill catalog",
     description:
-      "Synchronously re-runs seedV2SkillEntries against the current skill catalog. Gated on memory-v2-enabled flag and config.memory.v2.enabled.",
+      "Synchronously re-runs seedV2SkillEntries against the current skill catalog. Gated on config.memory.v2.enabled.",
     tags: ["memory"],
     requestBody: MemoryV2ReembedSkillsParams,
   },