@cryptiklemur/lattice 0.0.0 → 1.2.0

package/client/src/stores/sidebar.ts

@@ -26,6 +26,8 @@ export interface SidebarState {
   projectDropdownOpen: boolean;
   drawerOpen: boolean;
   nodeSettingsOpen: boolean;
+  addProjectOpen: boolean;
+  confirmRemoveSlug: string | null;
 }
 
 var SETTINGS_SECTIONS: SettingsSection[] = ["appearance", "claude", "environment", "mcp", "skills", "nodes"];
@@ -70,6 +72,8 @@ var sidebarStore = new Store<SidebarState>({
   projectDropdownOpen: false,
   drawerOpen: false,
   nodeSettingsOpen: false,
+  addProjectOpen: false,
+  confirmRemoveSlug: null,
 });
 
 function pushUrl(projectSlug: string | null, sessionId: string | null): void {
@@ -334,3 +338,27 @@ export function closeNodeSettings(): void {
     return { ...state, nodeSettingsOpen: false };
   });
 }
+
+export function openAddProject(): void {
+  sidebarStore.setState(function (state) {
+    return { ...state, addProjectOpen: true };
+  });
+}
+
+export function closeAddProject(): void {
+  sidebarStore.setState(function (state) {
+    return { ...state, addProjectOpen: false };
+  });
+}
+
+export function openConfirmRemove(slug: string): void {
+  sidebarStore.setState(function (state) {
+    return { ...state, confirmRemoveSlug: slug };
+  });
+}
+
+export function closeConfirmRemove(): void {
+  sidebarStore.setState(function (state) {
+    return { ...state, confirmRemoveSlug: null };
+  });
+}

package/client/vite.config.ts

