@@ -43,6 +43,7 @@ test('remote Project capabilities do not dispatch Client-local actions', async (
       projects: [],
       projectCapabilities: {
         chooseClientDirectory: false,
+        chooseHostDirectory: false,
         selectNoProject: false,
         setLocalDefault: false,
         viewClientPath: false,
 
@@ -15,12 +15,14 @@ import {
 
 const LOCAL_CAPABILITIES = {
   chooseClientDirectory: true,
+  chooseHostDirectory: false,
   selectNoProject: true,
   setLocalDefault: true,
   viewClientPath: true,
 } as const;
 const REMOTE_CAPABILITIES = {
   chooseClientDirectory: false,
+  chooseHostDirectory: true,
   selectNoProject: false,
   setLocalDefault: false,
   viewClientPath: false,
@@ -215,6 +217,7 @@ test('does not silently replace a stale Project preference with another Project'
 
 test('does not expose Client directory actions for a remote Host', async () => {
   let pickerCalls = 0;
+  const directoryRequests: unknown[] = [];
   const service = createProjectManagementService({
     capabilities: REMOTE_CAPABILITIES,
     catalog: {
@@ -232,6 +235,17 @@ test('does not expose Client directory actions for a remote Host', async () => {
       archive: unexpected,
       restore: unexpected,
     },
+    directoryCatalog: {
+      listDirectoryRoots: async () => [{ id: 'home', label: '~' }],
+      listDirectories: async (rootId, segments) => {
+        directoryRequests.push({ rootId, segments });
+        return [{ name: 'project' }];
+      },
+      registerDirectory: async (rootId, segments) => {
+        directoryRequests.push({ rootId, segments, register: true });
+        return { id: 'added', name: 'Added', locations: [], available: true };
+      },
+    },
     chooseDirectory: async () => {
       pickerCalls += 1;
       return '/client/path';
@@ -257,6 +271,19 @@ test('does not expose Client directory actions for a remote Host', async () => {
     path: '/host/project',
   });
   assert.equal(pickerCalls, 0);
+  assert.deepEqual(await service.directoryRoots(), [{ id: 'home', label: '~' }]);
+  assert.deepEqual(
+    await service.listDirectory({ rootId: 'home', segments: ['work'] }),
+    [{ name: 'project' }],
+  );
+  assert.equal(
+    (await service.registerDirectory({ rootId: 'home', segments: ['work', 'project'] })).id,
+    'added',
+  );
+  assert.deepEqual(directoryRequests, [
+    { rootId: 'home', segments: ['work'] },
+    { rootId: 'home', segments: ['work', 'project'], register: true },
+  ]);
 });
 
 function managementCatalog(catalog: ProjectCatalog): ProjectManagementCatalog {
 
@@ -115,6 +115,12 @@ export function registerAppIpc(
   );
   targetIpc.handle('projects:add', (_event, options?: { select?: unknown }) =>
     deps.projectManagement.add({ select: options?.select !== false }));
+  handleReconnectableRead(targetIpc, 'projects:directoryRoots', () =>
+    deps.projectManagement.directoryRoots());
+  handleReconnectableRead(targetIpc, 'projects:listDirectory', (_event, input: unknown) =>
+    deps.projectManagement.listDirectory(input));
+  targetIpc.handle('projects:registerDirectory', (_event, input: unknown) =>
+    deps.projectManagement.registerDirectory(input));
   targetIpc.handle('projects:select', (_event, projectId: unknown) =>
     deps.projectManagement.select(projectId));
   targetIpc.handle('projects:relink', (_event, projectId: unknown) =>
 
@@ -1,6 +1,8 @@
 import { findProjectByIdentity, type ProjectRecord } from '@maka/core/project';
 import type {
   DesktopProjectCapabilities,
+  DesktopProjectDirectoryEntry,
+  DesktopProjectDirectoryRoot,
   DesktopProjectSnapshot,
 } from '../preload/bridge-contract.js';
 import type { CurrentProjectSelection } from './project-root-controller.js';
@@ -20,6 +22,9 @@ export interface ProjectManagementService {
     projectId: unknown,
   ): Promise<{ project: ProjectRecord | null; path: string }>;
   relink(projectId: unknown): Promise<DirectoryActionResult>;
+  directoryRoots(): Promise<readonly DesktopProjectDirectoryRoot[]>;
+  listDirectory(input: unknown): Promise<readonly DesktopProjectDirectoryEntry[]>;
+  registerDirectory(input: unknown): Promise<ProjectRecord>;
   /**
    * The on-disk path of a catalogued project, for surfaces that need to open
    * it. Returns null when the project is unknown, archived, or its folder is
@@ -42,8 +47,18 @@ export interface ProjectManagementCatalog {
   restore(projectId: string): Promise<ProjectRecord>;
 }
 
+export interface ProjectDirectoryCatalog {
+  listDirectoryRoots(): Promise<readonly DesktopProjectDirectoryRoot[]>;
+  listDirectories(
+    rootId: string,
+    segments: readonly string[],
+  ): Promise<readonly DesktopProjectDirectoryEntry[]>;
+  registerDirectory(rootId: string, segments: readonly string[]): Promise<ProjectRecord>;
+}
+
 export function createProjectManagementService(deps: {
   catalog: ProjectManagementCatalog;
+  directoryCatalog?: ProjectDirectoryCatalog;
   chooseDirectory(): Promise<string | undefined>;
   selection: {
     currentSelection(): Promise<CurrentProjectSelection>;
@@ -130,6 +145,26 @@ export function createProjectManagementService(deps: {
       return { ok: true, project };
     },
 
+    directoryRoots() {
+      return requireHostDirectoryActions(deps).listDirectoryRoots();
+    },
+
+    listDirectory(input) {
+      const directory = requireDirectoryInput(input);
+      return requireHostDirectoryActions(deps).listDirectories(
+        directory.rootId,
+        directory.segments,
+      );
+    },
+
+    registerDirectory(input) {
+      const directory = requireDirectoryInput(input);
+      return requireHostDirectoryActions(deps).registerDirectory(
+        directory.rootId,
+        directory.segments,
+      );
+    },
+
     async pathFor(projectId) {
       if (!deps.capabilities.viewClientPath) return null;
       const id = requireProjectId(projectId);
@@ -155,6 +190,36 @@ export function createProjectManagementService(deps: {
   };
 }
 
+function requireHostDirectoryActions(
+  deps: {
+    readonly capabilities: DesktopProjectCapabilities;
+    readonly directoryCatalog?: ProjectDirectoryCatalog;
+  },
+): ProjectDirectoryCatalog {
+  if (!deps.capabilities.chooseHostDirectory || !deps.directoryCatalog) {
+    throw new Error('This Runtime Host does not publish project directories');
+  }
+  return deps.directoryCatalog;
+}
+
+function requireDirectoryInput(value: unknown): {
+  readonly rootId: string;
+  readonly segments: readonly string[];
+} {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    throw new TypeError('Invalid project directory');
+  }
+  const input = value as { rootId?: unknown; segments?: unknown };
+  if (
+    typeof input.rootId !== 'string' ||
+    !Array.isArray(input.segments) ||
+    !input.segments.every((segment) => typeof segment === 'string')
+  ) {
+    throw new TypeError('Invalid project directory');
+  }
+  return { rootId: input.rootId, segments: input.segments };
+}
+
 function requireLocalDirectoryActions(
   deps: { readonly capabilities: DesktopProjectCapabilities },
 ): void {
 
@@ -751,6 +751,7 @@ function registerHostClientIpc(
   }));
   const targetProjectManagement = createProjectManagementService({
     catalog: targetProjectCatalog,
+    directoryCatalog: targetProjectCatalog,
     chooseDirectory: async () => {
       const result = await mainWindowController.showOpenDialog({
         title: "Add project",
@@ -762,12 +763,14 @@ function registerHostClientIpc(
     capabilities: target.kind === "local"
       ? {
           chooseClientDirectory: true,
+          chooseHostDirectory: false,
           selectNoProject: true,
           setLocalDefault: true,
           viewClientPath: true,
         }
       : {
           chooseClientDirectory: false,
+          chooseHostDirectory: true,
           selectNoProject: false,
           setLocalDefault: false,
           viewClientPath: false,
 
@@ -66,6 +66,9 @@ import {
   type ProjectCatalogMutateResult,
   type ProjectCatalogProject,
   type ProjectCatalogProjectDetails,
+  PROJECT_DIRECTORY_MAX_ENTRIES,
+  type ProjectDirectoryEntry,
+  type ProjectDirectoryRoot,
   type QueueRetractInput,
   type QueueRetractResult,
   type SessionCatalogFilter,
@@ -564,6 +567,52 @@ export class DesktopRuntimeHostClient {
     return this.#projectForMutation(result);
   }
 
+  async listProjectDirectoryRoots(): Promise<readonly ProjectDirectoryRoot[]> {
+    const result = await this.request("project.catalog.query", { kind: "directory_roots" });
+    if (result.kind !== "directory_roots") throw invalidProjection("Project directory roots");
+    return result.roots;
+  }
+
+  async listProjectDirectories(
+    rootId: string,
+    segments: readonly string[],
+  ): Promise<readonly ProjectDirectoryEntry[]> {
+    const entries: ProjectDirectoryEntry[] = [];
+    let result = await this.request(
+      "project.catalog.query",
+      { kind: "directory_list_start", rootId, segments },
+    );
+    const cursors = new Set<string>();
+    while (true) {
+      if (result.kind !== "directory_page") throw invalidProjection("Project directory");
+      if (result.rootId !== rootId || !sameSegments(result.segments, segments)) {
+        throw invalidProjection("Project directory identity");
+      }
+      if (entries.length + result.entries.length > PROJECT_DIRECTORY_MAX_ENTRIES) {
+        throw invalidProjection("Project directory has too many entries");
+      }
+      entries.push(...result.entries);
+      if (result.nextCursor === null) return entries;
+      if (cursors.has(result.nextCursor)) throw repeatedCursor("Project directory");
+      cursors.add(result.nextCursor);
+      result = await this.request("project.catalog.query", {
+        kind: "directory_list_continue",
+        rootId,
+        segments,
+        cursor: result.nextCursor,
+      });
+    }
+  }
+
+  async registerProjectDirectory(
+    rootId: string,
+    segments: readonly string[],
+  ): Promise<ProjectCatalogProject> {
+    return this.#projectForMutation(
+      await this.#mutateProject({ kind: "register_directory", rootId, segments }),
+    );
+  }
+
   async relinkProject(projectId: string, path: string): Promise<ProjectCatalogProject> {
     return this.#projectForMutation(
       await this.#mutateProject({ kind: "relink", projectId, path }),
@@ -1681,6 +1730,10 @@ function repeatedCursor(name: string): DesktopRuntimeHostClientError {
   );
 }
 
+function sameSegments(left: readonly string[], right: readonly string[]): boolean {
+  return left.length === right.length && left.every((segment, index) => segment === right[index]);
+}
+
 function unstableProjection(
   name: string,
   sessionId: string,
 
@@ -3,16 +3,22 @@ import type {
   ProjectCatalogProject,
   ProjectCatalogProjectDetails,
 } from "@maka/runtime-host/protocol";
-import type { ProjectManagementCatalog } from "./project-management-service.js";
+import type {
+  ProjectDirectoryCatalog,
+  ProjectManagementCatalog,
+} from "./project-management-service.js";
 import type { DesktopRuntimeHostClient } from "./runtime-host-client.js";
 
-export interface DesktopProjectCatalog extends ProjectManagementCatalog {}
+export interface DesktopProjectCatalog extends ProjectManagementCatalog, ProjectDirectoryCatalog {}
 
 type RuntimeHostProjectClient = Pick<
   DesktopRuntimeHostClient,
   | "archiveProject"
   | "listProjects"
+  | "listProjectDirectories"
+  | "listProjectDirectoryRoots"
   | "registerProject"
+  | "registerProjectDirectory"
   | "relinkProject"
   | "renameProject"
   | "restoreProject"
@@ -33,6 +39,16 @@ export function createRuntimeHostProjectCatalog(
       const target = resolveTarget();
       return projectRecord(target, await target.client.registerProject(path));
     },
+    listDirectoryRoots: async () => resolveTarget().client.listProjectDirectoryRoots(),
+    listDirectories: async (rootId, segments) =>
+      resolveTarget().client.listProjectDirectories(rootId, segments),
+    registerDirectory: async (rootId, segments) => {
+      const target = resolveTarget();
+      return projectRecord(
+        target,
+        await target.client.registerProjectDirectory(rootId, segments),
+      );
+    },
     relink: async (projectId, path) => {
       const target = resolveTarget();
       return projectRecord(target, await target.client.relinkProject(projectId, path));
 
@@ -328,11 +328,21 @@ export type DesktopRuntimeHostSshTerminalSnapshot =
 
 export interface DesktopProjectCapabilities {
   readonly chooseClientDirectory: boolean;
+  readonly chooseHostDirectory: boolean;
   readonly selectNoProject: boolean;
   readonly setLocalDefault: boolean;
   readonly viewClientPath: boolean;
 }
 
+export interface DesktopProjectDirectoryRoot {
+  readonly id: string;
+  readonly label: string;
+}
+
+export interface DesktopProjectDirectoryEntry {
+  readonly name: string;
+}
+
 export interface DesktopProjectSnapshot {
   readonly projects: readonly ProjectRecord[];
   readonly capabilities: DesktopProjectCapabilities;
@@ -643,6 +653,15 @@ export interface MakaBridge {
     add(host?: DesktopRuntimeHostRef): Promise<
       { ok: true; project: ProjectRecord; path: string } | { ok: false; reason: 'cancelled' }
     >;
+    getDirectoryRoots(host: DesktopRuntimeHostRef): Promise<readonly DesktopProjectDirectoryRoot[]>;
+    listDirectory(
+      input: { readonly rootId: string; readonly segments: readonly string[] },
+      host: DesktopRuntimeHostRef,
+    ): Promise<readonly DesktopProjectDirectoryEntry[]>;
+    registerDirectory(
+      input: { readonly rootId: string; readonly segments: readonly string[] },
+      host: DesktopRuntimeHostRef,
+    ): Promise<ProjectRecord>;
     select(
       projectId: string | null,
       host?: DesktopRuntimeHostRef,
 
@@ -1735,6 +1735,21 @@ const makaBridge = {
     > {
       return invokeSelectedRuntimeHost(host, 'projects:add');
     },
+    getDirectoryRoots(host: DesktopRuntimeHostRef) {
+      return invokeSelectedRuntimeHost(host, 'projects:directoryRoots');
+    },
+    listDirectory(
+      input: { readonly rootId: string; readonly segments: readonly string[] },
+      host: DesktopRuntimeHostRef,
+    ) {
+      return invokeSelectedRuntimeHost(host, 'projects:listDirectory', input);
+    },
+    registerDirectory(
+      input: { readonly rootId: string; readonly segments: readonly string[] },
+      host: DesktopRuntimeHostRef,
+    ) {
+      return invokeSelectedRuntimeHost(host, 'projects:registerDirectory', input);
+    },
     select(
       projectId: string | null,
       host?: DesktopRuntimeHostRef,