reasonix 0.43.0 → 0.44.0

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

@@ -2,16 +2,16 @@
 import { createRequire as __cr } from 'node:module'; if (typeof globalThis.require === 'undefined') { globalThis.require = __cr(import.meta.url); }
 import {
   createMcpRuntime
-} from "./chunk-3Z6IBU3D.js";
+} from "./chunk-2V6EAEUW.js";
 import {
   buildCodeToolset
-} from "./chunk-YFGF5NKA.js";
+} from "./chunk-KGBG6M2X.js";
 import {
   Eventizer,
   autoResolveVerdict
-} from "./chunk-45U62RI3.js";
-import "./chunk-H6PS7IUE.js";
-import "./chunk-PQXPXJBJ.js";
+} from "./chunk-HNXDZGC6.js";
+import "./chunk-7UCMM425.js";
+import "./chunk-NVURFF27.js";
 import {
   CacheFirstLoop,
   ImmutablePrefix,
@@ -19,41 +19,39 @@ import {
   listFilesWithStatsAsync,
   parseAtQuery,
   rankPickerCandidates
-} from "./chunk-2R4QCDOZ.js";
-import "./chunk-F3PXYSNN.js";
-import "./chunk-FHOGSSCH.js";
-import {
-  parseMcpSpec
-} from "./chunk-6AK4EY3D.js";
+} from "./chunk-OPFUUYHL.js";
+import "./chunk-WK3UFQY3.js";
+import "./chunk-C53JQES5.js";
+import "./chunk-XSU4QVFW.js";
 import {
   MemoryStore,
   codeSystemPrompt
-} from "./chunk-5JJRUIPA.js";
+} from "./chunk-JNAQYELD.js";
 import {
   canonicalPresetName,
   resolvePreset
 } from "./chunk-2425HK6U.js";
 import {
-  countTokens
-} from "./chunk-PV55UMTO.js";
+  countTokensBounded
+} from "./chunk-6OWJV3YW.js";
 import {
   DeepSeekClient,
   pickPrimaryBalance
-} from "./chunk-2KDUS647.js";
+} from "./chunk-V26WPN3J.js";
 import "./chunk-25T6CVUP.js";
 import {
   loadDotenv
 } from "./chunk-2UQP6H6T.js";
-import "./chunk-YYQAUTTN.js";
+import "./chunk-MJ6W5UN3.js";
 import {
   pauseGate
-} from "./chunk-O52OLQL3.js";
+} from "./chunk-RDRC3XDT.js";
 import {
   SkillStore
-} from "./chunk-2K65GZBT.js";
+} from "./chunk-TEUDEGX2.js";
 import "./chunk-PLHAZOLZ.js";
-import "./chunk-XCGGEJTI.js";
-import "./chunk-7O5ALB4C.js";
+import "./chunk-4CTDEJUF.js";
+import "./chunk-7CIGMZT3.js";
 import "./chunk-S4XVGLRW.js";
 import {
   deleteSession,
@@ -63,30 +61,34 @@ import {
   patchSessionMeta,
   timestampSuffix
 } from "./chunk-6PBZN4VI.js";
-import "./chunk-RE4RAVFF.js";
+import "./chunk-R3CTO2HM.js";
+import "./chunk-ZZYBBX5N.js";
+import "./chunk-CGDR2ELH.js";
 import {
   isPlausibleKey,
   loadApiKey,
   loadBaseUrl,
+  loadDesktopOpenTabs,
   loadEditMode,
   loadEditor,
   loadPreset,
   loadReasoningEffort,
   loadRecentWorkspaces,
+  loadResolvedSkillPaths,
   loadWorkspaceDir,
+  parseMcpSpec,
   pushRecentWorkspace,
   readConfig,
   saveApiKey,
   saveBaseUrl,
+  saveDesktopOpenTabs,
   saveEditMode,
   saveEditor,
   savePreset,
   saveReasoningEffort,
   saveWorkspaceDir,
   writeConfig
-} from "./chunk-XPDVG52A.js";
-import "./chunk-HFEAY5DT.js";
-import "./chunk-YQ6NTIIE.js";
+} from "./chunk-AVFXO2EZ.js";
 import {
   VERSION
 } from "./chunk-XXC2BYTV.js";
