collabmd 0.1.51 → 0.1.54

package/src/server/application/agent-content-service.js

@@ -16,6 +16,7 @@ import {
 } from '../../domain/excalidraw-agent-scene.js';
 import { inspectAgentExcalidrawScene, renderAgentExcalidrawSvg } from '../../domain/excalidraw-agent-verification.js';
 import { getVaultFileKind, isBaseFilePath } from '../../domain/file-kind.js';
+import { collectMarkdownOutline } from '../../domain/markdown-outline.js';
 import { isWholeWordMatch } from '../../domain/literal-text-search.js';
 import { createWikiTargetIndex } from '../../domain/wiki-link-resolver.js';
 import {
@@ -27,6 +28,7 @@ import {
   collectMarkdownImageSources,
   collectMarkdownReferences,
 } from '../domain/markdown-reference-extractor.js';
+import { searchExcalidrawSceneText } from '../domain/ripgrep-search-service.js';
 import { compareWorkspacePaths, normalizeWorkspacePath } from '../domain/workspace-state.js';
 
 const MAX_DOCUMENT_CHARACTERS = 200_000;
@@ -337,8 +339,8 @@ export class AgentContentService {
 
   async searchVault(actor, {
     kinds = [],
-    limit = 50,
-    maxSnippetsPerFile = 5,
+    limit = 10,
+    maxSnippetsPerFile = 2,
     prefix = '',
     query = '',
     wholeWord = false,
@@ -348,85 +350,124 @@ export class AgentContentService {
     const normalizedQuery = String(query ?? '').trim().slice(0, 500);
     const normalizedPrefix = normalizeWorkspacePath(prefix);
     const kindFilter = new Set(Array.isArray(kinds) ? kinds : []);
-    const snippetLimit = clampInteger(maxSnippetsPerFile, 5, 1, 10);
-    const result = await this.searchService.search({
-      kinds: [...kindFilter],
-      limit,
-      maxSnippetsPerFile: snippetLimit,
-      prefix: normalizedPrefix,
-      query: normalizedQuery,
-      wholeWord,
-      signal,
-    });
-    if (normalizedQuery.length < 2) return result;
-
+    const snippetLimit = clampInteger(maxSnippetsPerFile, 2, 1, 10);
+    const pageSize = clampInteger(limit, 10, 1, 50);
+    const livePaths = new Set();
+    let liveIncomplete = false;
     const liveFiles = [];
-    for (const [path, room] of this.roomRegistry?.getRooms?.() ?? []) {
+    for (const [path, room] of normalizedQuery.length >= 2 ? this.roomRegistry?.getRooms?.() ?? [] : []) {
       const kind = getVaultFileKind(path);
       if (
         !isAgentReadablePath(path)
-        || !room.isHydrated?.()
         || (normalizedPrefix && path !== normalizedPrefix && !path.startsWith(`${normalizedPrefix}/`))
         || (kindFilter.size > 0 && !kindFilter.has(kind))
       ) continue;
-      const content = room.readEditableContent?.();
-      if (content === null || content === undefined) continue;
-      if (content.length > MAX_AGENT_READ_SOURCE_CHARACTERS) continue;
-      const live = searchLiveText(content, normalizedQuery, snippetLimit, wholeWord);
+      livePaths.add(path);
+      const content = room.isHydrated?.()
+        ? room.readEditableContent?.() ?? room.getPersistedContent?.()
+        : null;
+      if (content == null || content.length > MAX_AGENT_READ_SOURCE_CHARACTERS) {
+        liveIncomplete = true;
+        continue;
+      }
+      signal?.throwIfAborted();
+      let live;
+      if (kind === 'excalidraw') {
+        let scene;
+        try {
+          scene = JSON.parse(content);
+        } catch {
+          liveIncomplete = true;
+          continue;
+        }
+        live = searchExcalidrawSceneText(scene, {
+          query: normalizedQuery, maxSnippetsPerFile: snippetLimit, wholeWord,
+        });
+      } else {
+        live = searchLiveText(content, normalizedQuery, snippetLimit, wholeWord);
+      }
       if (live.matchCount > 0) {
         liveFiles.push({ file: path, kind, ...live });
       }
     }
-    if (liveFiles.length === 0) return result;
-
-    const livePaths = new Set(liveFiles.map(({ file }) => file));
-    const files = [...result.files.filter(({ file }) => !livePaths.has(file)), ...liveFiles]
-      .sort((left, right) => compareWorkspacePaths(left.file, right.file))
-      .slice(0, clampInteger(limit, 50, 1, 50));
+    const result = await this.searchService.search({
+      excludedPaths: [...livePaths],
+      kinds: [...kindFilter],
+      limit: pageSize,
+      maxSnippetsPerFile: snippetLimit,
+      prefix: normalizedPrefix,
+      query: normalizedQuery,
+      wholeWord,
+      signal,
+    });
+    const candidates = [...result.files.filter(({ file }) => !livePaths.has(file)), ...liveFiles]
+      .sort((left, right) => compareWorkspacePaths(left.file, right.file));
+    const files = candidates.slice(0, pageSize);
     return {
       ...result,
       files,
       matchCount: files.reduce((sum, file) => sum + file.matchCount, 0),
-      truncated: result.truncated || files.length < result.files.length + liveFiles.length,
+      truncated: result.truncated || liveIncomplete || candidates.length > files.length
+        || files.some((file) => file.truncated),
     };
   }
 
-  async readDocument(actor, { lineCount = MAX_READ_LINES, path, startLine = 1 } = {}) {
+  async readDocument(actor, { lineCount = 80, mode = 'content', path, startLine = 1 } = {}) {
     requireScope(actor, 'vault:read');
     const normalizedPath = normalizeWorkspacePath(path);
+    const kind = getVaultFileKind(normalizedPath);
     if (!isAgentReadablePath(normalizedPath)) {
       throw createAgentContentError('AGENT_UNSUPPORTED_DOCUMENT', 'Document type is not readable by agents', 400);
     }
+    if (!['content', 'outline'].includes(mode) || (mode === 'outline' && kind !== 'markdown')) {
+      throw createAgentContentError('AGENT_INPUT_INVALID', 'Outline mode requires a Markdown document', 400);
+    }
     const content = await this.readCurrentContent(normalizedPath);
     if (content.length > MAX_AGENT_READ_SOURCE_CHARACTERS) {
       throw createAgentContentError('AGENT_DOCUMENT_TOO_LARGE', 'Document is too large for agent reading', 413);
     }
     const lines = content.split('\n');
     const start = clampInteger(startLine, 1, 1, Math.max(lines.length, 1));
-    const count = clampInteger(lineCount, MAX_READ_LINES, 1, MAX_READ_LINES);
-    let selected = lines.slice(start - 1, start - 1 + count).join('\n');
-    let characterTruncated = false;
-    let endLine = Math.min(start + count - 1, lines.length);
-    if (selected.length > MAX_READ_CHARACTERS) {
-      selected = selected.slice(0, MAX_READ_CHARACTERS);
-      characterTruncated = true;
-      let returnedLineCount = 1;
-      for (let index = 0; index < selected.length; index += 1) {
-        if (selected.charCodeAt(index) === 10) returnedLineCount += 1;
-      }
-      if (selected.endsWith('\n')) returnedLineCount -= 1;
-      endLine = Math.min(start + Math.max(returnedLineCount, 1) - 1, lines.length);
-    }
-    return {
-      content: selected,
-      endLine,
-      kind: getVaultFileKind(normalizedPath),
+    const count = clampInteger(lineCount, 80, 1, MAX_READ_LINES);
+    const result = {
+      content: '',
+      endLine: lines.length,
+      kind,
+      nextStartLine: null,
       path: normalizedPath,
       revision: await createEditableContentRevision(content),
       startLine: start,
       totalLines: lines.length,
-      truncated: characterTruncated || endLine < lines.length,
+      truncated: false,
     };
+    if (mode === 'outline') {
+      const headings = collectMarkdownOutline(content).filter(({ line }) => line >= start);
+      result.headings = headings.slice(0, count);
+      if (headings.length > count) {
+        result.endLine = result.headings.at(-1).line;
+        result.nextStartLine = headings[count].line;
+        result.truncated = true;
+      }
+      return result;
+    }
+    const selected = [];
+    let characters = 0;
+    for (const line of lines.slice(start - 1, start - 1 + count)) {
+      const size = line.length + (selected.length ? 1 : 0);
+      if (characters + size > MAX_READ_CHARACTERS) {
+        if (selected.length === 0) {
+          throw createAgentContentError('AGENT_DOCUMENT_LINE_TOO_LARGE', 'This line exceeds the 100000-character read limit; read a different line or use Markdown outline mode', 413);
+        }
+        break;
+      }
+      selected.push(line);
+      characters += size;
+    }
+    result.content = selected.join('\n');
+    result.endLine = start + selected.length - 1;
+    result.truncated = result.endLine < lines.length;
+    result.nextStartLine = result.truncated ? result.endLine + 1 : null;
+    return result;
   }
   async inspectDocumentReferences(actor, { path } = {}) {
     requireScope(actor, 'vault:read');
@@ -438,13 +479,22 @@ export class AgentContentService {
     if (content.length > MAX_AGENT_READ_SOURCE_CHARACTERS) {
       throw createAgentContentError('AGENT_DOCUMENT_TOO_LARGE', 'Document is too large for agent inspection', 413);
     }
+    return {
+      ...this.inspectMarkdownContent(normalizedPath, content),
+      backlinks: await this.backlinkIndex?.getBacklinks?.(normalizedPath) ?? [],
+      path: normalizedPath,
+      revision: await createEditableContentRevision(content),
+    };
+  }
+
+  inspectMarkdownContent(normalizedPath, content) {
     const entries = Array.from(this.workspaceMutationCoordinator?.workspaceState?.entries?.values?.() ?? []);
     const filePaths = entries
       .filter((entry) => entry.nodeType !== 'directory')
       .map((entry) => entry.path);
     const references = collectMarkdownReferences(content, {
       sourceFilePath: normalizedPath,
-      wikiTargetIndex: createWikiTargetIndex(filePaths),
+      wikiTargetIndex: createWikiTargetIndex([...filePaths, normalizedPath]),
     });
     const toPublicReference = (reference) => ({
       exists: Boolean(reference.resolvedPath),
@@ -468,10 +518,7 @@ export class AgentContentService {
         };
       });
     return {
-      backlinks: await this.backlinkIndex?.getBacklinks?.(normalizedPath) ?? [],
       embeds: references.filter(({ isEmbed }) => isEmbed).map(toPublicReference),
-      path: normalizedPath,
-      revision: await createEditableContentRevision(content),
       videos,
       wikiLinks: references.filter(({ isEmbed }) => !isEmbed).map(toPublicReference),
     };
@@ -479,6 +526,10 @@ export class AgentContentService {
 
   async validateDocument(actor, { path } = {}) {
     const inspected = await this.inspectDocumentReferences(actor, { path });
+    return { ...this.validateMarkdownReferences(inspected), path: inspected.path, revision: inspected.revision };
+  }
+
+  validateMarkdownReferences(inspected) {
     const issues = [];
     inspected.wikiLinks.filter(({ exists }) => !exists).forEach((reference) => {
       issues.push({
@@ -506,8 +557,6 @@ export class AgentContentService {
     });
     return {
       issues,
-      path: inspected.path,
-      revision: inspected.revision,
       valid: issues.length === 0,
     };
   }
@@ -587,12 +636,13 @@ export class AgentContentService {
   }
 
 
-  async applyTextEdits(actor, { path, replacements, revision } = {}) {
+  async applyTextEdits(actor, { path, replacements, revision, validate = false } = {}) {
     requireScope(actor, 'vault:edit');
     const normalizedPath = normalizeWorkspacePath(path);
     if (!isAgentEditablePath(normalizedPath)) {
       throw createAgentContentError('AGENT_UNSUPPORTED_DOCUMENT', 'Document type is not editable by agents', 400);
     }
+    this.requireMarkdownValidation(normalizedPath, validate);
     return this.runForPath(normalizedPath, async () => {
       const content = await this.readCurrentContent(normalizedPath);
       if (content.length > MAX_DOCUMENT_CHARACTERS) {
@@ -619,7 +669,13 @@ export class AgentContentService {
       const nextContent = applyExactTextChanges(content, changes);
       assertValidAgentBaseContent(normalizedPath, nextContent);
       const room = this.roomRegistry?.get?.(normalizedPath);
+      const validation = validate
+        ? this.validateMarkdownReferences(this.inspectMarkdownContent(normalizedPath, nextContent))
+        : null;
       if (room) {
+        if (room.readEditableContent() !== content) {
+          throw createAgentContentError('AGENT_REVISION_CONFLICT', 'Document changed; read it again before editing', 409);
+        }
         room.applyExactTextChanges(changes, {
           origin: createCollaborationOrigin(actor),
         });
@@ -636,7 +692,8 @@ export class AgentContentService {
       return {
         path: normalizedPath,
         replacementCount: changes.length,
-        revision: await createEditableContentRevision(room ? room.readEditableContent() : nextContent),
+        revision: await createEditableContentRevision(nextContent),
+        ...(validation ? { validation } : {}),
       };
     });
   }
@@ -795,18 +852,22 @@ export class AgentContentService {
     });
   }
 
-  async createDocument(actor, { content = '', path } = {}) {
+  async createDocument(actor, { content = '', path, validate = false } = {}) {
     requireScope(actor, 'vault:edit');
     const normalizedPath = normalizeWorkspacePath(path);
     if (!isAgentCreatablePath(normalizedPath)) {
       throw createAgentContentError('AGENT_UNSUPPORTED_DOCUMENT', 'Document type cannot be created by agents', 400);
     }
+    this.requireMarkdownValidation(normalizedPath, validate);
     const normalizedContent = normalizeEditableText(content);
     if (normalizedContent.length > MAX_DOCUMENT_CHARACTERS) {
       throw createAgentContentError('AGENT_DOCUMENT_TOO_LARGE', 'Document is too large for agent creation', 413);
     }
     assertValidAgentBaseContent(normalizedPath, normalizedContent);
     return this.runForPath(normalizedPath, async () => {
+      const validation = validate
+        ? this.validateMarkdownReferences(this.inspectMarkdownContent(normalizedPath, normalizedContent))
+        : null;
       const result = await this.workspaceMutationCoordinator.createFile({
         content: normalizedContent,
         origin: getMutationOrigin(actor),
@@ -827,10 +888,17 @@ export class AgentContentService {
         kind: getVaultFileKind(normalizedPath),
         path: normalizedPath,
         revision: await createEditableContentRevision(normalizedContent),
+        ...(validation ? { validation } : {}),
       };
     });
   }
 
+  requireMarkdownValidation(path, validate) {
+    if (validate && getVaultFileKind(path) !== 'markdown') {
+      throw createAgentContentError('AGENT_INPUT_INVALID', 'Reference validation requires a Markdown document', 400);
+    }
+  }
+
   getSyntax(actor, { kind = '' } = {}) {
     requireScope(actor, 'vault:read');
     if (!kind) return { capabilities: listCollabMdContentCapabilities() };

package/src/server/auth/create-auth-service.js

@@ -3,9 +3,6 @@ import {
   AUTH_STRATEGY_NONE,
   AUTH_STRATEGY_OIDC,
   AUTH_STRATEGY_PASSWORD,
-  SUPPORTED_AUTH_STRATEGIES,
-  createRandomAuthPassword,
-  createRandomSessionSecret,
 } from './auth-constants.js';
 import {
   buildClientConfig,
@@ -18,14 +15,27 @@ import {
   createPasswordStrategy,
 } from './auth-strategies.js';
 
-export {
-  AUTH_STRATEGY_NONE,
-  AUTH_STRATEGY_OIDC,
-  AUTH_STRATEGY_PASSWORD,
-  SUPPORTED_AUTH_STRATEGIES,
-  createRandomAuthPassword,
-  createRandomSessionSecret,
-};
+function resolveRequestProtocol(req) {
+  const forwarded = String(req.headers['x-forwarded-proto'] ?? '').split(',')[0].trim().toLowerCase();
+  if (forwarded === 'https' || forwarded === 'http') {
+    return `${forwarded}:`;
+  }
+
+  try {
+    const cfVisitor = JSON.parse(req.headers['cf-visitor'] ?? '');
+    if (String(cfVisitor?.scheme).toLowerCase() === 'https') {
+      return 'https:';
+    }
+  } catch {
+    // Non-Cloudflare requests carry no cf-visitor payload.
+  }
+
+  if (req.socket?.encrypted) {
+    return 'https:';
+  }
+
+  return 'http:';
+}
 
 export function createAuthService(config) {
   const authConfig = config.auth ?? { strategy: AUTH_STRATEGY_NONE };
@@ -72,8 +82,26 @@ export function createAuthService(config) {
     },
 
     authorizeWebSocketRequest(req) {
+      // Browsers always send Origin; clients without it still need authentication.
+      if (req.headers.origin !== undefined) {
+        let allowed = false;
+        try {
+          const protocol = resolveRequestProtocol(req);
+          const expectedOrigin = authConfig.oidc?.publicBaseUrl
+            ? new URL(authConfig.oidc.publicBaseUrl).origin
+            : new URL(`${protocol}//${req.headers.host}`).origin;
+          allowed = req.headers.origin === expectedOrigin;
+        } catch {
+          // Malformed or opaque origins are forbidden.
+        }
+        if (!allowed) {
+          return { ok: false, statusCode: 403, statusMessage: 'Forbidden', body: 'Origin not allowed' };
+        }
+      }
       if (strategy.isAuthenticated(req)) {
-        return { ok: true };
+        const expiresAt = authConfig.strategy === AUTH_STRATEGY_NONE
+          ? null : sessionCookieManager.readSession(req)?.expiresAt;
+        return { ok: true, expiresAt: Number.isFinite(expiresAt) ? expiresAt : null };
       }
 
       return {

package/src/server/auth/session-cookie.js

@@ -1,19 +1,11 @@
 import { createHmac, timingSafeEqual } from 'node:crypto';
 
 function decodeBase64Url(value) {
-  const normalized = String(value ?? '')
-    .replace(/-/g, '+')
-    .replace(/_/g, '/');
-  const paddingLength = (4 - (normalized.length % 4)) % 4;
-  return Buffer.from(`${normalized}${'='.repeat(paddingLength)}`, 'base64');
+  return Buffer.from(String(value ?? ''), 'base64url');
 }
 
 function encodeBase64Url(value) {
-  return Buffer.from(value)
-    .toString('base64')
-    .replace(/\+/g, '-')
-    .replace(/\//g, '_')
-    .replace(/=+$/g, '');
+  return Buffer.from(value).toString('base64url');
 }
 
 function parseCookieHeader(headerValue) {
@@ -78,6 +70,44 @@ export function createSignedCookieManager({
   cookiePath = '/',
   secret,
 }) {
+  // Authenticating one request can verify the same cookie several times
+  // (strategy check + expiry read + user lookup). Memoize per request object;
+  // the cookie-header check keeps it correct if headers ever change.
+  const readCache = new WeakMap();
+
+  function readSignedCookie(req) {
+    const token = parseCookieHeader(req.headers.cookie).get(cookieName);
+    if (!token) {
+      return null;
+    }
+
+    const separatorIndex = token.lastIndexOf('.');
+    if (separatorIndex <= 0) {
+      return null;
+    }
+
+    const encodedPayload = token.slice(0, separatorIndex);
+    const encodedSignature = token.slice(separatorIndex + 1);
+
+    try {
+      const expectedSignature = createSignature(encodedPayload, secret);
+      const actualSignature = decodeBase64Url(encodedSignature);
+
+      if (actualSignature.length !== expectedSignature.length) {
+        return null;
+      }
+
+      if (!timingSafeEqual(actualSignature, expectedSignature)) {
+        return null;
+      }
+
+      const payloadBuffer = decodeBase64Url(encodedPayload);
+      const payload = JSON.parse(payloadBuffer.toString('utf8'));
+      return payload && typeof payload === 'object' ? payload : null;
+    } catch {
+      return null;
+    }
+  }
   function createCookieAttributes(req, { expires = null } = {}) {
     const attributes = [
       'HttpOnly',
@@ -115,37 +145,18 @@ export function createSignedCookieManager({
     },
 
     read(req) {
-      const token = parseCookieHeader(req.headers.cookie).get(cookieName);
-      if (!token) {
-        return null;
-      }
-
-      const separatorIndex = token.lastIndexOf('.');
-      if (separatorIndex <= 0) {
-        return null;
-      }
-
-      const encodedPayload = token.slice(0, separatorIndex);
-      const encodedSignature = token.slice(separatorIndex + 1);
-
-      try {
-        const expectedSignature = createSignature(encodedPayload, secret);
-        const actualSignature = decodeBase64Url(encodedSignature);
-
-        if (actualSignature.length !== expectedSignature.length) {
-          return null;
-        }
-
-        if (!timingSafeEqual(actualSignature, expectedSignature)) {
-          return null;
+      if (req && typeof req === 'object') {
+        const cached = readCache.get(req);
+        if (cached !== undefined) {
+          return cached;
         }
 
-        const payloadBuffer = decodeBase64Url(encodedPayload);
-        const payload = JSON.parse(payloadBuffer.toString('utf8'));
-        return payload && typeof payload === 'object' ? payload : null;
-      } catch {
-        return null;
+        const result = readSignedCookie(req);
+        readCache.set(req, result);
+        return result;
       }
+
+      return readSignedCookie(req);
     },
   };
 }

package/src/server/config/env.js

@@ -1,5 +1,5 @@
 import { basename, isAbsolute, relative, resolve } from 'path';
-import { readFileSync } from 'node:fs';
+import { lstatSync, readdirSync, readFileSync } from 'node:fs';
 import { fileURLToPath } from 'url';
 
 import {
@@ -9,7 +9,7 @@ import {
   SUPPORTED_AUTH_STRATEGIES,
   createRandomAuthPassword,
   createRandomSessionSecret,
-} from '../auth/create-auth-service.js';
+} from '../auth/auth-constants.js';
 import { loadBuildInfo } from './build-info.js';
 import { isPerfLoggingEnabled } from './perf-logging.js';
 
@@ -222,11 +222,11 @@ export function parseVaultList(rawValue) {
 
 export function resolveConfiguredVaults(overrides = {}, env = process.env) {
   if (Array.isArray(overrides.vaults)) {
-    return overrides.vaults.map(({ id, dir, repoUrl }) => {
+    return overrides.vaults.map(({ id, dir, name, repoUrl }) => {
       if (!VAULT_ID_PATTERN.test(String(id ?? ''))) {
         throw new Error(`Invalid vault id "${id}". ${VAULT_ID_HINT}`);
       }
-      return { id, dir: resolve(dir), repoUrl: normalizeOptionalString(repoUrl) };
+      return { id, dir: resolve(dir), ...(name ? { name: normalizeOptionalString(name) } : {}), repoUrl: normalizeOptionalString(repoUrl) };
     });
   }
   // ponytail: explicit directory (CLI positional) wins over the operator list
@@ -235,13 +235,34 @@ export function resolveConfiguredVaults(overrides = {}, env = process.env) {
     return [{ id: basename(dir), dir }];
   }
   const rawList = normalizeOptionalString(env.COLLABMD_VAULTS);
-  if (!rawList) {
+  const discovery = normalizeOptionalString(env.COLLABMD_VAULT_DISCOVERY);
+  if (!rawList && !discovery) {
     const dir = resolveConfiguredVaultDir(overrides, env);
     return [{ id: basename(dir), dir }];
   }
-  const vaults = parseVaultList(rawList);
+  let vaults;
+  if (rawList) {
+    vaults = parseVaultList(rawList);
+  } else {
+    if (!['all', 'marked'].includes(discovery)) {
+      throw new Error('COLLABMD_VAULT_DISCOVERY must be "all" or "marked".');
+    }
+    const root = resolve(env.COLLABMD_VAULT_DIR || '.');
+    // ponytail: discover immediate real directories at startup; restart to pick up additions.
+    vaults = readdirSync(root, { withFileTypes: true })
+      .filter((entry) => entry.isDirectory() && !entry.name.startsWith('.')
+        && (discovery === 'all' || lstatSync(resolve(root, entry.name, '.collabmd'), { throwIfNoEntry: false })?.isDirectory()))
+      .sort((a, b) => a.name.localeCompare(b.name, 'en'))
+      .map((entry) => ({ id: entry.name, dir: resolve(root, entry.name) }));
+    if (vaults.length === 0) {
+      throw new Error('No vaults found. Check COLLABMD_VAULT_DIR and COLLABMD_VAULT_DISCOVERY.');
+    }
+  }
   const seenIds = new Set();
   for (const vault of vaults) {
+    if (!VAULT_ID_PATTERN.test(vault.id)) {
+      throw new Error(`Invalid vault id "${vault.id}". ${VAULT_ID_HINT}`);
+    }
     if (seenIds.has(vault.id)) {
       throw new Error(`Duplicate vault id "${vault.id}" in COLLABMD_VAULTS.`);
     }
@@ -262,6 +283,17 @@ export function mangleVaultIdForEnv(vaultId) {
   return String(vaultId ?? '').toUpperCase().replace(/[^A-Z0-9]/g, '_');
 }
 
+export function resolveVaultNames(vaults, env = process.env) {
+  return vaults.map((vault) => {
+    const suffix = mangleVaultIdForEnv(vault.id);
+    const name = normalizeOptionalString(env[`COLLABMD_VAULT_NAME_${suffix}`]);
+    if (name && vaults.filter((entry) => mangleVaultIdForEnv(entry.id) === suffix).length > 1) {
+      throw new Error(`Ambiguous vault name: multiple vaults share COLLABMD_VAULT_NAME_${suffix}.`);
+    }
+    return { ...vault, name: vault.name || name || vault.id };
+  });
+}
+
 // ponytail: explicit repoUrl wins, then COLLABMD_GIT_REPO_URL_<ID>, then the shared URL for the primary
 export function resolveVaultRepoUrls(vaultDefs = [], overrides = {}, env = process.env) {
   const globalRepoUrl = normalizeOptionalString(overrides.remote?.repoUrl ?? overrides.git?.remote?.repoUrl ?? env.COLLABMD_GIT_REPO_URL);
@@ -540,7 +572,7 @@ function resolvePublicDir(nodeEnv) {
 
 export function loadConfig(overrides = {}) {
   const nodeEnv = process.env.NODE_ENV || 'development';
-  const vaults = resolveVaultRepoUrls(resolveConfiguredVaults(overrides), overrides);
+  const vaults = resolveVaultNames(resolveVaultRepoUrls(resolveConfiguredVaults(overrides), overrides));
   // ponytail: vaultDir stays the primary vault; other vaults resolve through the registry
   const vaultDir = overrides.vaultDir || vaults[0].dir;
   const basePath = normalizeAppBasePath(process.env.BASE_PATH || '');
@@ -622,6 +654,7 @@ export function loadConfig(overrides = {}) {
     publicDir,
     vaultDir,
     vaults,
+    vaultDashboard: overrides.vaultDashboard ?? parseBooleanFlag(process.env.COLLABMD_VAULT_DASHBOARD),
     publicWsBaseUrl: process.env.PUBLIC_WS_BASE_URL || '',
     testWsRoomHydrateDelayMs: parsePositiveInt(process.env.TEST_WS_ROOM_HYDRATE_DELAY_MS, 0),
     wikiLinkAutoCreate: process.env.COLLABMD_WIKI_LINK_AUTO_CREATE !== 'false',

package/src/server/domain/backlink-index.js

@@ -21,16 +21,6 @@ import { mapWithConcurrency } from '../shared/async-utils.js';
 
 const BACKLINK_BUILD_CONCURRENCY = 8;
 
-function createDeferred() {
-  let resolve;
-  let reject;
-  const promise = new Promise((nextResolve, nextReject) => {
-    resolve = nextResolve;
-    reject = nextReject;
-  });
-  return { promise, reject, resolve };
-}
-
 export class BacklinkIndex {
   constructor({
     rebuildDelayMs = 150,
@@ -83,7 +73,7 @@ export class BacklinkIndex {
       this._latestRequestedWorkspaceState = workspaceState;
     }
     if (!this._scheduledBuildDeferred) {
-      this._scheduledBuildDeferred = createDeferred();
+      this._scheduledBuildDeferred = Promise.withResolvers();
     }
 
     if (this._scheduledBuildTimer) {

package/src/server/domain/bases/base-query-results.js

@@ -103,8 +103,12 @@ function createSummaryPayload(columns, rows, summaries, definition, snapshot, th
 
 function createCsv(rows, columns) {
   const escapeCell = (value) => {
-    const text = String(value ?? '');
-    if (/[,"\n]/u.test(text)) {
+    let text = toDisplayText(value);
+    // CSV quoting alone does not prevent spreadsheets from evaluating formulas.
+    if (typeof value !== 'number' && /^[\s\p{Cc}]*[=+@-]|^[\t\r\n]/u.test(text)) {
+      text = `'${text}`;
+    }
+    if (/[,"\r\n]/u.test(text)) {
       return `"${text.replace(/"/g, '""')}"`;
     }
     return text;
@@ -112,7 +116,7 @@ function createCsv(rows, columns) {
 
   const lines = [
     columns.map((column) => escapeCell(column.label)).join(','),
-    ...rows.map((row) => columns.map((column) => escapeCell(toDisplayText(row.rawCells[column.id]))).join(',')),
+    ...rows.map((row) => columns.map((column) => escapeCell(row.rawCells[column.id])).join(',')),
   ];
   return `${lines.join('\n')}\n`;
 }