opt fixes

Author: arul28

apps/desktop/src/main/services/files/fileSearchIndexService.ts

@@ -21,6 +21,17 @@ const VOLATILE_ADE_FILES = new Set([
   ".ade/ade.sock",
   ".ade/local.secret.yaml",
 ]);
+const ALWAYS_SKIPPED_DIRECTORY_NAMES = new Set([
+  ".git",
+  ".next",
+  ".nuxt",
+  ".svelte-kit",
+  ".turbo",
+  ".vite",
+  "coverage",
+  "dist",
+  "node_modules",
+]);
 
 type IndexedFile = {
   path: string;
@@ -41,6 +52,11 @@ type WorkspaceIndex = {
   builtAt: string | null;
 };
 
+type IgnoreOptions = {
+  shouldIgnore: (relPath: string, includeIgnored: boolean) => Promise<boolean>;
+  primeIgnoreCache?: (relPaths: string[], includeIgnored: boolean) => Promise<void>;
+};
+
 function isVolatileAdeRuntimePath(relPath: string): boolean {
   return VOLATILE_ADE_FILES.has(relPath)
     || VOLATILE_ADE_PREFIXES.some((prefix) => relPath === prefix.slice(0, -1) || relPath.startsWith(prefix));
@@ -161,15 +177,9 @@ export function createFileSearchIndexService() {
     });
   };
 
-  const shouldSkipDirectoryName = (name: string): boolean => {
-    if (name === ".git") return true;
-    if (name === "node_modules") return true;
-    return false;
-  };
+  const shouldSkipDirectoryName = (name: string): boolean => ALWAYS_SKIPPED_DIRECTORY_NAMES.has(name);
 
