@wrongstack/desktop 1.0.3 → 1.0.4

package/assets/icon.svg

@@ -0,0 +1,6 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 400 400" fill="none" role="img" aria-labelledby="wrongstack-logo-title" shape-rendering="crispEdges">
+  <title id="wrongstack-logo-title">WrongStack</title>
+  <rect width="400" height="400" fill="#121210"/>
+  <path fill="#FD9F02" d="M30 170h60v60H30zM170 170h60v60h-60zM240 170h60v60h-60zM310 170h60v60h-60z"/>
+  <path fill="#FE2E5F" d="M100 200h60v60h-60z"/>
+</svg>

package/dist/main/agent-bridge.js

@@ -175,9 +175,7 @@ var DesktopAgentBridge = class extends EventEmitter {
       conversation.reconnectTimer = null;
       if (!conversation.reconnectUrl) return;
       if (conversation.ws?.readyState !== WebSocket.OPEN) {
-        void this.connect(conversation.runtimeId, conversation.reconnectUrl).catch(
-          () => void 0
-        );
+        void this.connect(conversation.runtimeId, conversation.reconnectUrl).catch(() => void 0);
       }
     }, reconnect.plan.delayMs);
   }

package/dist/main/main.js

@@ -1,5 +1,5 @@
 // src/main/main.ts