@@ -104,6 +106,11 @@ function emit(ev, tabId) {
   writeSync(1, Buffer.from(`${JSON.stringify(payload)}
 `, "utf8"));
 }
+function tailLines(s, n) {
+  if (!s) return "";
+  const lines = s.split(/\r?\n/);
+  return lines.slice(-n).join("\n");
+}
 function buildLoadedMessages(records) {
   const out = [];
   let turn = 0;
@@ -260,15 +267,18 @@ function emitMemory(tab) {
 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));
+    const sys = countTokensBounded(tab.runtime.loop.prefix.system);
+    const tools = countTokensBounded(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 store = new SkillStore({
+      projectRoot: tab.rootDir,
+      customSkillPaths: loadResolvedSkillPaths(tab.rootDir)
+    });
     const items = store.list().map((s) => ({
       name: s.name,
       description: s.description,
@@ -392,8 +402,20 @@ function pushMentionRecent(tab, path) {
   tab.recentMentions.unshift(path);
   if (tab.recentMentions.length > MAX) tab.recentMentions.length = MAX;
 }
+function installDesktopCrashGuards(stderr = process.stderr) {
+  process.on("unhandledRejection", (reason) => {
+    const err = reason instanceof Error ? reason : new Error(String(reason));
+    stderr.write(`[desktop] unhandledRejection: ${err.stack ?? err.message}
+`);
+  });
+  process.on("uncaughtException", (err) => {
+    stderr.write(`[desktop] uncaughtException: ${err.stack ?? err.message}
+`);
+  });
+}
 async function desktopCommand(opts) {
   loadDotenv();
+  installDesktopCrashGuards();
   const tabs = /* @__PURE__ */ new Map();
   const tabContext = new AsyncLocalStorage();
   function activeRunningTab() {
@@ -434,7 +456,11 @@ async function desktopCommand(opts) {
     return tab;
   }
   async function initTabToolset(tab) {
-    const toolset = await buildCodeToolset({ rootDir: tab.rootDir });
+    const toolset = await buildCodeToolset({
+      rootDir: tab.rootDir,
+      onSkillInstalled: () => emitSkills(tab),
+      onJobsChanged: () => emitJobs()
+    });
     tab.toolset = toolset;
     tab.system = codeSystemPrompt(tab.rootDir, {
       hasSemanticSearch: toolset.semantic.enabled,
@@ -491,8 +517,14 @@ async function desktopCommand(opts) {
       emit({ type: "$error", message: `mcp bridge failed: ${err.message}` }, tab.id);
     });
   }
+  function persistOpenTabs() {
+    try {
+      saveDesktopOpenTabs(Array.from(tabs.values()).map((t) => t.rootDir));
+    } catch {
+    }
+  }
   async function closeTab(tab) {
-    tab.aborter?.abort();
+    abortTurn(tab);
     try {
       await tab.toolset?.jobs.shutdown();
     } catch {
@@ -504,6 +536,11 @@ async function desktopCommand(opts) {
       }
     }
     tabs.delete(tab.id);
+    if (first && first.id === tab.id) {
+      const next = tabs.values().next().value;
+      if (next) first = next;
+    }
+    persistOpenTabs();
     emit({ type: "$tab_closed" }, tab.id);
   }
   async function runTurn(tab, text) {
@@ -557,7 +594,7 @@ async function desktopCommand(opts) {
       emitSettings(tab);
       return;
     }
-    tab.aborter?.abort();
+    abortTurn(tab);
     try {
       await tab.toolset?.jobs.shutdown();
     } catch {
@@ -572,7 +609,11 @@ async function desktopCommand(opts) {
     tab.symbolBuilding = null;
     tab.recentMentions.length = 0;
     tab.currentSession = mintSessionFor(target);
-    tab.toolset = await buildCodeToolset({ rootDir: target });
+    tab.toolset = await buildCodeToolset({
+      rootDir: target,
+      onSkillInstalled: () => emitSkills(tab),
+      onJobsChanged: () => emitJobs()
+    });
     tab.system = codeSystemPrompt(target, {
       hasSemanticSearch: tab.toolset.semantic.enabled,
       modelId: tab.currentModel
@@ -588,6 +629,69 @@ async function desktopCommand(opts) {
     }
     return void 0;
   }
+  function abortTurn(tab) {
+    tab.aborter?.abort();
+    tab.runtime?.loop.abort();
+  }
+  function tabSessionLabel(tab) {
+    if (tab.currentSession) {
+      try {
+        const summary = loadSessionMeta(tab.currentSession).summary?.trim();
+        if (summary) return summary;
+      } catch {
+      }
+    }
+    return tab.rootDir.split(/[\\/]/).filter(Boolean).pop() ?? tab.rootDir;
+  }
+  function emitJobs() {
+    const items = [];
+    for (const t of tabs.values()) {
+      const reg = t.toolset?.jobs;
+      if (!reg) continue;
+      const label = tabSessionLabel(t);
+      for (const j of reg.list()) {
+        items.push({
+          id: j.id,
+          tabId: t.id,
+          sessionLabel: label,
+          command: j.command,
+          pid: j.pid,
+          running: j.running,
+          exitCode: j.exitCode,
+          startedAt: j.startedAt,
+          outputTail: tailLines(j.output, 8),
+          spawnError: j.spawnError
+        });
+      }
+    }
+    items.sort((a, b) => {
+      if (a.running !== b.running) return a.running ? -1 : 1;
+      return b.startedAt - a.startedAt;
+    });
+    emit({ type: "$jobs", items });
+  }
+  async function stopJob(jobId) {
+    for (const t of tabs.values()) {
+      const reg = t.toolset?.jobs;
+      if (!reg) continue;
+      const hit = reg.list().find((j) => j.id === jobId);
+      if (!hit) continue;
+      await reg.stop(jobId);
+      return true;
+    }
+    return false;
+  }
+  async function stopAllJobs() {
+    const ops = [];
+    for (const t of tabs.values()) {
+      const reg = t.toolset?.jobs;
+      if (!reg) continue;
+      for (const j of reg.list()) {
+        if (j.running) ops.push(reg.stop(j.id));
+      }
+    }
+    await Promise.allSettled(ops);
+  }
   function cancelPendingGates(tab) {
     const hadActivePlan = tab.planTotalSteps > 0 || tab.completedStepIds.size > 0;
     const ids = [...tab.pendingGateIds];
@@ -599,9 +703,21 @@ async function desktopCommand(opts) {
       emit({ type: "$plan_cleared" }, tab.id);
     }
   }
-  const first = createTabSkeleton();
-  process.once("exit", () => {
-    for (const t of tabs.values()) void t.toolset?.jobs.shutdown();
+  let first;
+  let shuttingDown = false;
+  async function gracefulShutdown() {
+    if (shuttingDown) return;
+    shuttingDown = true;
+    await Promise.allSettled(
+      [...tabs.values()].map((t) => t.toolset?.jobs.shutdown(1500) ?? Promise.resolve())
+    );
+    process.exit(0);
+  }
+  process.on("SIGTERM", () => {
+    void gracefulShutdown();
+  });
+  process.on("SIGINT", () => {
+    void gracefulShutdown();
   });
   pauseGate.on((req) => {
     const tab = activeRunningTab();
@@ -733,20 +849,37 @@ async function desktopCommand(opts) {
     if (tab) tab.pendingGateIds.delete(req.id);
     pauseGate.cancel(req.id);
   });
-  emit({ type: "$tab_opened", workspaceDir: first.rootDir }, 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);
+  function bootstrapTab(initialDir) {
+    const tab = createTabSkeleton(initialDir);
+    emit({ type: "$tab_opened", workspaceDir: tab.rootDir }, tab.id);
+    emitSessions(tab);
+    emitSettings(tab);
+    emitMcpSpecs(tab);
+    emitSkills(tab);
+    emitMemory(tab);
+    if (!loadApiKey()) emit({ type: "$needs_setup", reason: "no_api_key" }, tab.id);
+    void emitBalance(tab);
+    void initTabToolset(tab).then(() => {
+      if (loadApiKey()) emit({ type: "$ready" }, tab.id);
+      emitCtxBreakdown(tab);
+    }).catch((err) => {
+      emit({ type: "$error", message: `init failed: ${err.message}` }, tab.id);
+    });
+    return tab;
+  }
+  const savedTabDirs = opts.dir ? [] : loadDesktopOpenTabs().filter((d) => {
+    try {
+      return existsSync(d) && statSync(d).isDirectory();
+    } catch {
+      return false;
+    }
   });
+  first = bootstrapTab(savedTabDirs[0]);
+  for (const d of savedTabDirs.slice(1)) {
+    if (resolve(d) === first.rootDir) continue;
+    bootstrapTab(d);
+  }
+  persistOpenTabs();
   const rl = createInterface({ input: stdin });
   rl.on("line", (line) => {
     const trimmed = line.trim();
@@ -760,21 +893,8 @@ async function desktopCommand(opts) {
     }
     if (msg.cmd === "tab_open") {
       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);
-          emitCtxBreakdown(tab2);
-        }).catch((err) => {
-          emit({ type: "$error", message: `init failed: ${err.message}` }, tab2.id);
-        });
+        bootstrapTab(msg.workspaceDir);
+        persistOpenTabs();
       } catch (err) {
         emit({ type: "$error", message: `tab_open failed: ${err.message}` });
       }
@@ -843,13 +963,25 @@ async function desktopCommand(opts) {
       }
       return;
     }
+    if (msg.cmd === "jobs_list") {
+      emitJobs();
+      return;
+    }
+    if (msg.cmd === "jobs_stop") {
+      void stopJob(msg.jobId).finally(() => emitJobs());
+      return;
+    }
+    if (msg.cmd === "jobs_stop_all") {
+      void stopAllJobs().finally(() => emitJobs());
+      return;
+    }
     const tab = msg.tabId ? tabs.get(msg.tabId) : first;
     if (!tab) {
       emit({ type: "$error", message: `unknown tab: ${msg.tabId}` });
       return;
     }
     if (msg.cmd === "abort") {
-      tab.aborter?.abort();
+      abortTurn(tab);
       cancelPendingGates(tab);
       return;
     }
@@ -916,7 +1048,10 @@ async function desktopCommand(opts) {
         return;
       }
       try {
-        const store = new SkillStore({ projectRoot: tab.rootDir });
+        const store = new SkillStore({
+          projectRoot: tab.rootDir,
+          customSkillPaths: loadResolvedSkillPaths(tab.rootDir)
+        });
         const found = store.read(msg.name);
         if (!found) {
           emit({ type: "$error", message: `skill not found: ${msg.name}` }, tab.id);
@@ -950,7 +1085,7 @@ ${found.body}${argsLine}`;
       try {
         const records = loadSessionMessages(msg.name);
         const meta = loadSessionMeta(msg.name);
-        tab.aborter?.abort();
+        abortTurn(tab);
         cancelPendingGates(tab);
         tab.currentSession = msg.name;
         if (tab.runtime) tab.runtime = buildRuntimeFor(tab);
@@ -973,7 +1108,7 @@ ${found.body}${argsLine}`;
       return;
     }
     if (msg.cmd === "new_chat") {
-      tab.aborter?.abort();
+      abortTurn(tab);
       cancelPendingGates(tab);
       tab.currentSession = mintSessionFor(tab.rootDir);
       if (tab.runtime) tab.runtime = buildRuntimeFor(tab);
@@ -1106,9 +1241,15 @@ ${found.body}${argsLine}`;
       void runTurn(tab, msg.text);
     }
   });
-  await new Promise((resolve2) => rl.on("close", resolve2));
+  await new Promise((resolve2) => {
+    rl.on("close", () => {
+      void gracefulShutdown();
+      resolve2();
+    });
+  });
 }
 export {
-  desktopCommand
+  desktopCommand,
+  installDesktopCrashGuards
 };
-//# sourceMappingURL=desktop-Q7NDXCON.js.map
+//# sourceMappingURL=desktop-KWGR4BNE.js.map