@@ -1,20 +1,20 @@
-import { defineConfig } from "vite";
-import react from "@vitejs/plugin-react";
-import tailwindcss from "@tailwindcss/vite";
-
-export default defineConfig({
-  plugins: [tailwindcss(), react()],
-  server: {
-    host: "0.0.0.0",
-    open: true,
-    proxy: {
-      "/ws": {
-        target: "ws://localhost:7654",
-        ws: true,
-      },
-      "/api": {
-        target: "http://localhost:7654",
-      },
-    },
-  },
-});
+import { defineConfig } from "vite";
+import react from "@vitejs/plugin-react";
+import tailwindcss from "@tailwindcss/vite";
+
+export default defineConfig({
+  plugins: [tailwindcss(), react()],
+  server: {
+    host: "0.0.0.0",
+    open: true,
+    proxy: {
+      "/ws": {
+        target: "ws://localhost:7654",
+        ws: true,
+      },
+      "/api": {
+        target: "http://localhost:7654",
+      },
+    },
+  },
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cryptiklemur/lattice",
-  "version": "0.0.0",
+  "version": "1.2.0",
   "description": "Multi-machine agentic dashboard for Claude Code. Monitor sessions, manage MCP servers and skills, orchestrate across mesh-networked nodes.",
   "license": "MIT",
   "author": "Aaron Scherer <me@aaronscherer.me>",

package/server/src/daemon.ts

@@ -24,6 +24,7 @@ import "./handlers/loop";
 import "./handlers/scheduler";
 import "./handlers/notes";
 import "./handlers/skills";
+import "./handlers/memory";
 import { startScheduler } from "./features/scheduler";
 import { loadNotes } from "./features/sticky-notes";
 import { cleanupClientTerminals } from "./handlers/terminal";

package/server/src/handlers/chat.ts

@@ -1,194 +1,194 @@
-import type { ChatSendMessage, ChatPermissionResponseMessage, ChatSetPermissionModeMessage, ClientMessage } from "@lattice/shared";
-import { registerHandler } from "../ws/router";
-import { sendTo } from "../ws/broadcast";
-import { getProjectBySlug } from "../project/registry";
-import { loadConfig } from "../config";
-import { startChatStream, getPendingPermission, deletePendingPermission, addAutoApprovedTool, setSessionPermissionOverride, getActiveStream, buildPermissionRule } from "../project/sdk-bridge";
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-
-function formatSdkRule(rule: { toolName: string; ruleContent?: string }): string {
-  if (!rule.ruleContent) return rule.toolName;
-  if (rule.toolName === "Bash") {
-    var firstWord = rule.ruleContent.split(/\s+/)[0].replace(/:.*$/, "");
-    if (firstWord === "curl" || firstWord === "wget") {
-      var urlMatch = rule.ruleContent.match(/https?:\/\/[^\s"']+/);
-      if (urlMatch) {
-        try {
-          var parsed = new URL(urlMatch[0]);
-          return rule.toolName + "(" + firstWord + ":" + parsed.hostname + ")";
-        } catch {}
-      }
-    }
-    return rule.toolName + "(" + firstWord + ":*)";
-  }
-  return rule.toolName + "(" + rule.ruleContent + ")";
-}
-
-function addProjectAllowRules(projectPath: string, suggestions: Array<{ type: string; rules?: Array<{ toolName: string; ruleContent?: string }>; directories?: string[]; behavior?: string }> | undefined, fallbackToolName: string, fallbackInput: Record<string, unknown>): void {
-  var claudeDir = join(projectPath, ".claude");
-  var settingsPath = join(claudeDir, "settings.json");
-
-  var settings: Record<string, unknown> = {};
-  if (existsSync(settingsPath)) {
-    try {
-      settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
-    } catch {
-      settings = {};
-    }
-  }
-
-  if (!settings.permissions) {
-    settings.permissions = {};
-  }
-  var permissions = settings.permissions as Record<string, unknown>;
-  if (!Array.isArray(permissions.allow)) {
-    permissions.allow = [];
-  }
-  if (!Array.isArray(permissions.additionalDirectories)) {
-    permissions.additionalDirectories = [];
-  }
-  var allowList = permissions.allow as string[];
-  var additionalDirs = permissions.additionalDirectories as string[];
-
-  if (suggestions && suggestions.length > 0) {
-    for (var si = 0; si < suggestions.length; si++) {
-      var suggestion = suggestions[si];
-      if (suggestion.type === "addRules" && suggestion.behavior === "allow" && suggestion.rules) {
-        for (var ri = 0; ri < suggestion.rules.length; ri++) {
-          var rule = formatSdkRule(suggestion.rules[ri]);
-          if (!allowList.includes(rule)) {
-            allowList.push(rule);
-          }
-          if (suggestion.rules[ri].ruleContent) {
-            var ruleDir = suggestion.rules[ri].ruleContent!.replace(/\/\*\*$/, "").replace(/^\//, "");
-            if (ruleDir.startsWith("/") && !additionalDirs.includes(ruleDir)) {
-              additionalDirs.push(ruleDir);
-            }
-          }
-        }
-      }
-      if (suggestion.type === "addDirectories" && suggestion.directories) {
-        for (var di = 0; di < suggestion.directories.length; di++) {
-          if (!additionalDirs.includes(suggestion.directories[di])) {
-            additionalDirs.push(suggestion.directories[di]);
-          }
-        }
-      }
-    }
-  } else {
-    var fallbackRule = buildPermissionRule(fallbackToolName, fallbackInput);
-    if (!allowList.includes(fallbackRule)) {
-      allowList.push(fallbackRule);
-    }
-  }
-
-  if (!existsSync(claudeDir)) {
-    mkdirSync(claudeDir, { recursive: true });
-  }
-  writeFileSync(settingsPath, JSON.stringify(settings, null, 2), "utf-8");
-}
-
-var activeSessionByClient = new Map<string, { projectSlug: string; sessionId: string }>();
-
-export function setActiveSession(clientId: string, projectSlug: string, sessionId: string): void {
-  activeSessionByClient.set(clientId, { projectSlug, sessionId });
-}
-
-export function clearActiveSession(clientId: string): void {
-  activeSessionByClient.delete(clientId);
-}
-
-export function getActiveSession(clientId: string): { projectSlug: string; sessionId: string } | undefined {
-  return activeSessionByClient.get(clientId);
-}
-
-registerHandler("chat", function (clientId: string, message: ClientMessage) {
-  if (message.type === "chat:send") {
-    var sendMsg = message as ChatSendMessage;
-    var active = activeSessionByClient.get(clientId);
-
-    if (!active) {
-      sendTo(clientId, { type: "chat:error", message: "No active session. Activate a session first." });
-      return;
-    }
-
-    var project = getProjectBySlug(active.projectSlug);
-    if (!project) {
-      sendTo(clientId, { type: "chat:error", message: `Project not found: ${active.projectSlug}` });
-      return;
-    }
-
-    var config = loadConfig();
-    var env = Object.assign({}, config.globalEnv, project.env);
-
-    startChatStream({
-      projectSlug: active.projectSlug,
-      sessionId: active.sessionId,
-      text: sendMsg.text,
-      clientId,
-      cwd: project.path,
-      env: Object.keys(env).length > 0 ? env : undefined,
-      model: sendMsg.model,
-      effort: sendMsg.effort as "low" | "medium" | "high" | "max" | undefined,
-    });
-
-    return;
-  }
-
-  if (message.type === "chat:cancel") {
-    sendTo(clientId, { type: "chat:error", message: "Cancel not yet implemented." });
-    return;
-  }
-
-  if (message.type === "chat:permission_response") {
-    var permMsg = message as ChatPermissionResponseMessage;
-    var pending = getPendingPermission(permMsg.requestId);
-    if (!pending) {
-      return;
-    }
-
-    var active = activeSessionByClient.get(clientId);
-
-    if (permMsg.allow) {
-      if (permMsg.alwaysAllow && permMsg.alwaysAllowScope === "session" && active) {
-        addAutoApprovedTool(active.sessionId, pending.toolName);
-      }
-
-      if (permMsg.alwaysAllow && permMsg.alwaysAllowScope === "project" && active) {
-        var project = getProjectBySlug(active.projectSlug);
-        if (project) {
-          addProjectAllowRules(project.path, pending.suggestions as any, pending.toolName, pending.input);
-        }
-        pending.resolve({ behavior: "allow", updatedInput: pending.input, toolUseID: pending.toolUseID });
-      } else {
-        pending.resolve({ behavior: "allow", updatedInput: pending.input, toolUseID: pending.toolUseID });
-      }
-
-      var resolvedStatus = permMsg.alwaysAllow ? "always_allowed" : "allowed";
-      sendTo(clientId, { type: "chat:permission_resolved", requestId: permMsg.requestId, status: resolvedStatus });
-    } else {
-      pending.resolve({ behavior: "deny", message: "User denied this operation.", toolUseID: pending.toolUseID });
-      sendTo(clientId, { type: "chat:permission_resolved", requestId: permMsg.requestId, status: "denied" });
-    }
-
-    deletePendingPermission(permMsg.requestId);
-    return;
-  }
-
-  if (message.type === "chat:set_permission_mode") {
-    var modeMsg = message as ChatSetPermissionModeMessage;
-    var activeSession = activeSessionByClient.get(clientId);
-    if (!activeSession) {
-      return;
-    }
-
-    var stream = getActiveStream(activeSession.sessionId);
-    if (stream) {
-      void stream.setPermissionMode(modeMsg.mode);
-    } else {
-      setSessionPermissionOverride(activeSession.sessionId, modeMsg.mode);
-    }
-    return;
-  }
-});
+import type { ChatSendMessage, ChatPermissionResponseMessage, ChatSetPermissionModeMessage, ClientMessage } from "@lattice/shared";
+import { registerHandler } from "../ws/router";
+import { sendTo } from "../ws/broadcast";
+import { getProjectBySlug } from "../project/registry";
+import { loadConfig } from "../config";
+import { startChatStream, getPendingPermission, deletePendingPermission, addAutoApprovedTool, setSessionPermissionOverride, getActiveStream, buildPermissionRule } from "../project/sdk-bridge";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+function formatSdkRule(rule: { toolName: string; ruleContent?: string }): string {
+  if (!rule.ruleContent) return rule.toolName;
+  if (rule.toolName === "Bash") {
+    var firstWord = rule.ruleContent.split(/\s+/)[0].replace(/:.*$/, "");
+    if (firstWord === "curl" || firstWord === "wget") {
+      var urlMatch = rule.ruleContent.match(/https?:\/\/[^\s"']+/);
+      if (urlMatch) {
+        try {
+          var parsed = new URL(urlMatch[0]);
+          return rule.toolName + "(" + firstWord + ":" + parsed.hostname + ")";
+        } catch {}
+      }
+    }
+    return rule.toolName + "(" + firstWord + ":*)";
+  }
+  return rule.toolName + "(" + rule.ruleContent + ")";
+}
+
+function addProjectAllowRules(projectPath: string, suggestions: Array<{ type: string; rules?: Array<{ toolName: string; ruleContent?: string }>; directories?: string[]; behavior?: string }> | undefined, fallbackToolName: string, fallbackInput: Record<string, unknown>): void {
+  var claudeDir = join(projectPath, ".claude");
+  var settingsPath = join(claudeDir, "settings.json");
+
+  var settings: Record<string, unknown> = {};
+  if (existsSync(settingsPath)) {
+    try {
+      settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
+    } catch {
+      settings = {};
+    }
+  }
+
+  if (!settings.permissions) {
+    settings.permissions = {};
+  }
+  var permissions = settings.permissions as Record<string, unknown>;
+  if (!Array.isArray(permissions.allow)) {
+    permissions.allow = [];
+  }
+  if (!Array.isArray(permissions.additionalDirectories)) {
+    permissions.additionalDirectories = [];
+  }
+  var allowList = permissions.allow as string[];
+  var additionalDirs = permissions.additionalDirectories as string[];
+
+  if (suggestions && suggestions.length > 0) {
+    for (var si = 0; si < suggestions.length; si++) {
+      var suggestion = suggestions[si];
+      if (suggestion.type === "addRules" && suggestion.behavior === "allow" && suggestion.rules) {
+        for (var ri = 0; ri < suggestion.rules.length; ri++) {
+          var rule = formatSdkRule(suggestion.rules[ri]);
+          if (!allowList.includes(rule)) {
+            allowList.push(rule);
+          }
+          if (suggestion.rules[ri].ruleContent) {
+            var ruleDir = suggestion.rules[ri].ruleContent!.replace(/\/\*\*$/, "").replace(/^\//, "");
+            if (ruleDir.startsWith("/") && !additionalDirs.includes(ruleDir)) {
+              additionalDirs.push(ruleDir);
+            }
+          }
+        }
+      }
+      if (suggestion.type === "addDirectories" && suggestion.directories) {
+        for (var di = 0; di < suggestion.directories.length; di++) {
+          if (!additionalDirs.includes(suggestion.directories[di])) {
+            additionalDirs.push(suggestion.directories[di]);
+          }
+        }
+      }
+    }
+  } else {
+    var fallbackRule = buildPermissionRule(fallbackToolName, fallbackInput);
+    if (!allowList.includes(fallbackRule)) {
+      allowList.push(fallbackRule);
+    }
+  }
+
+  if (!existsSync(claudeDir)) {
+    mkdirSync(claudeDir, { recursive: true });
+  }
+  writeFileSync(settingsPath, JSON.stringify(settings, null, 2), "utf-8");
+}
+
+var activeSessionByClient = new Map<string, { projectSlug: string; sessionId: string }>();
+
+export function setActiveSession(clientId: string, projectSlug: string, sessionId: string): void {
+  activeSessionByClient.set(clientId, { projectSlug, sessionId });
+}
+
+export function clearActiveSession(clientId: string): void {
+  activeSessionByClient.delete(clientId);
+}
+
+export function getActiveSession(clientId: string): { projectSlug: string; sessionId: string } | undefined {
+  return activeSessionByClient.get(clientId);
+}
+
+registerHandler("chat", function (clientId: string, message: ClientMessage) {
+  if (message.type === "chat:send") {
+    var sendMsg = message as ChatSendMessage;
+    var active = activeSessionByClient.get(clientId);
+
+    if (!active) {
+      sendTo(clientId, { type: "chat:error", message: "No active session. Activate a session first." });
+      return;
+    }
+
+    var project = getProjectBySlug(active.projectSlug);
+    if (!project) {
+      sendTo(clientId, { type: "chat:error", message: `Project not found: ${active.projectSlug}` });
+      return;
+    }
+
+    var config = loadConfig();
+    var env = Object.assign({}, config.globalEnv, project.env);
+
+    startChatStream({
+      projectSlug: active.projectSlug,
+      sessionId: active.sessionId,
+      text: sendMsg.text,
+      clientId,
+      cwd: project.path,
+      env: Object.keys(env).length > 0 ? env : undefined,
+      model: sendMsg.model,
+      effort: sendMsg.effort as "low" | "medium" | "high" | "max" | undefined,
+    });
+
+    return;
+  }
+
+  if (message.type === "chat:cancel") {
+    sendTo(clientId, { type: "chat:error", message: "Cancel not yet implemented." });
+    return;
+  }
+
+  if (message.type === "chat:permission_response") {
+    var permMsg = message as ChatPermissionResponseMessage;
+    var pending = getPendingPermission(permMsg.requestId);
+    if (!pending) {
+      return;
+    }
+
+    var active = activeSessionByClient.get(clientId);
+
+    if (permMsg.allow) {
+      if (permMsg.alwaysAllow && permMsg.alwaysAllowScope === "session" && active) {
+        addAutoApprovedTool(active.sessionId, pending.toolName);
+      }
+
+      if (permMsg.alwaysAllow && permMsg.alwaysAllowScope === "project" && active) {
+        var project = getProjectBySlug(active.projectSlug);
+        if (project) {
+          addProjectAllowRules(project.path, pending.suggestions as any, pending.toolName, pending.input);
+        }
+        pending.resolve({ behavior: "allow", updatedInput: pending.input, toolUseID: pending.toolUseID });
+      } else {
+        pending.resolve({ behavior: "allow", updatedInput: pending.input, toolUseID: pending.toolUseID });
+      }
+
+      var resolvedStatus = permMsg.alwaysAllow ? "always_allowed" : "allowed";
+      sendTo(clientId, { type: "chat:permission_resolved", requestId: permMsg.requestId, status: resolvedStatus });
+    } else {
+      pending.resolve({ behavior: "deny", message: "User denied this operation.", toolUseID: pending.toolUseID });
+      sendTo(clientId, { type: "chat:permission_resolved", requestId: permMsg.requestId, status: "denied" });
+    }
+
+    deletePendingPermission(permMsg.requestId);
+    return;
+  }
+
+  if (message.type === "chat:set_permission_mode") {
+    var modeMsg = message as ChatSetPermissionModeMessage;
+    var activeSession = activeSessionByClient.get(clientId);
+    if (!activeSession) {
+      return;
+    }
+
+    var stream = getActiveStream(activeSession.sessionId);
+    if (stream) {
+      void stream.setPermissionMode(modeMsg.mode);
+    } else {
+      setSessionPermissionOverride(activeSession.sessionId, modeMsg.mode);
+    }
+    return;
+  }
+});

package/server/src/handlers/fs.ts

@@ -3,6 +3,10 @@ import { registerHandler } from "../ws/router";
 import { sendTo, broadcast } from "../ws/broadcast";
 import { getProjectBySlug } from "../project/registry";
 import { listDirectory, readFile, writeFile } from "../project/file-browser";
+import { readdirSync, existsSync, readFileSync, statSync } from "node:fs";
+import { join, basename } from "node:path";
+import { homedir } from "node:os";
+import { loadConfig } from "../config";
 
 var activeProjectByClient = new Map<string, string>();
 
@@ -82,3 +86,158 @@ registerHandler("fs", function (clientId: string, message: ClientMessage) {
     return;
   }
 });
+
+function resolvePath(path: string): string {
+  if (!path || path === "~") return homedir();
+  if (path.startsWith("~/")) return join(homedir(), path.slice(2));
+  return path;
+}
+
+function detectProjectName(dirPath: string): string | null {
+  try {
+    var pkgPath = join(dirPath, "package.json");
+    if (existsSync(pkgPath)) {
+      var pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+      if (pkg.name) return pkg.name;
+    }
+  } catch {}
+
+  try {
+    var cargoPath = join(dirPath, "Cargo.toml");
+    if (existsSync(cargoPath)) {
+      var cargo = readFileSync(cargoPath, "utf-8");
+      var cargoMatch = cargo.match(/\[package\][\s\S]*?name\s*=\s*"([^"]+)"/);
+      if (cargoMatch) return cargoMatch[1];
+    }
+  } catch {}
+
+  try {
+    var composerPath = join(dirPath, "composer.json");
+    if (existsSync(composerPath)) {
+      var composer = JSON.parse(readFileSync(composerPath, "utf-8"));
+      if (composer.name) return composer.name;
+    }
+  } catch {}
+
+  try {
+    var pyprojectPath = join(dirPath, "pyproject.toml");
+    if (existsSync(pyprojectPath)) {
+      var pyproject = readFileSync(pyprojectPath, "utf-8");
+      var pyMatch = pyproject.match(/\[project\][\s\S]*?name\s*=\s*"([^"]+)"/);
+      if (pyMatch) return pyMatch[1];
+    }
+  } catch {}
+
+  try {
+    var goModPath = join(dirPath, "go.mod");
+    if (existsSync(goModPath)) {
+      var goMod = readFileSync(goModPath, "utf-8");
+      var goMatch = goMod.match(/^module\s+(\S+)/m);
+      if (goMatch) {
+        var parts = goMatch[1].split("/");
+        return parts[parts.length - 1];
+      }
+    }
+  } catch {}
+
+  try {
+    var entries = readdirSync(dirPath);
+    for (var i = 0; i < entries.length; i++) {
+      if (entries[i].endsWith(".sln") || entries[i].endsWith(".csproj")) {
+        return entries[i].replace(/\.[^.]+$/, "");
+      }
+    }
+  } catch {}
+
+  return null;
+}
+
+registerHandler("browse", function (clientId: string, message: ClientMessage) {
+  if (message.type === "browse:list") {
+    var browseMsg = message as { type: "browse:list"; path: string };
+    var resolvedPath = resolvePath(browseMsg.path);
+    var home = homedir();
+
+    if (!existsSync(resolvedPath)) {
+      sendTo(clientId, { type: "browse:list_result", path: resolvedPath, homedir: home, entries: [] });
+      return;
+    }
+
+    try {
+      var stat = statSync(resolvedPath);
+      if (!stat.isDirectory()) {
+        sendTo(clientId, { type: "browse:list_result", path: resolvedPath, homedir: home, entries: [] });
+        return;
+      }
+    } catch {
+      sendTo(clientId, { type: "browse:list_result", path: resolvedPath, homedir: home, entries: [] });
+      return;
+    }
+
+    try {
+      var dirEntries = readdirSync(resolvedPath, { withFileTypes: true });
+      var results: Array<{ name: string; path: string; hasClaudeMd: boolean; projectName: string | null }> = [];
+
+      for (var i = 0; i < dirEntries.length; i++) {
+        var entry = dirEntries[i];
+        if (!entry.isDirectory()) continue;
+
+        var entryPath = join(resolvedPath, entry.name);
+        var hasClaudeMd = existsSync(join(entryPath, "CLAUDE.md"));
+        var projectName = detectProjectName(entryPath);
+
+        results.push({
+          name: entry.name,
+          path: entryPath,
+          hasClaudeMd: hasClaudeMd,
+          projectName: projectName,
+        });
+      }
+
+      results.sort(function (a, b) { return a.name.localeCompare(b.name); });
+
+      sendTo(clientId, { type: "browse:list_result", path: resolvedPath, homedir: home, entries: results });
+    } catch {
+      sendTo(clientId, { type: "browse:list_result", path: resolvedPath, homedir: home, entries: [] });
+    }
+    return;
+  }
+
+  if (message.type === "browse:suggestions") {
+    var claudeProjectsDir = join(homedir(), ".claude", "projects");
+    var config = loadConfig();
+    var existingPaths = new Set(config.projects.map(function (p) { return p.path; }));
+    var suggestions: Array<{ path: string; name: string; hasClaudeMd: boolean }> = [];
+
+    if (existsSync(claudeProjectsDir)) {
+      try {
+        var hashDirs = readdirSync(claudeProjectsDir);
+        for (var i = 0; i < hashDirs.length; i++) {
+          var hashDir = hashDirs[i];
+          var candidatePath = "/" + hashDir.slice(1).replace(/-/g, "/");
+
+          if (!existsSync(candidatePath)) continue;
+          if (existingPaths.has(candidatePath)) continue;
+
+          try {
+            var stat = statSync(candidatePath);
+            if (!stat.isDirectory()) continue;
+          } catch { continue; }
+
+          var hasClaudeMd = existsSync(join(candidatePath, "CLAUDE.md"));
+          var name = candidatePath.split("/").pop() || hashDir;
+
+          suggestions.push({
+            path: candidatePath,
+            name: name,
+            hasClaudeMd: hasClaudeMd,
+          });
+        }
+      } catch {}
+    }
+
+    suggestions.sort(function (a, b) { return a.name.localeCompare(b.name); });
+    sendTo(clientId, { type: "browse:suggestions_result", suggestions: suggestions });
+    return;
+  }
+});