-import * as path6 from "node:path";
+import * as path7 from "node:path";
 import { installCrashShield, resolveWstackPaths as resolveWstackPaths3 } from "@wrongstack/core/utils";
 import {
   app as app2,
@@ -40,9 +40,9 @@ function handleFileOpen(filePath) {
 }
 var pendingOpenFilePath = null;
 function drainPendingOpenFilePath() {
-  const path7 = pendingOpenFilePath;
+  const path8 = pendingOpenFilePath;
   pendingOpenFilePath = null;
-  return path7;
+  return path8;
 }
 function firstOpenFileArg(argv) {
   if (process.platform !== "darwin") return null;
@@ -147,7 +147,7 @@ var DesktopAgentBridge = class extends EventEmitter {
     conversation.error = void 0;
     this.emitChanged(conversation);
     this.emitReconnectEvent(conversation, "connecting");
-    const promise = new Promise((resolve4, reject) => {
+    const promise = new Promise((resolve5, reject) => {
       const ws = new WebSocket(wsUrl);
       conversation.ws = ws;
       const myGeneration = ++conversation.socketGeneration;
@@ -172,7 +172,7 @@ var DesktopAgentBridge = class extends EventEmitter {
         conversation.connectionState = markConnectionOpen(conversation.connectionState);
         this.emitChanged(conversation);
         this.emitReconnectEvent(conversation, "connected");
-        resolve4();
+        resolve5();
       });
       ws.once("error", (err) => {
         clearTimeout(timeout);
@@ -233,9 +233,7 @@ var DesktopAgentBridge = class extends EventEmitter {
       conversation.reconnectTimer = null;
       if (!conversation.reconnectUrl) return;
       if (conversation.ws?.readyState !== WebSocket.OPEN) {
-        void this.connect(conversation.runtimeId, conversation.reconnectUrl).catch(
-          () => void 0
-        );
+        void this.connect(conversation.runtimeId, conversation.reconnectUrl).catch(() => void 0);
       }
     }, reconnect.plan.delayMs);
   }
@@ -531,6 +529,7 @@ var IPC = {
   getState: "desktop:get-state",
   getConversation: "desktop:get-conversation",
   getWebuiStatus: "desktop:get-webui-status",
+  listProjectSessions: "desktop:list-project-sessions",
   openProject: "desktop:open-project",
   registerProject: "desktop:register-project",
   unregisterProject: "desktop:unregister-project",
@@ -1004,6 +1003,24 @@ var WS_PORT_START = 34660;
 var START_TIMEOUT_MS = 3e4;
 var MIN_WINDOW_WIDTH = 760;
 var MIN_WINDOW_HEIGHT = 520;
+var DEFAULT_IDLE_MINUTES = 15;
+var IDLE_SWEEP_INTERVAL_MS = 6e4;
+function resolveIdleTimeoutMs(env = process.env) {
+  const raw = Number.parseFloat(env.WRONGSTACK_DESKTOP_IDLE_MINUTES ?? "");
+  if (Number.isFinite(raw)) return raw > 0 ? raw * 6e4 : 0;
+  return DEFAULT_IDLE_MINUTES * 6e4;
+}
+function reclaimableRuntimeIds(runtimes, options) {
+  if (options.idleTimeoutMs <= 0) return [];
+  const out = [];
+  for (const [id, runtime] of runtimes) {
+    if (id === options.activeRuntimeId) continue;
+    if (runtime.status !== "running") continue;
+    if (options.now - runtime.lastActivityAt < options.idleTimeoutMs) continue;
+    out.push(id);
+  }
+  return out;
+}
 var DesktopRuntimeManager = class extends EventEmitter2 {
   constructor(trustBoundary = desktopCompatibilityTrustBoundary) {
     super();
@@ -1025,6 +1042,8 @@ var DesktopRuntimeManager = class extends EventEmitter2 {
   activeRuntimeId = null;
   restoring = false;
   workspaceRestoreCompleted = false;
+  idleSweepTimer = null;
+  idleTimeoutMs = 0;
   async init() {
     const state = await this.loadDesktopState();
     this.recentProjects = state.recentProjects;
@@ -1036,9 +1055,12 @@ var DesktopRuntimeManager = class extends EventEmitter2 {
     this.windowState = state.window;
   }
   snapshot() {
+    const activeId = this.activeRuntimeId;
     return {
-      activeRuntimeId: this.activeRuntimeId,
-      runtimes: Array.from(this.runtimes.values()).map(publicRuntime),
+      activeRuntimeId: activeId,
+      runtimes: Array.from(this.runtimes.values()).map(
+        (runtime) => publicRuntime(runtime, runtime.id === activeId)
+      ),
       recentProjects: [...this.recentProjects],
       registeredProjects: [...this.registeredProjects],
       restoring: this.restoring
@@ -1101,7 +1123,7 @@ var DesktopRuntimeManager = class extends EventEmitter2 {
   }
   getRuntime(id) {
     const runtime = this.runtimes.get(id);
-    return runtime ? publicRuntime(runtime) : void 0;
+    return runtime ? publicRuntime(runtime, true) : void 0;
   }
   getRuntimeUrlWithToken(id) {
     const runtime = this.runtimes.get(id);
@@ -1120,8 +1142,8 @@ var DesktopRuntimeManager = class extends EventEmitter2 {
   }
   async openProject(projectRoot, options = {}) {
     const resolved = path3.resolve(projectRoot);
-    const stat3 = await fs2.stat(resolved).catch(() => null);
-    if (!stat3?.isDirectory()) throw new Error(`Not a directory: ${resolved}`);
+    const stat4 = await fs2.stat(resolved).catch(() => null);
+    if (!stat4?.isDirectory()) throw new Error(`Not a directory: ${resolved}`);
     const kind = options.kind ?? "project";
     const touchRecent = options.touchRecent ?? kind === "project";
     const forceNew = options.forceNew === true;
@@ -1142,7 +1164,7 @@ var DesktopRuntimeManager = class extends EventEmitter2 {
           await this.persistWorkspaceState();
         }
         this.emitChanged();
-        return publicRuntime(existing);
+        return publicRuntime(existing, true);
       }
       const staleSameRoot = Array.from(this.runtimes.values()).filter(
         (runtime2) => samePath(runtime2.root, resolved) && runtime2.kind === kind
@@ -1175,7 +1197,8 @@ var DesktopRuntimeManager = class extends EventEmitter2 {
       token,
       child: null,
       logs: [],
-      logNotifyTimer: null
+      logNotifyTimer: null,
+      lastActivityAt: Date.now()
     };
     this.runtimes.set(runtimeId, runtime);
     this.activeRuntimeId = runtimeId;
@@ -1229,12 +1252,14 @@ var DesktopRuntimeManager = class extends EventEmitter2 {
       child.stdout?.on("data", (chunk) => {
         const text = chunk.toString();
         appendRuntimeLog(runtime, "stdout", text);
+        runtime.lastActivityAt = Date.now();
         this.scheduleLogChanged(runtime);
         process.stdout.write(`[desktop:${runtime.id}] ${text}`);
       });
       child.stderr?.on("data", (chunk) => {
         const text = chunk.toString();
         appendRuntimeLog(runtime, "stderr", text);
+        runtime.lastActivityAt = Date.now();
         this.scheduleLogChanged(runtime);
         process.stderr.write(`[desktop:${runtime.id}] ${text}`);
       });
@@ -1264,7 +1289,7 @@ var DesktopRuntimeManager = class extends EventEmitter2 {
       runtime.status = "running";
       await this.persistWorkspaceState();
       this.emitChanged();
-      return publicRuntime(runtime);
+      return publicRuntime(runtime, true);
     } catch (err) {
       if (runtime.status !== "stopped" && runtime.status !== "error") {
         runtime.status = "error";
@@ -1285,6 +1310,7 @@ var DesktopRuntimeManager = class extends EventEmitter2 {
     const runtime = this.runtimes.get(id);
     if (!runtime) throw new Error(`Runtime not found: ${id}`);
     this.activeRuntimeId = id;
+    runtime.lastActivityAt = Date.now();
     if (runtime.kind === "project") this.lastActiveProjectRoot = runtime.root;
     if (runtime.kind === "project") {
       await this.touchProject(runtime.root);
@@ -1313,8 +1339,8 @@ var DesktopRuntimeManager = class extends EventEmitter2 {
   }
   async registerProject(projectRoot) {
     const resolved = path3.resolve(projectRoot);
-    const stat3 = await fs2.stat(resolved).catch(() => null);
-    if (!stat3?.isDirectory()) throw new Error(`Not a directory: ${resolved}`);
+    const stat4 = await fs2.stat(resolved).catch(() => null);
+    if (!stat4?.isDirectory()) throw new Error(`Not a directory: ${resolved}`);
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const entry = {
       name: path3.basename(resolved) || resolved,
@@ -1436,11 +1462,58 @@ var DesktopRuntimeManager = class extends EventEmitter2 {
   emitChanged() {
     this.emit("changed");
   }
+  /**
+   * Notify the shell that a runtime produced output.
+   *
+   * Only the ACTIVE runtime's logs reach the renderer (see `publicRuntime`), so
+   * output from a background project has nothing to show and must not cost a
+   * broadcast. Before this guard, every project writing to stdout scheduled its
+   * own 250 ms timer, and each one fired a FULL snapshot: N chatty projects
+   * produced 4N broadcasts per second carrying N x 40 log lines each, for a
+   * panel that displays one runtime's output.
+   *
+   * The 250 ms debounce is per-runtime by construction (the timer lives on the
+   * runtime record) but only one runtime can be active, so at most one such
+   * timer is ever armed now.
+   */
+  /**
+   * Begin reclaiming idle project servers.
+   *
+   * Idempotent, and a no-op when the timeout is disabled. The interval is
+   * unref'd so a pending sweep never holds the process open during quit.
+   */
+  startIdleSweep(options = {}) {
+    if (this.idleSweepTimer) return;
+    this.idleTimeoutMs = options.idleTimeoutMs ?? resolveIdleTimeoutMs();
+    if (this.idleTimeoutMs <= 0) return;
+    this.idleSweepTimer = setInterval(() => {
+      void this.sweepIdleRuntimes();
+    }, IDLE_SWEEP_INTERVAL_MS);
+    this.idleSweepTimer.unref?.();
+  }
+  stopIdleSweep() {
+    if (!this.idleSweepTimer) return;
+    clearInterval(this.idleSweepTimer);
+    this.idleSweepTimer = null;
+  }
+  /** One pass. Exposed so a test can drive it without waiting on the interval. */
+  async sweepIdleRuntimes(now = Date.now()) {
+    const ids = reclaimableRuntimeIds(this.runtimes, {
+      activeRuntimeId: this.activeRuntimeId,
+      idleTimeoutMs: this.idleTimeoutMs,
+      now
+    });
+    for (const id of ids) {
+      await this.closeRuntimeInternal(id, { persistWorkspace: false });
+    }
+    return ids;
+  }
   scheduleLogChanged(runtime) {
+    if (runtime.id !== this.activeRuntimeId) return;
     if (runtime.logNotifyTimer) return;
     runtime.logNotifyTimer = setTimeout(() => {
       runtime.logNotifyTimer = null;
-      if (this.runtimes.get(runtime.id) === runtime) {
+      if (this.runtimes.get(runtime.id) === runtime && runtime.id === this.activeRuntimeId) {
         this.emitChanged();
       }
     }, 250);
@@ -1451,14 +1524,14 @@ function hasChildExited(child) {
 }
 function waitForChildExit(child, timeoutMs) {
   if (hasChildExited(child)) return Promise.resolve(true);
-  return new Promise((resolve4) => {
+  return new Promise((resolve5) => {
     let settled = false;
     const finish = (exited) => {
       if (settled) return;
       settled = true;
       clearTimeout(timer);
       child.off("exit", onExit);
-      resolve4(exited);
+      resolve5(exited);
     };
     const onExit = () => finish(true);
     const timer = setTimeout(() => finish(hasChildExited(child)), timeoutMs);
@@ -1484,12 +1557,12 @@ async function terminateProcessTree(child) {
     }
     return;
   }
-  await new Promise((resolve4) => {
+  await new Promise((resolve5) => {
     let settled = false;
     const finish = () => {
       if (settled) return;
       settled = true;
-      resolve4();
+      resolve5();
     };
     const timer = setTimeout(finish, 3e3);
     timer.unref?.();
@@ -1508,7 +1581,8 @@ async function terminateProcessTree(child) {
     });
   });
 }
-function publicRuntime(runtime) {
+var SNAPSHOT_LOG_LINES = 40;
+function publicRuntime(runtime, includeLogs) {
   const {
     child: _child,
     token: _token,
@@ -1519,9 +1593,10 @@ function publicRuntime(runtime) {
   void _child;
   void _token;
   void _logNotifyTimer;
+  if (!includeLogs) return record;
   return {
     ...record,
-    recentLogs: logs.slice(-40)
+    recentLogs: logs.slice(-SNAPSHOT_LOG_LINES)
   };
 }
 function runtimeToSessionState(runtime) {
@@ -1634,11 +1709,11 @@ async function findFreePort(startPort, exclude) {
   throw new Error(`No free local port found near ${startPort}`);
 }
 function isPortFree(port) {
-  return new Promise((resolve4) => {
+  return new Promise((resolve5) => {
     const server = net.createServer();
-    server.once("error", () => resolve4(false));
+    server.once("error", () => resolve5(false));
     server.once("listening", () => {
-      server.close(() => resolve4(true));
+      server.close(() => resolve5(true));
     });
     server.listen(port, "127.0.0.1");
   });
@@ -1648,7 +1723,7 @@ function waitForHttpReady(baseUrl, token, timeoutMs) {
   const url = new URL(baseUrl);
   url.searchParams.set("token", token);
   url.searchParams.set("shell", "desktop");
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve5, reject) => {
     let probeTimer;
     const cleanup = () => {
       if (probeTimer) {
@@ -1673,7 +1748,7 @@ function waitForHttpReady(baseUrl, token, timeoutMs) {
           if (!done) {
             done = true;
             cleanup();
-            resolve4();
+            resolve5();
           }
           return;
         }
@@ -2101,12 +2176,31 @@ var DesktopWebuiController = class {
   findBySenderId(senderId) {
     return [...this.views.values()].find((entry) => entry.view.webContents.id === senderId);
   }
+  /**
+   * Point the window at the active runtime's WebUI, and keep no other view.
+   *
+   * Only views whose runtime had STOPPED were released here. A view for a
+   * running-but-background project stayed alive for the life of the app — a
+   * full Chromium renderer process each, hidden purely by setting its width to
+   * zero in `layoutViews`. Ten open projects meant ten renderer processes to
+   * show one, and memory grew with every project ever visited.
+   *
+   * Now exactly one view exists: the active one. Switching projects releases
+   * the previous view and loads the next, which costs a page load on the way
+   * back — the deliberate trade for a footprint that does not grow with how
+   * many projects are open. The shell covers that load with its own
+   * `loading` state, so the gap is visible as progress rather than as a blank
+   * window.
+   *
+   * Queued WebUI commands are not at risk: `dispatch` only ever targets
+   * `activeEntry()`, so a disposed background view cannot have had any.
+   */
   syncActive() {
     if (!this.ctx.getMainWindow()) return;
     const snapshot = this.ctx.manager.snapshot();
-    const live = new Set(snapshot.runtimes.filter((r) => r.status === "running").map((r) => r.id));
-    for (const [id, entry2] of this.views) if (!live.has(id)) this.dispose(entry2);
     const active = snapshot.runtimes.find((runtime) => runtime.id === snapshot.activeRuntimeId);
+    const keep = active?.status === "running" ? active.id : null;
+    for (const [id, entry2] of this.views) if (id !== keep) this.dispose(entry2);
     if (active?.status !== "running") {
       this.activeRuntimeId = active?.id ?? null;
       this.publishStatus({ runtimeId: active?.id ?? null, status: "idle" });
@@ -2187,7 +2281,7 @@ var DesktopWebuiController = class {
     if (this.views.get(entry.runtimeId) !== entry || !entry.url) return Promise.resolve(false);
     const requestId = `${entry.runtimeId}:${Date.now()}:${++this.commandSequence}`;
     const outbound = { ...command, requestId };
-    return new Promise((resolve4) => {
+    return new Promise((resolve5) => {
       const fallbackTimer = setTimeout(() => {
         if (!this.pendingAcks.has(requestId)) return;
         if (this.views.get(entry.runtimeId) !== entry || entry.view.webContents.isDestroyed())
@@ -2202,7 +2296,7 @@ var DesktopWebuiController = class {
         runtimeId: entry.runtimeId,
         timer,
         fallbackTimer,
-        resolve: resolve4
+        resolve: resolve5
       });
       try {
         entry.view.webContents.send(IPC.webuiCommand, outbound);
@@ -2269,6 +2363,7 @@ var DesktopWebuiController = class {
 import * as fs3 from "node:fs/promises";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 import { nativeImage } from "electron";
+var ICON_CANDIDATES = ["../../assets/icon.png", "../../assets/icon.icns"];
 async function readIcon(relativePath) {
   try {
     const iconPath = fileURLToPath2(new URL(relativePath, import.meta.url));
@@ -2280,8 +2375,11 @@ async function readIcon(relativePath) {
   }
 }
 async function loadDesktopAppIcon() {
-  if (process.platform !== "darwin") return readIcon("../../assets/icon.svg");
-  return await readIcon("../../assets/icon.png") ?? readIcon("../../assets/icon.icns");
+  for (const candidate of ICON_CANDIDATES) {
+    const icon = await readIcon(candidate);
+    if (icon) return icon;
+  }
+  return void 0;
 }
 
 // src/main/window-state-controller.ts
@@ -2754,6 +2852,94 @@ function configureApplicationMenu(ctx) {
 // src/main/ipc-handlers/index.ts
 import { ipcMain } from "electron";
 
+// src/main/session-index.ts
+import * as fs5 from "node:fs/promises";
+import * as path5 from "node:path";
+import { projectSlug as projectSlug2, wstackGlobalRoot as wstackGlobalRoot3 } from "@wrongstack/core/utils";
+var SHARD_RE = /^\d{4}-\d{2}-\d{2}$/;
+var SUMMARY_SUFFIX = ".summary.json";
+var DEFAULT_SESSION_LIMIT = 25;
+var CACHE_TTL_MS = 4e3;
+var cache = /* @__PURE__ */ new Map();
+function projectStoreDir(projectRoot) {
+  return path5.join(wstackGlobalRoot3(), "projects", projectSlug2(path5.resolve(projectRoot)));
+}
+function toEntry(raw, fallbackId, mtimeMs) {
+  if (typeof raw !== "object" || raw === null) return null;
+  const r = raw;
+  const id = typeof r.id === "string" && r.id !== "" ? r.id : fallbackId;
+  if (!id) return null;
+  const title = typeof r.title === "string" ? r.title.trim() : "";
+  const startedAt = typeof r.startedAt === "string" ? r.startedAt : new Date(mtimeMs).toISOString();
+  const lastActivityAt = typeof r.lastActivityAt === "string" ? r.lastActivityAt : typeof r.endedAt === "string" ? r.endedAt : startedAt;
+  return {
+    id,
+    // A session that never got a first user message has no title. Showing the
+    // id is better than an empty row the user cannot identify.
+    title: title || id.split("/").pop() || id,
+    startedAt,
+    lastActivityAt,
+    ...typeof r.messageCount === "number" ? { messageCount: r.messageCount } : {},
+    ...typeof r.model === "string" ? { model: r.model } : {},
+    ...typeof r.provider === "string" ? { provider: r.provider } : {}
+  };
+}
+async function listProjectSessions(projectRoot, options = {}) {
+  const limit = options.limit ?? DEFAULT_SESSION_LIMIT;
+  if (limit <= 0) return [];
+  const sessionsDir = path5.join(projectStoreDir(projectRoot), "sessions");
+  const dirStat = await fs5.stat(sessionsDir).catch(() => null);
+  if (!dirStat?.isDirectory()) return [];
+  const cached = cache.get(sessionsDir);
+  if (cached && Date.now() - cached.readAt < CACHE_TTL_MS && cached.limit >= limit) {
+    return cached.sessions.slice(0, limit);
+  }
+  let shards;
+  try {
+    const entries = await fs5.readdir(sessionsDir, { withFileTypes: true });
+    shards = entries.filter((entry) => entry.isDirectory() && SHARD_RE.test(entry.name)).map((entry) => entry.name).sort((a, b) => b.localeCompare(a));
+  } catch {
+    return [];
+  }
+  const sessions = [];
+  for (const shard of shards) {
+    if (sessions.length >= limit) break;
+    const shardDir = path5.join(sessionsDir, shard);
+    let files;
+    try {
+      files = (await fs5.readdir(shardDir)).filter((name) => name.endsWith(SUMMARY_SUFFIX));
+    } catch {
+      continue;
+    }
+    files.sort((a, b) => b.localeCompare(a));
+    for (const file of files) {
+      if (sessions.length >= limit) break;
+      const full = path5.join(shardDir, file);
+      let text;
+      let mtimeMs;
+      try {
+        const [content, stat4] = await Promise.all([fs5.readFile(full, "utf8"), fs5.stat(full)]);
+        text = content;
+        mtimeMs = stat4.mtimeMs;
+      } catch {
+        continue;
+      }
+      let parsed;
+      try {
+        parsed = JSON.parse(text);
+      } catch {
+        continue;
+      }
+      const fallbackId = `${shard}/${file.slice(0, -SUMMARY_SUFFIX.length)}`;
+      const entry = toEntry(parsed, fallbackId, mtimeMs);
+      if (entry) sessions.push(entry);
+    }
+  }
+  sessions.sort((a, b) => (b.lastActivityAt ?? "").localeCompare(a.lastActivityAt ?? ""));
+  cache.set(sessionsDir, { readAt: Date.now(), limit, sessions });
+  return sessions;
+}
+
 // src/main/validation/index.ts
 function validate(schema, data) {
   try {
@@ -2801,7 +2987,7 @@ function createValidationLogger(prefix) {
 
 // src/main/validation/schemas.ts
 import { statSync } from "node:fs";
-import * as path5 from "node:path";
+import * as path6 from "node:path";
 import { z } from "zod";
 var RUNTIME_ID_PATTERN = /^[a-zA-Z0-9._:-]{3,120}$/;
 var runtimeIdSchema = z.string().regex(RUNTIME_ID_PATTERN, "Invalid runtime ID format");
@@ -2811,7 +2997,7 @@ var projectRootSchema = pathSchema.refine((value) => !value.includes("\0"), {
 }).refine(
   (value) => {
     try {
-      return statSync(path5.resolve(value)).isDirectory();
+      return statSync(path6.resolve(value)).isDirectory();
     } catch {
       return false;
     }
@@ -2888,6 +3074,14 @@ function registerIpcHandlers(ctx) {
     return ctx.getAgentBridge().snapshot(result.data);
   });
   ipcMain.handle(IPC.getWebuiStatus, () => ctx.getWebuiStatus());
+  ipcMain.handle(IPC.listProjectSessions, async (_event, root) => {
+    const result = validate(pathSchema, root);
+    if (!result.success) {
+      validationLogger.log(`listProjectSessions: ${result.error}`);
+      return [];
+    }
+    return listProjectSessions(result.data);
+  });
   ipcMain.handle(IPC.navigateWebui, async (_event, command) => {
     return ctx.dispatchWebuiCommand(command);
   });
@@ -3059,7 +3253,7 @@ if (process.platform === "win32") {
 }
 app2.setPath(
   "userData",
-  path6.join(
+  path7.join(
     resolveWstackPaths3({ projectRoot: process.cwd() }).configDir,
     "desktop",
     "electron-profile"
@@ -3113,7 +3307,7 @@ function revealInExplorer(root) {
     if (!authorization.allowed) return;
     return shell2.openPath(root).catch((err) => {
       if (process.platform === "darwin") {
-        void shell2.openPath(path6.dirname(root)).catch(() => void 0);
+        void shell2.openPath(path7.dirname(root)).catch(() => void 0);
       }
       console.error(
         JSON.stringify({
@@ -3382,6 +3576,7 @@ async function boot() {
     void windowStateController.save().finally(() => app2.exit(0));
   });
   await restoreLastWorkspace2();
+  manager.startIdleSweep();
   const argvOpenPath = firstOpenFileArg(process.argv);
   const queuedOpenPath = drainPendingOpenFilePath();
   const openPath = argvOpenPath ?? queuedOpenPath;
@@ -3409,6 +3604,7 @@ app2.on("before-quit", () => {
   }
   bridge.closeAll();
   webuiController.disposeAll();
+  manager.stopIdleSweep();
   void manager.closeAll({ persistWorkspace: false });
 });
 app2.on("activate", () => {

package/dist/preload/preload.cjs

@@ -8,6 +8,7 @@ var IPC = {
   getState: "desktop:get-state",
   getConversation: "desktop:get-conversation",
   getWebuiStatus: "desktop:get-webui-status",
+  listProjectSessions: "desktop:list-project-sessions",
   openProject: "desktop:open-project",
   registerProject: "desktop:register-project",
   unregisterProject: "desktop:unregister-project",
@@ -47,6 +48,7 @@ var api = {
   getState: () => import_electron.ipcRenderer.invoke(IPC.getState),
   getConversation: (runtimeId) => import_electron.ipcRenderer.invoke(IPC.getConversation, runtimeId),
   getWebuiStatus: () => import_electron.ipcRenderer.invoke(IPC.getWebuiStatus),
+  listProjectSessions: (root) => import_electron.ipcRenderer.invoke(IPC.listProjectSessions, root),
   openProject: (root) => import_electron.ipcRenderer.invoke(IPC.openProject, root),
   registerProject: (root) => import_electron.ipcRenderer.invoke(IPC.registerProject, root),
   unregisterProject: (root) => import_electron.ipcRenderer.invoke(IPC.unregisterProject, root),

package/dist/preload/webui-preload.cjs

@@ -8,6 +8,7 @@ var IPC = {
   getState: "desktop:get-state",
   getConversation: "desktop:get-conversation",
   getWebuiStatus: "desktop:get-webui-status",
+  listProjectSessions: "desktop:list-project-sessions",
   openProject: "desktop:open-project",
   registerProject: "desktop:register-project",
   unregisterProject: "desktop:unregister-project",