reasonix 0.40.0 → 0.43.0

package/dist/cli/{desktop-6OLENOOO.js → desktop-Q7NDXCON.js}

@@ -1,13 +1,17 @@
 #!/usr/bin/env node
+import { createRequire as __cr } from 'node:module'; if (typeof globalThis.require === 'undefined') { globalThis.require = __cr(import.meta.url); }
+import {
+  createMcpRuntime
+} from "./chunk-3Z6IBU3D.js";
 import {
   buildCodeToolset
-} from "./chunk-AVB3WZWU.js";
-import "./chunk-ULBW7DYL.js";
+} from "./chunk-YFGF5NKA.js";
 import {
   Eventizer,
   autoResolveVerdict
-} from "./chunk-VLNRQMCI.js";
-import "./chunk-RFX7TYVV.js";
+} from "./chunk-45U62RI3.js";
+import "./chunk-H6PS7IUE.js";
+import "./chunk-PQXPXJBJ.js";
 import {
   CacheFirstLoop,
   ImmutablePrefix,
@@ -15,32 +19,42 @@ import {
   listFilesWithStatsAsync,
   parseAtQuery,
   rankPickerCandidates
-} from "./chunk-4YV2GBYG.js";
-import "./chunk-XJLZ4HKU.js";
-import "./chunk-HCC42PEI.js";
-import "./chunk-XHQIK7B6.js";
+} from "./chunk-2R4QCDOZ.js";
+import "./chunk-F3PXYSNN.js";
+import "./chunk-FHOGSSCH.js";
+import {
+  parseMcpSpec
+} from "./chunk-6AK4EY3D.js";
 import {
+  MemoryStore,
   codeSystemPrompt
-} from "./chunk-R4YTW7PR.js";
+} from "./chunk-5JJRUIPA.js";
 import {
   canonicalPresetName,
   resolvePreset
-} from "./chunk-E46ECXJD.js";
-import "./chunk-DAEAAVDF.js";
+} from "./chunk-2425HK6U.js";
 import {
-  DeepSeekClient
-} from "./chunk-KMWKGPFZ.js";
+  countTokens
+} from "./chunk-PV55UMTO.js";
+import {
+  DeepSeekClient,
+  pickPrimaryBalance
+} from "./chunk-2KDUS647.js";
+import "./chunk-25T6CVUP.js";
 import {
   loadDotenv
-} from "./chunk-3Q3C4W66.js";
+} from "./chunk-2UQP6H6T.js";
+import "./chunk-YYQAUTTN.js";
 import {
   pauseGate
-} from "./chunk-SZH34P45.js";
-import "./chunk-7DLHHBGN.js";
-import "./chunk-FM57FNPJ.js";
-import "./chunk-CLAN6PVH.js";
-import "./chunk-FFNOMR32.js";
-import "./chunk-5X7LZJDE.js";
+} from "./chunk-O52OLQL3.js";
+import {
+  SkillStore
+} from "./chunk-2K65GZBT.js";
+import "./chunk-PLHAZOLZ.js";
+import "./chunk-XCGGEJTI.js";
+import "./chunk-7O5ALB4C.js";
+import "./chunk-S4XVGLRW.js";
 import {
   deleteSession,
   listSessionsForWorkspace,
@@ -48,8 +62,8 @@ import {
   loadSessionMeta,
   patchSessionMeta,
   timestampSuffix
-} from "./chunk-XST7BSZJ.js";
-import "./chunk-H7PHYVPM.js";
+} from "./chunk-6PBZN4VI.js";
+import "./chunk-RE4RAVFF.js";
 import {
   isPlausibleKey,
   loadApiKey,
@@ -61,19 +75,22 @@ import {
   loadRecentWorkspaces,
   loadWorkspaceDir,
   pushRecentWorkspace,
+  readConfig,
   saveApiKey,
   saveBaseUrl,
   saveEditMode,
   saveEditor,
   savePreset,
   saveReasoningEffort,
-  saveWorkspaceDir
-} from "./chunk-CZSJILQP.js";
-import "./chunk-ZTLZO42A.js";
-import "./chunk-ORM6PK57.js";
+  saveWorkspaceDir,
+  writeConfig
+} from "./chunk-XPDVG52A.js";
+import "./chunk-HFEAY5DT.js";
+import "./chunk-YQ6NTIIE.js";
 import {
   VERSION
-} from "./chunk-CRPQUBP6.js";
+} from "./chunk-XXC2BYTV.js";
+import "./chunk-TUK7OWJA.js";
 
 // src/cli/commands/desktop.ts
 import { AsyncLocalStorage } from "async_hooks";
