Opt Pass (#256)

Author: arul28

apps/ade-cli/README.md

@@ -75,6 +75,8 @@ ade ios-sim devices --text
 ade --socket ios-sim apps --text
 ade --socket ios-sim launch --target target-id --text
 ade --socket ios-sim preview-render --source apps/ios/ADE/Views/Home.swift --index 0 --text
+ade --socket app-control launch --command "npm run dev" --text
+ade --socket browser open http://localhost:5173 --new-tab --text
 ade --socket update status --text
 ade --socket update check --text
 ade --socket update install --text

apps/ade-cli/src/cli.test.ts

@@ -1829,6 +1829,44 @@ describe("ADE CLI", () => {
     });
   });
 
+  it("update commands map to auto-update actions", () => {
+    const status = buildCliPlan(["update", "status"]);
+    expect(status.kind).toBe("execute");
+    if (status.kind !== "execute") return;
+    expect(status.steps[0]?.params).toMatchObject({
+      arguments: { domain: "update", action: "getSnapshot", args: {} },
+    });
+
+    const check = buildCliPlan(["auto-update", "check"]);
+    expect(check.kind).toBe("execute");
+    if (check.kind !== "execute") return;
+    expect(check.steps[0]?.params).toMatchObject({
+      arguments: { domain: "update", action: "checkForUpdates", args: {} },
+    });
+
+    const install = buildCliPlan(["updates", "install"]);
+    expect(install.kind).toBe("execute");
+    if (install.kind !== "execute") return;
+    expect(install.steps[0]?.params).toMatchObject({
+      arguments: { domain: "update", action: "quitAndInstall", args: {} },
+    });
+
+    const dismiss = buildCliPlan(["update", "dismiss"]);
+    expect(dismiss.kind).toBe("execute");
+    if (dismiss.kind !== "execute") return;
+    expect(dismiss.steps[0]?.params).toMatchObject({
+      arguments: { domain: "update", action: "dismissInstalledNotice", args: {} },
+    });
+
+    const actions = buildCliPlan(["update", "actions"]);
+    expect(actions.kind).toBe("execute");
+    if (actions.kind !== "execute") return;
+    expect(actions.steps[0]?.params).toMatchObject({
+      name: "list_ade_actions",
+      arguments: { domain: "update" },
+    });
+  });
+
   it("attaches a rendered lane graph when the plan has the lanes visualizer", () => {
     const connection = {
       mode: "headless" as const,

apps/desktop/resources/ade-cli-help.txt

@@ -38,6 +38,7 @@ _    ____  _____
     $ ade browser open | tabs | screenshot         Use ADE's built-in browser pane
     $ ade memory add | search | pin                 Use ADE memory
     $ ade settings action <method>                  Call project config actions
+    $ ade update status | check | install | dismiss Read auto-update state and drive install
     $ ade actions list | run | status               Escape hatch for every ADE service action
     $ ade cursor cloud agents | runs | artifacts | repos | models | me
                                                     Drive Cursor Cloud agents via @cursor/sdk
@@ -121,6 +122,7 @@ _    ____  _____
     $ ade browser open | tabs | screenshot         Use ADE's built-in browser pane
     $ ade memory add | search | pin                 Use ADE memory
     $ ade settings action <method>                  Call project config actions
+    $ ade update status | check | install | dismiss Read auto-update state and drive install
     $ ade actions list | run | status               Escape hatch for every ADE service action
     $ ade cursor cloud agents | runs | artifacts | repos | models | me
                                                     Drive Cursor Cloud agents via @cursor/sdk
@@ -204,6 +206,7 @@ _    ____  _____
     $ ade browser open | tabs | screenshot         Use ADE's built-in browser pane
     $ ade memory add | search | pin                 Use ADE memory
     $ ade settings action <method>                  Call project config actions
+    $ ade update status | check | install | dismiss Read auto-update state and drive install
     $ ade actions list | run | status               Escape hatch for every ADE service action
     $ ade cursor cloud agents | runs | artifacts | repos | models | me
                                                     Drive Cursor Cloud agents via @cursor/sdk
@@ -614,6 +617,10 @@ _    ____  _____
     $ ade --socket ios-sim shutdown --force        Force-release a session owned by another chat
     $ ade ios-sim actions --text                   List every callable ios_simulator action
 
+  Project discovery scans root-level .xcodeproj bundles and apps/*/*.xcodeproj
+  projects; do not create symlink shims or fake schemes before checking
+  "ios-sim apps --text" and the build output.
+
   Capture and inspection:
     $ ade ios-sim screenshot --text                One-shot PNG via simctl (screenshot)
     $ ade ios-sim snapshot --text                  Screenshot + selectable elements (getScreenSnapshot)
@@ -791,6 +798,7 @@ _    ____  _____
     $ ade browser open | tabs | screenshot         Use ADE's built-in browser pane
     $ ade memory add | search | pin                 Use ADE memory
     $ ade settings action <method>                  Call project config actions
+    $ ade update status | check | install | dismiss Read auto-update state and drive install
     $ ade actions list | run | status               Escape hatch for every ADE service action
     $ ade cursor cloud agents | runs | artifacts | repos | models | me
                                                     Drive Cursor Cloud agents via @cursor/sdk
@@ -837,6 +845,32 @@ _    ____  _____
 
   Start with: ade doctor --text
 
+## ade update --help
+_    ____  _____
+    / \  |  _ \| ____|
+   / _ \ | | | |  _|
+  / ___ \| |_| | |___
+ /_/   \_\____/|_____|
+
+  Auto-update
+
+  Auto-update commands query and drive ADE desktop's auto-updater. The desktop
+  app owns the updater process; CLI parity exists so agents can read state and,
+  when explicitly requested by the user, trigger a check, install, or dismiss
+  the post-install notice. quitAndInstall relaunches the desktop app and only
+  succeeds when status is "ready".
+
+    $ ade --socket update status --text             Read AutoUpdateSnapshot (status, version, progress)
+    $ ade --socket update check --text              Trigger a background update check
+    $ ade --socket update install --text            Refresh latest, then quit and install when ready
+    $ ade --socket update dismiss --text            Clear the recently-installed banner
+    $ ade --socket update actions --text            List callable update actions
+
+  Snapshot status values: idle, checking, downloading, ready, installing, error.
+  "installing" appears between quitAndInstall and the desktop relaunch; if the
+  install fails, status falls back to error and the pending-install record is
+  cleared automatically.
+
 ## ade actions --help
 _    ____  _____
     / \  |  _ \| ____|

apps/desktop/scripts/regen-ade-cli-help.cjs

@@ -30,6 +30,7 @@ const SUBCOMMANDS = [
   "browser",
   "memory",
   "settings",
+  "update",
   "actions",
   "cursor",
 ];

apps/desktop/src/main/services/memory/embeddingWorkerService.test.ts

@@ -8,6 +8,7 @@ import { createMemoryService } from "./memoryService";
 import {
   createEmbeddingWorkerService,
   DEFAULT_ACTIVE_BATCH_SIZE,
+  DEFAULT_ACTIVE_SESSION_COLD_START_DEFER_MS,
   DEFAULT_IDLE_BATCH_SIZE,
 } from "./embeddingWorkerService";
 import { DEFAULT_EMBEDDING_MODEL_ID, EXPECTED_EMBEDDING_DIMENSIONS } from "./embeddingService";
@@ -35,9 +36,11 @@ function buildVector(seed: string): Float32Array {
 async function createFixture(opts: {
   withActiveSession?: boolean;
   embedImpl?: (text: string) => Promise<Float32Array>;
+  isAvailable?: () => boolean;
   sleep?: (ms: number) => Promise<void>;
   idleBatchSize?: number;
   activeBatchSize?: number;
+  activeSessionColdStartDeferMs?: number;
   attachQueueHook?: boolean;
 } = {}) {
   const root = fs.mkdtempSync(path.join(os.tmpdir(), "ade-embedding-worker-"));
@@ -76,7 +79,7 @@ async function createFixture(opts: {
   const sessionService = createSessionService({ db });
   const embeddingService = {
     embed: vi.fn(opts.embedImpl ?? (async (text: string) => buildVector(text))),
-    isAvailable: vi.fn(() => true),
+    isAvailable: vi.fn(opts.isAvailable ?? (() => true)),
     getModelId: vi.fn(() => DEFAULT_EMBEDDING_MODEL_ID),
   };
 
@@ -98,6 +101,7 @@ async function createFixture(opts: {
     sessionService,
     idleBatchSize: opts.idleBatchSize ?? DEFAULT_IDLE_BATCH_SIZE,
     activeBatchSize: opts.activeBatchSize ?? DEFAULT_ACTIVE_BATCH_SIZE,
+    activeSessionColdStartDeferMs: opts.activeSessionColdStartDeferMs ?? DEFAULT_ACTIVE_SESSION_COLD_START_DEFER_MS,
     sleep: opts.sleep,
   });
 
@@ -268,6 +272,51 @@ describe("embeddingWorkerService", () => {
     expect(sleep).toHaveBeenCalledWith(100);
   });
 
+  it("defers a cold embedding model load while sessions are active", async () => {
+    vi.useFakeTimers();
+    try {
+      let modelReady = false;
+      const { db, logger, worker, memoryService, embeddingService } = await createFixture({
+        withActiveSession: true,
+        activeSessionColdStartDeferMs: 25,
+        isAvailable: () => modelReady,
+      });
+
+      memoryService.addMemory({
+        projectId: "project-1",
+        scope: "project",
+        category: "fact",
+        content: "Defer this until the active session is not competing with a cold model load.",
+        importance: "medium",
+      });
+
+      await vi.advanceTimersByTimeAsync(0);
+
+      expect(embeddingService.embed).not.toHaveBeenCalled();
+      expect(worker.getStatus()).toEqual(expect.objectContaining({
+        batchesProcessed: 0,
+        queueDepth: 1,
+      }));
+      expect(logger.info).toHaveBeenCalledWith(
+        "memory.embedding_worker.cold_start_deferred",
+        expect.objectContaining({
+          projectId: "project-1",
+          queueDepth: 1,
+          retryInMs: 25,
+        }),
+      );
+
+      modelReady = true;
+      await vi.advanceTimersByTimeAsync(25);
+      await worker.waitForIdle();
+
+      expect(embeddingService.embed).toHaveBeenCalledTimes(1);
+      expect(countEmbeddings(db)).toBe(1);
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+
   it("logs and skips a failed entry without blocking the rest of the batch", async () => {
     const { db, logger, worker, memoryService } = await createFixture({
       idleBatchSize: 10,

apps/desktop/src/main/services/memory/embeddingWorkerService.ts

@@ -7,6 +7,7 @@ import type { createEmbeddingService } from "./embeddingService";
 
 export const DEFAULT_IDLE_BATCH_SIZE = 50;
 export const DEFAULT_ACTIVE_BATCH_SIZE = 10;
+export const DEFAULT_ACTIVE_SESSION_COLD_START_DEFER_MS = 60_000;
 const MIN_BATCH_SIZE = 10;
 const MAX_BATCH_SIZE = 50;
 const DEFAULT_YIELD_MS = 100;
@@ -26,6 +27,7 @@ type CreateEmbeddingWorkerServiceOpts = {
   sessionService?: Pick<ReturnType<typeof createSessionService>, "list">;
   idleBatchSize?: number;
   activeBatchSize?: number;
+  activeSessionColdStartDeferMs?: number;
   yieldMs?: number;
   now?: () => Date;
   sleep?: (ms: number) => Promise<void>;
@@ -75,6 +77,10 @@ export function createEmbeddingWorkerService(opts: CreateEmbeddingWorkerServiceO
 
   const idleBatchSize = normalizeBatchSize(opts.idleBatchSize, DEFAULT_IDLE_BATCH_SIZE);
   const activeBatchSize = normalizeBatchSize(opts.activeBatchSize, DEFAULT_ACTIVE_BATCH_SIZE);
+  const activeSessionColdStartDeferMs = Math.max(
+    1,
+    Math.floor(opts.activeSessionColdStartDeferMs ?? DEFAULT_ACTIVE_SESSION_COLD_START_DEFER_MS),
+  );
   const yieldMs = Math.max(0, Math.floor(opts.yieldMs ?? DEFAULT_YIELD_MS));
 
   const queue: string[] = [];
@@ -129,9 +135,15 @@ export function createEmbeddingWorkerService(opts: CreateEmbeddingWorkerServiceO
     return isSessionActive() ? activeBatchSize : idleBatchSize;
   }
 
-  function scheduleProcessing() {
+  function shouldDeferColdStartForActiveSession(): boolean {
+    if (embeddingService.isAvailable()) return false;
+    return isSessionActive();
+  }
+
+  function scheduleProcessing(delayMs = 0) {
     if (scheduled || processingPromise || queue.length === 0) return;
     scheduled = true;
+    const normalizedDelayMs = Math.max(0, Math.floor(delayMs));
     setTimeout(() => {
       scheduled = false;
       void processQueue().catch((error) => {
@@ -140,7 +152,7 @@ export function createEmbeddingWorkerService(opts: CreateEmbeddingWorkerServiceO
           error: getErrorMessage(error),
         });
       });
-    }, 0);
+    }, normalizedDelayMs);
   }
 
   function queueMemory(memoryId: string) {
@@ -227,8 +239,19 @@ export function createEmbeddingWorkerService(opts: CreateEmbeddingWorkerServiceO
   async function processQueue() {
     if (processingPromise) return processingPromise;
 
+    let rescheduleDelayMs = 0;
     processingPromise = (async () => {
       while (queue.length > 0) {
+        if (shouldDeferColdStartForActiveSession()) {
+          rescheduleDelayMs = activeSessionColdStartDeferMs;
+          logger.info("memory.embedding_worker.cold_start_deferred", {
+            projectId,
+            queueDepth: queue.length,
+            retryInMs: activeSessionColdStartDeferMs,
+          });
+          return;
+        }
+
         const batchSize = Math.min(nextBatchSize(), queue.length);
         const batchIds = queue.splice(0, batchSize);
         for (const id of batchIds) {
@@ -272,7 +295,7 @@ export function createEmbeddingWorkerService(opts: CreateEmbeddingWorkerServiceO
       processingPromise = null;
       resolveIdleIfNeeded();
       if (queue.length > 0) {
-        scheduleProcessing();
+        scheduleProcessing(rescheduleDelayMs);
       }
     });
 

apps/desktop/src/renderer/components/app/AppShell.tsx

@@ -429,8 +429,27 @@ export function AppShell({ children }: { children: React.ReactNode }) {
       }
     };
 
-    const disposeProjectChanged = window.ade.app.onProjectChanged(() => {
-      void initializeProjectState();
+    const disposeProjectChanged = window.ade.app.onProjectChanged((nextProject) => {
+      const state = useAppStore.getState();
+      const nextRoot = nextProject?.rootPath ?? null;
+      const currentRoot = state.project?.rootPath ?? null;
+      const expectedShowWelcome = !nextProject;
+      const alreadyApplied =
+        state.projectHydrated &&
+        currentRoot === nextRoot &&
+        state.showWelcome === expectedShowWelcome;
+
+      if (state.projectTransition) return;
+
+      if (alreadyApplied) {
+        setProject(nextProject);
+        setShowWelcome(expectedShowWelcome);
+        return;
+      }
+
+      setProjectHydrated(false);
+      applyProjectState(nextProject);
+      setProjectHydrated(true);
     });
 
     void initializeProjectState();