-  const buildWorkspace = async (index: WorkspaceIndex, opts: {
-    shouldIgnore: (relPath: string, includeIgnored: boolean) => Promise<boolean>;
-  }): Promise<void> => {
+  const buildWorkspace = async (index: WorkspaceIndex, opts: IgnoreOptions): Promise<void> => {
     index.files.clear();
     index.totalContentBytes = 0;
 
@@ -187,8 +197,13 @@ export function createFileSearchIndexService() {
         continue;
       }
 
-      for (const entry of entries) {
-        const relPath = normalizeRelative(path.join(relDir, entry.name));
+      const candidates = entries
+        .map((entry) => ({ entry, relPath: normalizeRelative(path.join(relDir, entry.name)) }))
+        .filter((candidate) => Boolean(candidate.relPath));
+
+      await opts.primeIgnoreCache?.(candidates.map((candidate) => candidate.relPath), index.includeIgnored);
+
+      for (const { entry, relPath } of candidates) {
         if (!relPath) continue;
         if (shouldSkipPathPrefix(relPath, index.includeIgnored)) continue;
         if (entry.isDirectory() && shouldSkipDirectoryName(entry.name)) continue;
@@ -215,9 +230,8 @@ export function createFileSearchIndexService() {
     index.builtAt = new Date().toISOString();
   };
 
-  const ensureBuilt = async (workspaceId: string, rootPath: string, opts: {
+  const ensureBuilt = async (workspaceId: string, rootPath: string, opts: IgnoreOptions & {
     includeIgnored: boolean;
-    shouldIgnore: (relPath: string, includeIgnored: boolean) => Promise<boolean>;
   }): Promise<WorkspaceIndex> => {
     const index = getOrCreateWorkspaceIndex(workspaceId, rootPath, opts.includeIgnored);
     if (index.files.size > 0 || index.builtAt) return index;
@@ -239,10 +253,12 @@ export function createFileSearchIndexService() {
       rootPath: string;
       includeIgnored: boolean;
       shouldIgnore: (relPath: string, includeIgnored: boolean) => Promise<boolean>;
+      primeIgnoreCache?: (relPaths: string[], includeIgnored: boolean) => Promise<void>;
     }): Promise<void> {
       await ensureBuilt(args.workspaceId, args.rootPath, {
         includeIgnored: args.includeIgnored,
-        shouldIgnore: args.shouldIgnore
+        shouldIgnore: args.shouldIgnore,
+        primeIgnoreCache: args.primeIgnoreCache
       });
     },
 
@@ -253,10 +269,12 @@ export function createFileSearchIndexService() {
       limit: number;
       includeIgnored: boolean;
       shouldIgnore: (relPath: string, includeIgnored: boolean) => Promise<boolean>;
+      primeIgnoreCache?: (relPaths: string[], includeIgnored: boolean) => Promise<void>;
     }): Promise<FilesQuickOpenItem[]> {
       const index = await ensureBuilt(args.workspaceId, args.rootPath, {
         includeIgnored: args.includeIgnored,
-        shouldIgnore: args.shouldIgnore
+        shouldIgnore: args.shouldIgnore,
+        primeIgnoreCache: args.primeIgnoreCache
       });
 
       const scored: FilesQuickOpenItem[] = [];
@@ -276,10 +294,12 @@ export function createFileSearchIndexService() {
       limit: number;
       includeIgnored: boolean;
       shouldIgnore: (relPath: string, includeIgnored: boolean) => Promise<boolean>;
+      primeIgnoreCache?: (relPaths: string[], includeIgnored: boolean) => Promise<void>;
     }): Promise<FilesSearchTextMatch[]> {
       const index = await ensureBuilt(args.workspaceId, args.rootPath, {
         includeIgnored: args.includeIgnored,
-        shouldIgnore: args.shouldIgnore
+        shouldIgnore: args.shouldIgnore,
+        primeIgnoreCache: args.primeIgnoreCache
       });
 
       const out: FilesSearchTextMatch[] = [];

apps/desktop/src/main/services/files/fileService.test.ts

@@ -235,6 +235,37 @@ describe("fileService", () => {
     }
   });
 
+  it("keeps generated output directories out of the file search index", async () => {
+    const rootPath = fs.mkdtempSync(path.join(os.tmpdir(), "ade-file-service-generated-search-"));
+    const { execSync } = await import("node:child_process");
+    execSync("git init", { cwd: rootPath, stdio: "ignore" });
+    const laneService = createLaneServiceStub(rootPath);
+    const service = createFileService({ laneService });
+
+    try {
+      fs.mkdirSync(path.join(rootPath, "src"), { recursive: true });
+      fs.mkdirSync(path.join(rootPath, "dist"), { recursive: true });
+      fs.writeFileSync(path.join(rootPath, "src", "index.ts"), "needle source\n", "utf8");
+      fs.writeFileSync(path.join(rootPath, "dist", "bundle.js"), "needle bundled output\n", "utf8");
+
+      const quickOpen = await service.quickOpen({
+        workspaceId: "workspace-1",
+        query: "bundle",
+        includeIgnored: true,
+      });
+      const search = await service.searchText({
+        workspaceId: "workspace-1",
+        query: "needle",
+        includeIgnored: true,
+      });
+
+      expect(quickOpen).toEqual([]);
+      expect(search.map((item) => item.path)).toEqual(["src/index.ts"]);
+    } finally {
+      fs.rmSync(rootPath, { recursive: true, force: true });
+    }
+  });
+
   it("lists only the requested tree depth without extra file metadata", async () => {
     const rootPath = fs.mkdtempSync(path.join(os.tmpdir(), "ade-file-service-tree-"));
     const { execSync } = await import("node:child_process");

apps/desktop/src/main/services/files/fileService.ts

@@ -426,6 +426,8 @@ export function createFileService({
 
   const shouldIgnoreForRoot = (rootPath: string) =>
     (relPath: string, includeIgnored: boolean) => isIgnoredPath(rootPath, relPath, includeIgnored);
+  const primeIgnoreCacheForRoot = (rootPath: string) =>
+    (relPaths: string[], includeIgnored: boolean) => primeIgnoreCache(rootPath, relPaths, includeIgnored);
 
   const emitLaneMutation = (workspaceId: string, reason: string) => {
     if (!onLaneWorktreeMutation) return;
@@ -838,7 +840,8 @@ export function createFileService({
         query,
         limit,
         includeIgnored: Boolean(args.includeIgnored),
-        shouldIgnore: shouldIgnoreForRoot(workspace.rootPath)
+        shouldIgnore: shouldIgnoreForRoot(workspace.rootPath),
+        primeIgnoreCache: primeIgnoreCacheForRoot(workspace.rootPath)
       });
     },
 
@@ -853,7 +856,8 @@ export function createFileService({
         query,
         limit,
         includeIgnored: Boolean(args.includeIgnored),
-        shouldIgnore: shouldIgnoreForRoot(workspace.rootPath)
+        shouldIgnore: shouldIgnoreForRoot(workspace.rootPath),
+        primeIgnoreCache: primeIgnoreCacheForRoot(workspace.rootPath)
       });
     },
 

apps/desktop/src/renderer/components/chat/AgentChatComposer.tsx

@@ -2136,7 +2136,8 @@ export function AgentChatComposer({
     setSelectedBuiltInBrowserContextId(null);
   }, [builtInBrowserContextItems, selectedBuiltInBrowserContextId]);
 
-  const composerBeamActive = isActive && layoutVariant !== "grid-tile" && !iosSimulatorOpen && (turnActive || !chatHasMessages);
+  // Idle composer motion keeps the GPU busy; reserve the beam for active turns.
+  const composerBeamActive = isActive && layoutVariant !== "grid-tile" && !iosSimulatorOpen && turnActive;
   const composerBeamVariant = turnActive ? "ocean" : "colorful";
   const composerBeamDuration = turnActive ? 20 : 5;
   const composerBeamStrength = turnActive ? 0.26 : 0.44;

apps/desktop/src/renderer/components/files/FilesPage.test.tsx

@@ -280,6 +280,16 @@ describe("FilesPage", () => {
         stageFile: vi.fn(async () => undefined),
         unstageFile: vi.fn(async () => undefined),
         discardFile: vi.fn(async () => undefined),
+        listRecentCommits: vi.fn(async () => []),
+      },
+      diff: {
+        getFile: vi.fn(async ({ path, mode }: { path: string; mode: string }) => ({
+          path,
+          mode,
+          original: { exists: true, text: fileContents[path] ?? "" },
+          modified: { exists: true, text: fileContents[path] ?? "" },
+          language: path.endsWith(".ts") ? "typescript" : "markdown",
+        })),
       },
       app: {
         openPathInEditor: vi.fn(async () => undefined),

apps/desktop/src/renderer/components/files/FilesPage.tsx

@@ -33,6 +33,7 @@ import type {
   FilesQuickOpenItem,
   FilesSearchTextMatch,
   FilesWorkspace,
+  FileDiff,
   GitCommitSummary,
   LaneSummary,
 } from "../../../shared/types";
@@ -456,6 +457,12 @@ function getFileIcon(fileName: string): { icon: React.ComponentType<any>; color:
   return { icon: FileText, color: FILE_ICON_COLORS.default };
 }
 
+function fileDiffHasRenderableChanges(diff: FileDiff): boolean {
+  if (diff.original.exists !== diff.modified.exists) return true;
+  if (diff.isBinary) return true;
+  return diff.original.text !== diff.modified.text;
+}
+
 function changeStatusColor(changeStatus: FileTreeNode["changeStatus"]): string {
   if (changeStatus === "A") return COLORS.success;
   if (changeStatus === "D") return COLORS.danger;
@@ -2873,7 +2880,15 @@ function FilesDiffPanel({
       </div>
 
       {error ? <div style={{ padding: 12, fontFamily: MONO_FONT, fontSize: 11, color: COLORS.danger }}>{error}</div> : null}
-      <div className="min-h-0 flex-1">{diff ? <MonacoDiffView ref={diffViewRef} diff={diff} className="h-full" theme={theme} /> : null}</div>
+      <div className="min-h-0 flex-1">
+        {diff && fileDiffHasRenderableChanges(diff) ? (
+          <MonacoDiffView ref={diffViewRef} diff={diff} className="h-full" theme={theme} />
+        ) : diff ? (
+          <div className="flex h-full items-center justify-center px-4 text-xs" style={{ color: COLORS.textMuted }}>
+            No changes for this file.
+          </div>
+        ) : null}
+      </div>
     </div>
   );
 }

apps/desktop/src/renderer/components/run/LaneRuntimeBar.tsx

@@ -22,6 +22,9 @@ const dividerStyle = {
   paddingRight: 16,
 };
 
+const RUNTIME_BAR_PASSIVE_REFRESH_MS = 10_000;
+const RUNTIME_BAR_HEALTH_REFRESH_MS = 30_000;
+
 export function LaneRuntimeBar({ laneId, onOpenPreviewRouting }: LaneRuntimeBarProps) {
   const [health, setHealth] = useState<LaneHealthCheck | null>(null);
   const [preview, setPreview] = useState<LanePreviewInfo | null>(null);
@@ -84,13 +87,19 @@ export function LaneRuntimeBar({ laneId, onOpenPreviewRouting }: LaneRuntimeBarP
       return;
     }
     let cancelled = false;
+    let lastHealthRefreshAt = 0;
     const runRefresh = (runHealthCheck: boolean) => {
       if (cancelled) return;
+      if (document.visibilityState !== "visible") return;
+      if (runHealthCheck) lastHealthRefreshAt = Date.now();
       refreshRuntimeState(laneId, { runHealthCheck });
     };
     runRefresh(false);
     const deferredTimer = window.setTimeout(() => runRefresh(true), 160);
-    const refreshInterval = window.setInterval(() => runRefresh(true), 2500);
+    const refreshInterval = window.setInterval(() => {
+      const shouldRunHealthCheck = Date.now() - lastHealthRefreshAt >= RUNTIME_BAR_HEALTH_REFRESH_MS;
+      runRefresh(shouldRunHealthCheck);
+    }, RUNTIME_BAR_PASSIVE_REFRESH_MS);
 
     return () => {
       cancelled = true;

apps/desktop/src/renderer/components/terminals/useSessionDelta.ts

@@ -2,7 +2,14 @@ import { useEffect, useState } from "react";
 import type { SessionDeltaSummary } from "../../../shared/types";
 
 const deltaCache = new Map<string, SessionDeltaSummary | null>();
+const deltaInFlight = new Map<string, Promise<SessionDeltaSummary | null>>();
+const deltaQueue: Array<{
+  sessionId: string;
+  resolve: (value: SessionDeltaSummary | null) => void;
+}> = [];
 const MAX_CACHED_SESSION_DELTAS = 128;
+const MAX_CONCURRENT_SESSION_DELTA_REQUESTS = 4;
+let activeDeltaRequests = 0;
 
 function touchDeltaCacheEntry(sessionId: string, value: SessionDeltaSummary | null): void {
   if (deltaCache.has(sessionId)) {
@@ -16,6 +23,46 @@ function touchDeltaCacheEntry(sessionId: string, value: SessionDeltaSummary | nu
   }
 }
 
+function pumpDeltaQueue(): void {
+  while (activeDeltaRequests < MAX_CONCURRENT_SESSION_DELTA_REQUESTS && deltaQueue.length > 0) {
+    const next = deltaQueue.shift();
+    if (!next) return;
+    activeDeltaRequests += 1;
+    window.ade.sessions
+      .getDelta(next.sessionId)
+      .then((result) => {
+        touchDeltaCacheEntry(next.sessionId, result);
+        next.resolve(result);
+      })
+      .catch(() => {
+        touchDeltaCacheEntry(next.sessionId, null);
+        next.resolve(null);
+      })
+      .finally(() => {
+        deltaInFlight.delete(next.sessionId);
+        activeDeltaRequests = Math.max(0, activeDeltaRequests - 1);
+        pumpDeltaQueue();
+      });
+  }
+}
+
+function fetchSessionDelta(sessionId: string): Promise<SessionDeltaSummary | null> {
+  if (deltaCache.has(sessionId)) {
+    const cached = deltaCache.get(sessionId) ?? null;
+    touchDeltaCacheEntry(sessionId, cached);
+    return Promise.resolve(cached);
+  }
+  const existing = deltaInFlight.get(sessionId);
+  if (existing) return existing;
+
+  const request = new Promise<SessionDeltaSummary | null>((resolve) => {
+    deltaQueue.push({ sessionId, resolve });
+    pumpDeltaQueue();
+  });
+  deltaInFlight.set(sessionId, request);
+  return request;
+}
+
 export function useSessionDelta(sessionId: string | null, enabled: boolean) {
   const [delta, setDelta] = useState<SessionDeltaSummary | null>(
     sessionId ? deltaCache.get(sessionId) ?? null : null,
@@ -27,24 +74,11 @@ export function useSessionDelta(sessionId: string | null, enabled: boolean) {
       return;
     }
 
-    if (deltaCache.has(sessionId)) {
-      const cached = deltaCache.get(sessionId) ?? null;
-      touchDeltaCacheEntry(sessionId, cached);
-      setDelta(cached);
-      return;
-    }
-
     let cancelled = false;
-    window.ade.sessions
-      .getDelta(sessionId)
+    fetchSessionDelta(sessionId)
       .then((result) => {
         if (cancelled) return;
-        touchDeltaCacheEntry(sessionId, result);
         setDelta(result);
-      })
-      .catch(() => {
-        // Cache the miss so we don't re-fetch on every render
-        if (!cancelled) touchDeltaCacheEntry(sessionId, null);
       });
 
     return () => {