@@ -158,8 +175,9 @@ function emitSettings(tab) {
 async function emitBalance(tab) {
   if (!tab.runtime) return;
   const bal = await tab.runtime.loop.client.getBalance().catch(() => null);
-  if (!bal || !bal.balance_infos.length) return;
-  const primary = bal.balance_infos[0];
+  if (!bal) return;
+  const primary = pickPrimaryBalance(bal.balance_infos);
+  if (!primary) return;
   emit(
     {
       type: "$balance",
@@ -175,13 +193,95 @@ function emitSessions(tab) {
     const items = listSessionsForWorkspace(tab.rootDir).map((s) => ({
       name: s.name,
       messageCount: s.messageCount,
-      mtime: s.mtime.toISOString()
+      mtime: s.mtime.toISOString(),
+      summary: s.meta.summary
     }));
     emit({ type: "$sessions", items }, tab.id);
   } catch (err) {
     emit({ type: "$error", message: `session_list failed: ${err.message}` }, tab.id);
   }
 }
+function summarizeMcpSpec(raw) {
+  try {
+    const parsed = parseMcpSpec(raw);
+    if (parsed.transport === "stdio") {
+      const argv = [parsed.command, ...parsed.args].join(" ");
+      return {
+        raw,
+        name: parsed.name,
+        transport: "stdio",
+        summary: `stdio \xB7 ${argv}`,
+        status: "configured"
+      };
+    }
+    return {
+      raw,
+      name: parsed.name,
+      transport: parsed.transport,
+      summary: `${parsed.transport} \xB7 ${parsed.url}`,
+      status: "configured"
+    };
+  } catch (err) {
+    return {
+      raw,
+      name: null,
+      transport: "stdio",
+      summary: raw,
+      parseError: err.message,
+      status: "failed",
+      statusReason: err.message
+    };
+  }
+}
+function emitMcpSpecs(tab) {
+  const cfg = readConfig();
+  const specs = (cfg.mcp ?? []).map((raw) => {
+    const base = summarizeMcpSpec(raw);
+    const live = tab.mcpStatuses.get(raw);
+    if (!live) return base;
+    return { ...base, status: live.kind, statusReason: live.reason, toolCount: live.toolCount };
+  });
+  const bridged = specs.length > 0 && specs.every((s) => s.status === "connected");
+  emit({ type: "$mcp_specs", specs, bridged }, tab.id);
+}
+function emitMemory(tab) {
+  try {
+    const store = new MemoryStore({ projectRoot: tab.rootDir });
+    const entries = store.list().map((e) => ({
+      name: e.name,
+      scope: e.scope,
+      description: e.description
+    }));
+    emit({ type: "$memory", entries }, tab.id);
+  } catch (err) {
+    emit({ type: "$error", message: `memory_get failed: ${err.message}` }, tab.id);
+  }
+}
+function emitCtxBreakdown(tab) {
+  if (!tab.runtime) return;
+  try {
+    const sys = countTokens(tab.runtime.loop.prefix.system);
+    const tools = countTokens(JSON.stringify(tab.runtime.loop.prefix.toolSpecs));
+    emit({ type: "$ctx_breakdown", reservedTokens: sys + tools }, tab.id);
+  } catch {
+  }
+}
+function emitSkills(tab) {
+  try {
+    const store = new SkillStore({ projectRoot: tab.rootDir });
+    const items = store.list().map((s) => ({
+      name: s.name,
+      description: s.description,
+      scope: s.scope,
+      path: s.path,
+      runAs: s.runAs,
+      model: s.model
+    }));
+    emit({ type: "$skills", items }, tab.id);
+  } catch (err) {
+    emit({ type: "$error", message: `skills_get failed: ${err.message}` }, tab.id);
+  }
+}
 var tabCounter = 0;
 function nextTabId() {
   tabCounter++;
@@ -196,27 +296,35 @@ function mintSessionFor(rootDir) {
   return name;
 }
 function buildRuntimeFor(tab) {
+  if (!tab.toolset) throw new Error("buildRuntimeFor called before initTabToolset finished");
+  const toolset = tab.toolset;
   const client = new DeepSeekClient({ baseUrl: loadBaseUrl() });
-  const prefix = new ImmutablePrefix({ system: tab.system, toolSpecs: tab.toolset.tools.specs() });
+  const prefix = new ImmutablePrefix({ system: tab.system, toolSpecs: toolset.tools.specs() });
+  const reasoningEffort = loadReasoningEffort();
+  const { autoEscalate } = resolvePreset(tab.currentPreset);
   const loop = new CacheFirstLoop({
     client,
     prefix,
-    tools: tab.toolset.tools,
+    tools: toolset.tools,
     model: tab.currentModel,
     budgetUsd: tab.budgetUsd,
-    session: tab.currentSession
+    session: tab.currentSession,
+    reasoningEffort,
+    autoEscalate
   });
-  const reasoningEffort = loadReasoningEffort();
   const eventizer = new Eventizer();
   const ctx = { model: tab.currentModel, prefixHash: prefix.fingerprint, reasoningEffort };
   return { loop, eventizer, ctx };
 }
 var TS_EXPORT_RE = /^export\s+(?:default\s+)?(?:async\s+)?(function|class|const|let|var|interface|type|enum)\s+\*?\s*(\w+)/;
+var FILE_INDEX_TTL_MS = 1e4;
 async function getFileIndexFor(tab) {
-  if (tab.fileIndex) return tab.fileIndex;
+  const fresh = tab.fileIndex && Date.now() - tab.fileIndexBuiltAt < FILE_INDEX_TTL_MS;
+  if (fresh) return tab.fileIndex;
   if (tab.fileIndexBuilding) return tab.fileIndexBuilding;
   tab.fileIndexBuilding = listFilesWithStatsAsync(tab.rootDir, { maxResults: 5e3 }).then((res) => {
     tab.fileIndex = res;
+    tab.fileIndexBuiltAt = Date.now();
     tab.fileIndexBuilding = null;
     return res;
   }).catch((err) => {
@@ -292,17 +400,12 @@ async function desktopCommand(opts) {
     const id = tabContext.getStore();
     return id ? tabs.get(id) : void 0;
   }
-  async function createTab(initialDir) {
+  function createTabSkeleton(initialDir) {
     const dir = resolve(initialDir ?? opts.dir ?? loadWorkspaceDir() ?? process.cwd());
     pushRecentWorkspace(dir);
     const preset = canonicalPresetName(loadPreset());
     const resolved = resolvePreset(preset);
     const model = opts.model || resolved.model;
-    const toolset = await buildCodeToolset({ rootDir: dir });
-    const system = codeSystemPrompt(dir, {
-      hasSemanticSearch: toolset.semantic.enabled,
-      modelId: model
-    });
     const tab = {
       id: nextTabId(),
       rootDir: dir,
@@ -310,33 +413,96 @@ async function desktopCommand(opts) {
       currentPreset: preset,
       currentModel: model,
       budgetUsd: opts.budgetUsd,
-      toolset,
-      system,
+      toolset: null,
+      system: "",
       runtime: null,
       aborter: null,
       fileIndex: null,
       fileIndexBuilding: null,
+      fileIndexBuiltAt: 0,
       symbolIndex: null,
       symbolBuilding: null,
       recentMentions: [],
       pendingGateIds: /* @__PURE__ */ new Set(),
       completedStepIds: /* @__PURE__ */ new Set(),
-      planTotalSteps: 0
+      planTotalSteps: 0,
+      mcpRuntime: null,
+      mcpStatuses: /* @__PURE__ */ new Map()
     };
     tab.currentSession = mintSessionFor(dir);
+    tabs.set(tab.id, tab);
+    return tab;
+  }
+  async function initTabToolset(tab) {
+    const toolset = await buildCodeToolset({ rootDir: tab.rootDir });
+    tab.toolset = toolset;
+    tab.system = codeSystemPrompt(tab.rootDir, {
+      hasSemanticSearch: toolset.semantic.enabled,
+      modelId: tab.currentModel
+    });
     if (loadApiKey()) {
       process.env.DEEPSEEK_API_KEY = loadApiKey();
       tab.runtime = buildRuntimeFor(tab);
+      void bridgeTabMcp(tab);
     }
-    tabs.set(tab.id, tab);
-    return tab;
+  }
+  function bridgeTabMcp(tab) {
+    if (!tab.runtime || !tab.toolset) return Promise.resolve();
+    if (tab.mcpRuntime) {
+      return tab.mcpRuntime.reloadFromConfig(tab.runtime.loop).then(() => emitMcpSpecs(tab)).catch((err) => {
+        emit({ type: "$error", message: `mcp reload failed: ${err.message}` }, tab.id);
+      });
+    }
+    const requested = (readConfig().mcp ?? []).length;
+    if (requested === 0) return Promise.resolve();
+    const runtime = createMcpRuntime({
+      getTools: () => {
+        if (!tab.toolset) throw new Error("toolset gone");
+        return tab.toolset.tools;
+      },
+      getMcpPrefix: () => void 0,
+      getRequestedCount: () => requested,
+      progressSink: { current: null }
+    });
+    tab.mcpRuntime = runtime;
+    runtime.setLifecycleSink((notice) => {
+      if (notice.kind === "slow") return;
+      const cfg = readConfig().mcp ?? [];
+      const target = cfg.find((raw) => {
+        try {
+          return parseMcpSpec(raw).name === notice.name;
+        } catch {
+          return false;
+        }
+      });
+      if (!target) return;
+      if (notice.kind === "handshake") {
+        tab.mcpStatuses.set(target, { kind: "handshake" });
+      } else if (notice.kind === "connected") {
+        tab.mcpStatuses.set(target, { kind: "connected", toolCount: notice.tools });
+      } else if (notice.kind === "failed") {
+        tab.mcpStatuses.set(target, { kind: "failed", reason: notice.reason });
+      } else if (notice.kind === "disabled") {
+        tab.mcpStatuses.set(target, { kind: "disabled" });
+      }
+      emitMcpSpecs(tab);
+    });
+    return runtime.reloadFromConfig(tab.runtime.loop).then(() => void 0).catch((err) => {
+      emit({ type: "$error", message: `mcp bridge failed: ${err.message}` }, tab.id);
+    });
   }
   async function closeTab(tab) {
     tab.aborter?.abort();
     try {
-      await tab.toolset.jobs.shutdown();
+      await tab.toolset?.jobs.shutdown();
     } catch {
     }
+    if (tab.mcpRuntime) {
+      try {
+        await tab.mcpRuntime.closeAll();
+      } catch {
+      }
+    }
     tabs.delete(tab.id);
     emit({ type: "$tab_closed" }, tab.id);
   }
@@ -344,10 +510,25 @@ async function desktopCommand(opts) {
     if (!tab.runtime) return;
     const rt = tab.runtime;
     tab.aborter = new AbortController();
+    if (tab.currentSession) {
+      const existing = loadSessionMeta(tab.currentSession).summary;
+      if (!existing || !existing.trim()) {
+        const summary = text.replace(/\s+/g, " ").trim().slice(0, 60);
+        if (summary) {
+          try {
+            patchSessionMeta(tab.currentSession, { summary });
+          } catch {
+          }
+        }
+      }
+    }
     await tabContext.run(tab.id, async () => {
       try {
         for await (const ev of rt.loop.step(text)) {
           for (const kev of rt.eventizer.consume(ev, rt.ctx)) emit(kev, tab.id);
+          if (ev.role === "tool" && (ev.toolName === "remember" || ev.toolName === "forget")) {
+            emitMemory(tab);
+          }
           if (tab.aborter?.signal.aborted) break;
         }
       } catch (err) {
@@ -378,7 +559,7 @@ async function desktopCommand(opts) {
     }
     tab.aborter?.abort();
     try {
-      await tab.toolset.jobs.shutdown();
+      await tab.toolset?.jobs.shutdown();
     } catch {
     }
     tab.rootDir = target;
@@ -386,6 +567,7 @@ async function desktopCommand(opts) {
     pushRecentWorkspace(target);
     tab.fileIndex = null;
     tab.fileIndexBuilding = null;
+    tab.fileIndexBuiltAt = 0;
     tab.symbolIndex = null;
     tab.symbolBuilding = null;
     tab.recentMentions.length = 0;
@@ -398,6 +580,7 @@ async function desktopCommand(opts) {
     if (tab.runtime) tab.runtime = buildRuntimeFor(tab);
     emitSessions(tab);
     emitSettings(tab);
+    emitSkills(tab);
   }
   function forgetGate(id) {
     for (const t of tabs.values()) {
@@ -416,9 +599,9 @@ async function desktopCommand(opts) {
       emit({ type: "$plan_cleared" }, tab.id);
     }
   }
-  const first = await createTab();
+  const first = createTabSkeleton();
   process.once("exit", () => {
-    for (const t of tabs.values()) void t.toolset.jobs.shutdown();
+    for (const t of tabs.values()) void t.toolset?.jobs.shutdown();
   });
   pauseGate.on((req) => {
     const tab = activeRunningTab();
@@ -452,6 +635,22 @@ async function desktopCommand(opts) {
       );
       return;
     }
+    if (req.kind === "path_access") {
+      const payload = req.payload;
+      emit(
+        {
+          type: "$path_access_required",
+          id: req.id,
+          path: payload.path,
+          intent: payload.intent,
+          toolName: payload.toolName,
+          sandboxRoot: payload.sandboxRoot,
+          allowPrefix: payload.allowPrefix
+        },
+        tabId
+      );
+      return;
+    }
     if (req.kind === "choice") {
       const payload = req.payload;
       emit(
@@ -526,13 +725,28 @@ async function desktopCommand(opts) {
       );
       return;
     }
+    const exhaustive = req.kind;
+    process.stderr.write(
+      `[desktop] no handler for pause kind "${String(exhaustive)}" \u2014 auto-cancelling gate id=${req.id}
+`
+    );
+    if (tab) tab.pendingGateIds.delete(req.id);
+    pauseGate.cancel(req.id);
   });
   emit({ type: "$tab_opened", workspaceDir: first.rootDir }, first.id);
-  if (loadApiKey()) emit({ type: "$ready" }, first.id);
-  else emit({ type: "$needs_setup", reason: "no_api_key" }, first.id);
   emitSessions(first);
   emitSettings(first);
+  emitMcpSpecs(first);
+  emitSkills(first);
+  emitMemory(first);
+  if (!loadApiKey()) emit({ type: "$needs_setup", reason: "no_api_key" }, first.id);
   void emitBalance(first);
+  void initTabToolset(first).then(() => {
+    if (loadApiKey()) emit({ type: "$ready" }, first.id);
+    emitCtxBreakdown(first);
+  }).catch((err) => {
+    emit({ type: "$error", message: `init failed: ${err.message}` }, first.id);
+  });
   const rl = createInterface({ input: stdin });
   rl.on("line", (line) => {
     const trimmed = line.trim();
@@ -545,19 +759,25 @@ async function desktopCommand(opts) {
       return;
     }
     if (msg.cmd === "tab_open") {
-      void (async () => {
-        try {
-          const tab2 = await createTab(msg.workspaceDir);
-          emit({ type: "$tab_opened", workspaceDir: tab2.rootDir }, tab2.id);
+      try {
+        const tab2 = createTabSkeleton(msg.workspaceDir);
+        emit({ type: "$tab_opened", workspaceDir: tab2.rootDir }, tab2.id);
+        emitSessions(tab2);
+        emitSettings(tab2);
+        emitMcpSpecs(tab2);
+        emitSkills(tab2);
+        emitMemory(tab2);
+        if (!loadApiKey()) emit({ type: "$needs_setup", reason: "no_api_key" }, tab2.id);
+        void emitBalance(tab2);
+        void initTabToolset(tab2).then(() => {
           if (loadApiKey()) emit({ type: "$ready" }, tab2.id);
-          else emit({ type: "$needs_setup", reason: "no_api_key" }, tab2.id);
-          emitSessions(tab2);
-          emitSettings(tab2);
-          void emitBalance(tab2);
-        } catch (err) {
-          emit({ type: "$error", message: `tab_open failed: ${err.message}` });
-        }
-      })();
+          emitCtxBreakdown(tab2);
+        }).catch((err) => {
+          emit({ type: "$error", message: `init failed: ${err.message}` }, tab2.id);
+        });
+      } catch (err) {
+        emit({ type: "$error", message: `tab_open failed: ${err.message}` });
+      }
       return;
     }
     if (msg.cmd === "confirm_response") {
@@ -608,6 +828,11 @@ async function desktopCommand(opts) {
         saveApiKey(key);
         process.env.DEEPSEEK_API_KEY = key;
         for (const tab2 of tabs.values()) {
+          if (!tab2.toolset) {
+            emitSettings(tab2);
+            void emitBalance(tab2);
+            continue;
+          }
           tab2.runtime = buildRuntimeFor(tab2);
           emit({ type: "$ready" }, tab2.id);
           emitSettings(tab2);
@@ -632,6 +857,86 @@ async function desktopCommand(opts) {
       void closeTab(tab);
       return;
     }
+    if (msg.cmd === "mcp_specs_get") {
+      emitMcpSpecs(tab);
+      return;
+    }
+    if (msg.cmd === "mcp_specs_add") {
+      const spec = msg.spec.trim();
+      if (!spec) {
+        emit({ type: "$error", message: "mcp_specs_add: spec is empty" }, tab.id);
+        return;
+      }
+      try {
+        parseMcpSpec(spec);
+      } catch (err) {
+        emit({ type: "$error", message: `mcp_specs_add: ${err.message}` }, tab.id);
+        return;
+      }
+      try {
+        const cfg = readConfig();
+        const list = cfg.mcp ?? [];
+        if (!list.includes(spec)) {
+          cfg.mcp = [...list, spec];
+          writeConfig(cfg);
+        }
+        emitMcpSpecs(tab);
+        void bridgeTabMcp(tab);
+      } catch (err) {
+        emit({ type: "$error", message: `mcp_specs_add: ${err.message}` }, tab.id);
+      }
+      return;
+    }
+    if (msg.cmd === "mcp_specs_remove") {
+      try {
+        const cfg = readConfig();
+        const list = cfg.mcp ?? [];
+        if (list.includes(msg.spec)) {
+          cfg.mcp = list.filter((s) => s !== msg.spec);
+          writeConfig(cfg);
+        }
+        tab.mcpStatuses.delete(msg.spec);
+        emitMcpSpecs(tab);
+        void bridgeTabMcp(tab);
+      } catch (err) {
+        emit({ type: "$error", message: `mcp_specs_remove: ${err.message}` }, tab.id);
+      }
+      return;
+    }
+    if (msg.cmd === "skills_get") {
+      emitSkills(tab);
+      return;
+    }
+    if (msg.cmd === "skill_run") {
+      if (!tab.runtime) {
+        emit(
+          { type: "$error", message: "Not configured yet \u2014 paste your DeepSeek API key first." },
+          tab.id
+        );
+        return;
+      }
+      try {
+        const store = new SkillStore({ projectRoot: tab.rootDir });
+        const found = store.read(msg.name);
+        if (!found) {
+          emit({ type: "$error", message: `skill not found: ${msg.name}` }, tab.id);
+          return;
+        }
+        const extra = msg.args?.trim() ?? "";
+        const header = `# Skill: ${found.name}${found.description ? `
+> ${found.description}` : ""}`;
+        const argsLine = extra ? `
+
+Arguments: ${extra}` : "";
+        const payload = `${header}
+
+${found.body}${argsLine}`;
+        void runTurn(tab, payload);
+      } catch (err) {
+        emit({ type: "$error", message: `skill_run: ${err.message}` }, tab.id);
+      }
+      return;
+    }
     if (msg.cmd === "session_list") {
       emitSessions(tab);
       return;
@@ -701,12 +1006,13 @@ async function desktopCommand(opts) {
           const resolved = resolvePreset(tab.currentPreset);
           tab.currentModel = resolved.model;
           savePreset(tab.currentPreset);
-          saveReasoningEffort(resolved.reasoningEffort);
-          tab.system = codeSystemPrompt(tab.rootDir, {
-            hasSemanticSearch: tab.toolset.semantic.enabled,
-            modelId: tab.currentModel
-          });
-          if (tab.runtime) tab.runtime = buildRuntimeFor(tab);
+          if (tab.toolset) {
+            tab.system = codeSystemPrompt(tab.rootDir, {
+              hasSemanticSearch: tab.toolset.semantic.enabled,
+              modelId: tab.currentModel
+            });
+            if (tab.runtime) tab.runtime = buildRuntimeFor(tab);
+          }
         }
         emitSettings(tab);
       } catch (err) {
@@ -721,7 +1027,8 @@ async function desktopCommand(opts) {
       const nonce = msg.nonce;
       const query = msg.query;
       const parsed = parseAtQuery(query);
-      if (parsed.trailingSlash) {
+      const treeWalk = parsed.trailingSlash || query.length === 0;
+      if (treeWalk) {
         void listDirectory(tab.rootDir, parsed.dir).then((entries) => {
           const results = entries.map((e) => e.isDir ? `${e.path}/` : e.path);
           emit({ type: "$mention_results", nonce, query, results }, tab.id);
@@ -804,4 +1111,4 @@ async function desktopCommand(opts) {
 export {
   desktopCommand
 };
-//# sourceMappingURL=desktop-6OLENOOO.js.map
+//# sourceMappingURL=desktop-Q7NDXCON.js.map