collabmd 0.1.20 → 0.1.23

package/src/server/infrastructure/git/responses.js

@@ -1,3 +1,8 @@
+import {
+  createEmptyWorkspaceChange as createSharedEmptyWorkspaceChange,
+  createWorkspaceChange as createSharedWorkspaceChange,
+} from '../../../domain/workspace-change.js';
+
 const STATUS_MAP = {
   A: { code: 'A', label: 'added', status: 'added' },
   C: { code: 'C', label: 'copied', status: 'copied' },
@@ -43,12 +48,7 @@ export function createEmptyBranchStatus() {
 }
 
 export function createEmptyWorkspaceChange() {
-  return {
-    changedPaths: [],
-    deletedPaths: [],
-    refreshExplorer: true,
-    renamedPaths: [],
-  };
+  return createSharedEmptyWorkspaceChange();
 }
 
 export function createEmptyStatusResponse() {
@@ -86,23 +86,89 @@ export function createDiffResponse({
   };
 }
 
+export function createHistoryResponse({
+  commits = [],
+  hasMore = false,
+  isGitRepo = true,
+  limit = 30,
+  offset = 0,
+} = {}) {
+  return {
+    commits,
+    hasMore,
+    isGitRepo,
+    limit,
+    offset,
+  };
+}
+
+export function createFileHistoryResponse({
+  commits = [],
+  hasMore = false,
+  isGitRepo = true,
+  limit = 30,
+  offset = 0,
+  path = null,
+} = {}) {
+  return {
+    commits,
+    hasMore,
+    isGitRepo,
+    limit,
+    offset,
+    path,
+  };
+}
+
+export function createCommitDiffResponse({
+  commit = null,
+  files = [],
+  isGitRepo = true,
+  metaOnly = false,
+  path = null,
+  summary = {
+    additions: 0,
+    deletions: 0,
+    filesChanged: 0,
+  },
+} = {}) {
+  return {
+    commit,
+    files,
+    isGitRepo,
+    metaOnly,
+    path,
+    source: 'commit',
+    summary,
+  };
+}
+
+export function createFileSnapshotResponse({
+  content = '',
+  fileKind = null,
+  hash = null,
+  isGitRepo = true,
+  path = null,
+} = {}) {
+  return {
+    content,
+    fileKind,
+    hash,
+    isGitRepo,
+    path,
+  };
+}
+
 export function createWorkspaceChange({
   changedPaths = [],
   deletedPaths = [],
   refreshExplorer = true,
   renamedPaths = [],
 } = {}) {
-  return {
-    changedPaths: Array.from(new Set((changedPaths ?? []).filter(Boolean))),
-    deletedPaths: Array.from(new Set((deletedPaths ?? []).filter(Boolean))),
-    refreshExplorer: Boolean(refreshExplorer),
-    renamedPaths: Array.from(new Map(
-      (renamedPaths ?? [])
-        .filter((entry) => entry?.oldPath && entry?.newPath && entry.oldPath !== entry.newPath)
-        .map((entry) => [`${entry.oldPath}:${entry.newPath}`, {
-          newPath: entry.newPath,
-          oldPath: entry.oldPath,
-        }]),
-    ).values()),
-  };
+  return createSharedWorkspaceChange({
+    changedPaths,
+    deletedPaths,
+    refreshExplorer,
+    renamedPaths,
+  });
 }

package/src/server/infrastructure/http/create-auth-api-handler.js

@@ -7,6 +7,14 @@ function applyAuthResponse(req, res, result) {
     res.setHeader('Set-Cookie', result.setCookie);
   }
 
+  if (result?.redirectTo) {
+    res.writeHead(result?.statusCode ?? 302, {
+      Location: result.redirectTo,
+    });
+    res.end();
+    return true;
+  }
+
   jsonResponse(req, res, result?.statusCode ?? 200, result?.body ?? { ok: true });
   return true;
 }
@@ -21,10 +29,30 @@ export function createAuthApiHandler({ authService }) {
       return applyAuthResponse(req, res, authService.getStatus(req));
     }
 
+    if (requestUrl.pathname === '/api/auth/oidc/login' && req.method === 'GET') {
+      try {
+        return applyAuthResponse(req, res, await authService.beginOidcLogin(req, requestUrl));
+      } catch (error) {
+        console.error('[api] Failed to start OIDC login:', error.message);
+        jsonResponse(req, res, 500, { error: 'Failed to start OIDC login' });
+        return true;
+      }
+    }
+
+    if (requestUrl.pathname === '/api/auth/oidc/callback' && req.method === 'GET') {
+      try {
+        return applyAuthResponse(req, res, await authService.completeOidcLogin(req, requestUrl));
+      } catch (error) {
+        console.error('[api] Failed to complete OIDC login:', error.message);
+        jsonResponse(req, res, 500, { error: 'Failed to complete OIDC login' });
+        return true;
+      }
+    }
+
     if (requestUrl.pathname === '/api/auth/session' && req.method === 'POST') {
       try {
         const body = await parseJsonBody(req);
-        return applyAuthResponse(req, res, authService.createSession(req, body));
+        return applyAuthResponse(req, res, await authService.createSession(req, body));
       } catch (error) {
         const statusCode = getRequestErrorStatusCode(error);
         if (statusCode) {
@@ -39,7 +67,7 @@ export function createAuthApiHandler({ authService }) {
     }
 
     if (requestUrl.pathname === '/api/auth/session' && req.method === 'DELETE') {
-      return applyAuthResponse(req, res, authService.clearSession(req));
+      return applyAuthResponse(req, res, await authService.clearSession(req));
     }
 
     jsonResponse(req, res, 404, { error: 'Auth endpoint not found' });

package/src/server/infrastructure/http/create-git-api-command-handler.js

@@ -1,7 +1,7 @@
 import { getRequestErrorStatusCode } from './http-errors.js';
 import { jsonResponse } from './http-response.js';
 import { parseJsonBody } from './request-body.js';
-import { createEmptyWorkspaceChange } from '../git/responses.js';
+import { createEmptyWorkspaceChange, hasWorkspaceMutation } from '../../../domain/workspace-change.js';
 
 async function parseRequiredBody(req, res, fieldName) {
   const body = await parseJsonBody(req);
@@ -29,19 +29,16 @@ function handleGitError(req, res, error, logMessage, fallbackMessage) {
   return true;
 }
 
-function hasWorkspaceMutation(workspaceChange = {}) {
-  return Boolean(
-    (workspaceChange.changedPaths?.length ?? 0) > 0
-    || (workspaceChange.deletedPaths?.length ?? 0) > 0
-    || (workspaceChange.renamedPaths?.length ?? 0) > 0,
-  );
+function readRequestId(req) {
+  const value = String(req.headers['x-collabmd-request-id'] || '').trim();
+  return value ? value.slice(0, 120) : null;
 }
 
 async function applyWorkspaceMutationEffects({
-  backlinkIndex,
+  action,
+  req,
   responsePayload,
-  roomRegistry,
-  vaultFileStore,
+  workspaceMutationCoordinator,
 }) {
   const workspaceChange = responsePayload?.workspaceChange ?? createEmptyWorkspaceChange();
   responsePayload.workspaceChange = workspaceChange;
@@ -50,18 +47,20 @@ async function applyWorkspaceMutationEffects({
     return responsePayload;
   }
 
-  await vaultFileStore?.reconcileSidecars?.(workspaceChange);
-  await vaultFileStore?.reconcileCollaborationSnapshots?.(workspaceChange);
-  await backlinkIndex?.build?.();
-  await roomRegistry?.reconcileWorkspaceChange?.(workspaceChange);
+  await workspaceMutationCoordinator?.apply?.({
+    action,
+    origin: 'git',
+    requestId: readRequestId(req),
+    sourceRef: responsePayload?.sourceRef ?? null,
+    workspaceChange,
+  });
   return responsePayload;
 }
 
 export function createGitApiCommandHandler({
-  backlinkIndex = null,
+  authService = null,
   gitService,
-  roomRegistry = null,
-  vaultFileStore = null,
+  workspaceMutationCoordinator = null,
 }) {
   return async function handleGitApiCommand(req, res, requestUrl) {
     if (requestUrl.pathname === '/api/git/stage' && req.method === 'POST') {
@@ -72,10 +71,12 @@ export function createGitApiCommandHandler({
         }
 
         jsonResponse(req, res, 200, await applyWorkspaceMutationEffects({
-          backlinkIndex,
-          responsePayload: await gitService.stageFile(body.path),
-          roomRegistry,
-          vaultFileStore,
+          action: 'stage',
+          req,
+          responsePayload: await workspaceMutationCoordinator.runManagedWorkspaceMutation(
+            () => gitService.stageFile(body.path),
+          ),
+          workspaceMutationCoordinator,
         }));
       } catch (error) {
         handleGitError(req, res, error, '[api] Failed to stage git file:', 'Failed to stage git file');
@@ -91,10 +92,12 @@ export function createGitApiCommandHandler({
         }
 
         jsonResponse(req, res, 200, await applyWorkspaceMutationEffects({
-          backlinkIndex,
-          responsePayload: await gitService.unstageFile(body.path),
-          roomRegistry,
-          vaultFileStore,
+          action: 'unstage',
+          req,
+          responsePayload: await workspaceMutationCoordinator.runManagedWorkspaceMutation(
+            () => gitService.unstageFile(body.path),
+          ),
+          workspaceMutationCoordinator,
         }));
       } catch (error) {
         handleGitError(req, res, error, '[api] Failed to unstage git file:', 'Failed to unstage git file');
@@ -110,12 +113,15 @@ export function createGitApiCommandHandler({
         }
 
         jsonResponse(req, res, 200, await applyWorkspaceMutationEffects({
-          backlinkIndex,
-          responsePayload: await gitService.commitStaged({
-            message: body.message,
-          }),
-          roomRegistry,
-          vaultFileStore,
+          action: 'commit',
+          req,
+          responsePayload: await workspaceMutationCoordinator.runManagedWorkspaceMutation(
+            () => gitService.commitStaged({
+              author: authService?.getAuthenticatedUser?.(req) ?? null,
+              message: body.message,
+            }),
+          ),
+          workspaceMutationCoordinator,
         }));
       } catch (error) {
         handleGitError(req, res, error, '[api] Failed to commit staged changes:', 'Failed to commit staged changes');
@@ -126,10 +132,12 @@ export function createGitApiCommandHandler({
     if (requestUrl.pathname === '/api/git/push' && req.method === 'POST') {
       try {
         jsonResponse(req, res, 200, await applyWorkspaceMutationEffects({
-          backlinkIndex,
-          responsePayload: await gitService.pushBranch(),
-          roomRegistry,
-          vaultFileStore,
+          action: 'push',
+          req,
+          responsePayload: await workspaceMutationCoordinator.runManagedWorkspaceMutation(
+            () => gitService.pushBranch(),
+          ),
+          workspaceMutationCoordinator,
         }));
       } catch (error) {
         handleGitError(req, res, error, '[api] Failed to push git branch:', 'Failed to push git branch');
@@ -140,10 +148,12 @@ export function createGitApiCommandHandler({
     if (requestUrl.pathname === '/api/git/pull' && req.method === 'POST') {
       try {
         jsonResponse(req, res, 200, await applyWorkspaceMutationEffects({
-          backlinkIndex,
-          responsePayload: await gitService.pullBranch(),
-          roomRegistry,
-          vaultFileStore,
+          action: 'pull',
+          req,
+          responsePayload: await workspaceMutationCoordinator.runManagedWorkspaceMutation(
+            () => gitService.pullBranch(),
+          ),
+          workspaceMutationCoordinator,
         }));
       } catch (error) {
         handleGitError(req, res, error, '[api] Failed to pull git branch:', 'Failed to pull git branch');
@@ -159,10 +169,12 @@ export function createGitApiCommandHandler({
         }
 
         jsonResponse(req, res, 200, await applyWorkspaceMutationEffects({
-          backlinkIndex,
-          responsePayload: await gitService.resetFileToHead(body.path),
-          roomRegistry,
-          vaultFileStore,
+          action: 'reset-file',
+          req,
+          responsePayload: await workspaceMutationCoordinator.runManagedWorkspaceMutation(
+            () => gitService.resetFileToHead(body.path),
+          ),
+          workspaceMutationCoordinator,
         }));
       } catch (error) {
         handleGitError(req, res, error, '[api] Failed to reset git file:', 'Failed to reset git file');

package/src/server/infrastructure/http/create-git-api-handler.js

@@ -3,17 +3,21 @@ import { createGitApiCommandHandler } from './create-git-api-command-handler.js'
 import { createGitApiQueryHandler } from './create-git-api-query-handler.js';
 
 export function createGitApiHandler({
+  authService = null,
   backlinkIndex = null,
   gitService = null,
   roomRegistry = null,
   vaultFileStore = null,
+  workspaceMutationCoordinator = null,
 }) {
   const handleGitApiQuery = createGitApiQueryHandler({ gitService });
   const handleGitApiCommand = createGitApiCommandHandler({
+    authService,
     backlinkIndex,
     gitService,
     roomRegistry,
     vaultFileStore,
+    workspaceMutationCoordinator,
   });
 
   return async function handleGitApi(req, res, requestUrl) {

package/src/server/infrastructure/http/create-git-api-query-handler.js

@@ -18,6 +18,16 @@ function isTruthyParam(value) {
   return value === '1' || value === 'true';
 }
 
+function readHistoryLimit(value) {
+  const parsed = Number.parseInt(String(value ?? ''), 10);
+  return Number.isFinite(parsed) ? parsed : 30;
+}
+
+function readHistoryOffset(value) {
+  const parsed = Number.parseInt(String(value ?? ''), 10);
+  return Number.isFinite(parsed) ? parsed : 0;
+}
+
 function handleGitError(req, res, error, message, fallback) {
   const statusCode = getRequestErrorStatusCode(error);
   if (statusCode) {
@@ -61,6 +71,57 @@ export function createGitApiQueryHandler({ gitService }) {
       return true;
     }
 
+    if (requestUrl.pathname === '/api/git/history' && req.method === 'GET') {
+      try {
+        jsonResponse(req, res, 200, await gitService.getHistory({
+          limit: readHistoryLimit(requestUrl.searchParams.get('limit')),
+          offset: readHistoryOffset(requestUrl.searchParams.get('offset')),
+        }));
+      } catch (error) {
+        handleGitError(req, res, error, '[api] Failed to read git history:', 'Failed to read git history');
+      }
+      return true;
+    }
+
+    if (requestUrl.pathname === '/api/git/file-history' && req.method === 'GET') {
+      try {
+        jsonResponse(req, res, 200, await gitService.getFileHistory({
+          limit: readHistoryLimit(requestUrl.searchParams.get('limit')),
+          offset: readHistoryOffset(requestUrl.searchParams.get('offset')),
+          path: requestUrl.searchParams.get('path'),
+        }));
+      } catch (error) {
+        handleGitError(req, res, error, '[api] Failed to read git file history:', 'Failed to read git file history');
+      }
+      return true;
+    }
+
+    if (requestUrl.pathname === '/api/git/commit' && req.method === 'GET') {
+      try {
+        jsonResponse(req, res, 200, await gitService.getCommit({
+          allowLargePatch: isTruthyParam(requestUrl.searchParams.get('allowLargePatch')),
+          hash: requestUrl.searchParams.get('hash'),
+          metaOnly: isTruthyParam(requestUrl.searchParams.get('metaOnly')),
+          path: requestUrl.searchParams.get('path'),
+        }));
+      } catch (error) {
+        handleGitError(req, res, error, '[api] Failed to read git commit:', 'Failed to read git commit');
+      }
+      return true;
+    }
+
+    if (requestUrl.pathname === '/api/git/file-snapshot' && req.method === 'GET') {
+      try {
+        jsonResponse(req, res, 200, await gitService.getFileSnapshot({
+          hash: requestUrl.searchParams.get('hash'),
+          path: requestUrl.searchParams.get('path'),
+        }));
+      } catch (error) {
+        handleGitError(req, res, error, '[api] Failed to read git file snapshot:', 'Failed to read git file snapshot');
+      }
+      return true;
+    }
+
     if (requestUrl.pathname === '/api/git/pull-backups' && req.method === 'GET') {
       try {
         jsonResponse(req, res, 200, {

package/src/server/infrastructure/http/create-request-handler.js

@@ -3,6 +3,7 @@ import { createGitApiHandler } from './create-git-api-handler.js';
 import { createEsmProxyHandler } from './create-esm-proxy-handler.js';
 import { createStaticHandler } from './create-static-handler.js';
 import { createVaultApiHandler } from './create-vault-api-handler.js';
+import { parseJsonBody } from './request-body.js';
 import {
   applyCorsHeaders,
   jsonResponse,
@@ -42,21 +43,27 @@ export function createRequestHandler(
   roomRegistry = null,
   plantUmlRenderer = null,
   gitService = null,
+  testControls = { wsRoomHydrateDelayMs: 0 },
+  workspaceMutationCoordinator = null,
+  fileSystemSyncService = null,
 ) {
   const handleEsmProxy = createEsmProxyHandler();
   const handleStaticRequest = createStaticHandler(config, authService);
   const handleAuthApi = createAuthApiHandler({ authService });
   const handleGitApi = createGitApiHandler({
+    authService,
     backlinkIndex,
     gitService,
     roomRegistry,
     vaultFileStore,
+    workspaceMutationCoordinator,
   });
   const handleVaultApi = createVaultApiHandler({
     backlinkIndex,
     plantUmlRenderer,
     roomRegistry,
     vaultFileStore,
+    workspaceMutationCoordinator,
   });
 
   return async function handleRequest(req, res) {
@@ -103,12 +110,27 @@ export function createRequestHandler(
     }
 
     if (config.nodeEnv === 'test' && requestUrl.pathname === '/api/test/reset-state' && req.method === 'POST') {
+      await fileSystemSyncService?.resetForExternalStateChange?.();
       await roomRegistry?.reset?.();
       await backlinkIndex?.build?.();
+      await workspaceMutationCoordinator?.initialize?.();
+      await fileSystemSyncService?.resetForExternalStateChange?.();
       jsonResponse(req, res, 200, { ok: true });
       return;
     }
 
+    if (config.nodeEnv === 'test' && requestUrl.pathname === '/api/test/hydrate-delay' && req.method === 'POST') {
+      const body = await parseJsonBody(req).catch(() => ({}));
+      testControls.wsRoomHydrateDelayMs = Math.max(0, Number(body?.delayMs) || 0);
+      await fileSystemSyncService?.resetForExternalStateChange?.();
+      await roomRegistry?.reset?.();
+      await backlinkIndex?.build?.();
+      await workspaceMutationCoordinator?.initialize?.();
+      await fileSystemSyncService?.resetForExternalStateChange?.();
+      jsonResponse(req, res, 200, { delayMs: testControls.wsRoomHydrateDelayMs, ok: true });
+      return;
+    }
+
     if (await handleAuthApi(req, res, requestUrl)) {
       return;
     }

package/src/server/infrastructure/http/create-vault-api-command-handler.js

@@ -3,6 +3,7 @@ import {
   isMermaidFilePath,
   isPlantUmlFilePath,
 } from '../../../domain/file-kind.js';
+import { createWorkspaceChange } from '../../../domain/workspace-change.js';
 import { createRequestError, getRequestErrorStatusCode } from './http-errors.js';
 import { jsonResponse } from './http-response.js';
 import { parseJsonBody, readBinaryRequestBody } from './request-body.js';
@@ -36,6 +37,11 @@ function selectWriteOperation(vaultFileStore, filePath, content) {
   return vaultFileStore.writeMarkdownFile(filePath, content);
 }
 
+function readRequestId(req) {
+  const value = String(req.headers['x-collabmd-request-id'] || '').trim();
+  return value ? value.slice(0, 120) : null;
+}
+
 function handleVaultError(req, res, error, logMessage, fallbackMessage) {
   const statusCode = getRequestErrorStatusCode(error);
   if (statusCode) {
@@ -49,9 +55,8 @@ function handleVaultError(req, res, error, logMessage, fallbackMessage) {
 }
 
 export function createVaultApiCommandHandler({
-  backlinkIndex,
-  roomRegistry = null,
   vaultFileStore,
+  workspaceMutationCoordinator = null,
 }) {
   return async function handleVaultApiCommand(req, res, requestUrl) {
     if (requestUrl.pathname === '/api/file' && req.method === 'PUT') {
@@ -68,6 +73,15 @@ export function createVaultApiCommandHandler({
           return true;
         }
 
+        await workspaceMutationCoordinator?.apply?.({
+          action: 'write-file',
+          origin: 'api',
+          requestId: readRequestId(req),
+          workspaceChange: createWorkspaceChange({
+            changedPaths: [body.path],
+          }),
+        });
+
         jsonResponse(req, res, 200, { ok: true });
       } catch (error) {
         handleVaultError(req, res, error, '[api] Failed to write file:', 'Failed to write file');
@@ -97,6 +111,15 @@ export function createVaultApiCommandHandler({
           return true;
         }
 
+        await workspaceMutationCoordinator?.apply?.({
+          action: 'upload-attachment',
+          origin: 'api',
+          requestId: readRequestId(req),
+          workspaceChange: createWorkspaceChange({
+            changedPaths: [result.path],
+          }),
+        });
+
         jsonResponse(req, res, 201, {
           markdown: result.markdownSnippet,
           ok: true,
@@ -121,8 +144,14 @@ export function createVaultApiCommandHandler({
           jsonResponse(req, res, 409, { error: result.error });
           return true;
         }
-
-        backlinkIndex?.onFileCreated(body.path, body.content || '');
+        await workspaceMutationCoordinator?.apply?.({
+          action: 'create-file',
+          origin: 'api',
+          requestId: readRequestId(req),
+          workspaceChange: createWorkspaceChange({
+            changedPaths: [body.path],
+          }),
+        });
         jsonResponse(req, res, 201, { ok: true, path: body.path });
       } catch (error) {
         handleVaultError(req, res, error, '[api] Failed to create file:', 'Failed to create file');
@@ -137,21 +166,22 @@ export function createVaultApiCommandHandler({
         return true;
       }
 
-      const activeRoom = roomRegistry?.get(filePath);
       try {
-        activeRoom?.markDeleted?.();
         const result = await vaultFileStore.deleteFile(filePath);
         if (!result.ok) {
-          activeRoom?.unmarkDeleted?.();
           jsonResponse(req, res, 400, { error: result.error });
           return true;
         }
-
-        roomRegistry?.delete?.(filePath);
-        backlinkIndex?.onFileDeleted(filePath);
+        await workspaceMutationCoordinator?.apply?.({
+          action: 'delete-file',
+          origin: 'api',
+          requestId: readRequestId(req),
+          workspaceChange: createWorkspaceChange({
+            deletedPaths: [filePath],
+          }),
+        });
         jsonResponse(req, res, 200, { ok: true });
       } catch (error) {
-        activeRoom?.unmarkDeleted?.();
         console.error('[api] Failed to delete file:', error.message);
         jsonResponse(req, res, 500, { error: 'Failed to delete file' });
       }
@@ -171,9 +201,14 @@ export function createVaultApiCommandHandler({
           jsonResponse(req, res, 400, { error: result.error });
           return true;
         }
-
-        roomRegistry?.rename(body.oldPath, body.newPath);
-        backlinkIndex?.onFileRenamed(body.oldPath, body.newPath);
+        await workspaceMutationCoordinator?.apply?.({
+          action: 'rename-file',
+          origin: 'api',
+          requestId: readRequestId(req),
+          workspaceChange: createWorkspaceChange({
+            renamedPaths: [{ oldPath: body.oldPath, newPath: body.newPath }],
+          }),
+        });
         jsonResponse(req, res, 200, { ok: true, path: body.newPath });
       } catch (error) {
         handleVaultError(req, res, error, '[api] Failed to rename file:', 'Failed to rename file');
@@ -195,6 +230,15 @@ export function createVaultApiCommandHandler({
           return true;
         }
 
+        await workspaceMutationCoordinator?.apply?.({
+          action: 'create-directory',
+          origin: 'api',
+          requestId: readRequestId(req),
+          workspaceChange: createWorkspaceChange({
+            changedPaths: [body.path],
+          }),
+        });
+
         jsonResponse(req, res, 201, { ok: true });
       } catch (error) {
         handleVaultError(req, res, error, '[api] Failed to create directory:', 'Failed to create directory');

package/src/server/infrastructure/http/create-vault-api-handler.js

@@ -7,15 +7,18 @@ export function createVaultApiHandler({
   plantUmlRenderer = null,
   roomRegistry = null,
   vaultFileStore,
+  workspaceMutationCoordinator = null,
 }) {
   const handleVaultApiQuery = createVaultApiQueryHandler({
     backlinkIndex,
     vaultFileStore,
+    workspaceMutationCoordinator,
   });
   const handleVaultApiCommand = createVaultApiCommandHandler({
     backlinkIndex,
     roomRegistry,
     vaultFileStore,
+    workspaceMutationCoordinator,
   });
   const handlePlantUmlApi = createPlantUmlApiHandler({
     plantUmlRenderer,

package/src/server/infrastructure/http/create-vault-api-query-handler.js

@@ -59,11 +59,13 @@ function selectReadOperation(vaultFileStore, filePath) {
 export function createVaultApiQueryHandler({
   backlinkIndex,
   vaultFileStore,
+  workspaceMutationCoordinator = null,
 }) {
   return async function handleVaultApiQuery(req, res, requestUrl) {
     if (requestUrl.pathname === '/api/files' && req.method === 'GET') {
       try {
-        jsonResponse(req, res, 200, { tree: await vaultFileStore.tree() });
+        const tree = workspaceMutationCoordinator?.getWorkspaceTree?.() ?? await vaultFileStore.tree();
+        jsonResponse(req, res, 200, { tree });
       } catch (error) {
         console.error('[api] Failed to read file tree:', error.message);
         jsonResponse(req, res, 500, { error: 'Failed to read file tree' });