reasonix 0.47.1 → 0.48.0

package/dist/cli/{desktop-EG6P5SF2.js → desktop-562OPWIU.js}

@@ -1,16 +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 {
+  QQChannel,
   createMcpRuntime
-} from "./chunk-YFP3MYMY.js";
+} from "./chunk-EMMENC4O.js";
 import {
   buildCodeToolset
-} from "./chunk-XD6P7AFH.js";
+} from "./chunk-7M4YYMKW.js";
 import {
   Eventizer,
   autoResolveVerdict
-} from "./chunk-ZXSCAODE.js";
-import "./chunk-DQ6K5ZQ7.js";
+} from "./chunk-OB4BUJBL.js";
+import "./chunk-3WGTGXO4.js";
 import "./chunk-EQATK2L2.js";
 import {
   CacheFirstLoop,
@@ -19,14 +20,15 @@ import {
   listFilesWithStatsAsync,
   parseAtQuery,
   rankPickerCandidates
-} from "./chunk-JBH5RM7X.js";
-import "./chunk-6QC5RQLE.js";
-import "./chunk-HUILPCYX.js";
+} from "./chunk-OPYALNTT.js";
+import "./chunk-5OHHAQ4W.js";
+import "./chunk-MRZG4GBF.js";
 import "./chunk-HIYTRCSW.js";
 import {
   MemoryStore,
   codeSystemPrompt
-} from "./chunk-BQ6HC66J.js";
+} from "./chunk-2QSTA2QV.js";
+import "./chunk-FEZK652I.js";
 import {
   canonicalPresetName,
   resolvePreset
@@ -37,21 +39,21 @@ import {
 import {
   DeepSeekClient,
   pickPrimaryBalance
-} from "./chunk-DWPAKZTY.js";
+} from "./chunk-TE5UIIFL.js";
 import "./chunk-25T6CVUP.js";
 import {
   loadDotenv
 } from "./chunk-2UQP6H6T.js";
-import "./chunk-KVZZ5U75.js";
+import "./chunk-V4Y732RQ.js";
 import {
   pauseGate
-} from "./chunk-TRSAHHCL.js";
+} from "./chunk-WZGNXR6E.js";
 import {
   SkillStore
 } from "./chunk-FY4S7TJZ.js";
 import "./chunk-PLHAZOLZ.js";
-import "./chunk-T5A7EY6B.js";
-import "./chunk-GH7DC2Y5.js";
+import "./chunk-HR5NBKEM.js";
+import "./chunk-NMQSUNLB.js";
 import "./chunk-S4XVGLRW.js";
 import {
   deleteSession,
@@ -62,9 +64,9 @@ import {
   sessionPath,
   timestampSuffix
 } from "./chunk-RRXUIPWG.js";
-import "./chunk-DN4B5S6Y.js";
-import "./chunk-QCFLPSPH.js";
-import "./chunk-NRQ5UP5T.js";
+import "./chunk-JMDE6IO3.js";
+import "./chunk-OG5JANQ4.js";
+import "./chunk-YW63N3ZR.js";
 import {
   describeQQAccess,
   isPlausibleKey,
@@ -92,7 +94,7 @@ import {
   saveReasoningEffort,
   saveWorkspaceDir,
   writeConfig
-} from "./chunk-6CRPCJAU.js";
+} from "./chunk-CDVSFSAK.js";
 import {
   VERSION
 } from "./chunk-XXC2BYTV.js";
@@ -172,15 +174,12 @@ function toAccess(config) {
 function loadDesktopQQState(path) {
   const config = loadQQConfig(path);
   const configured = Boolean(config.appId && config.appSecret);
-  const enabled = config.enabled === true;
   return {
     ...config,
     sandbox: config.sandbox ?? false,
-    enabled,
+    enabled: config.enabled === true,
     configured,
-    // Never true — the desktop process doesn't host a QQChannel (#1317).
-    connected: false,
-    enabledForCli: configured && enabled,
+    runtimeState: "disconnected",
     appIdPreview: toPreview(config.appId),
     access: toAccess(config)
   };
@@ -208,9 +207,32 @@ function setDesktopQQEnabled(enabled, path) {
 }
 
 // src/cli/commands/desktop.ts
+var desktopQqRuntimeSnapshot = {
+  runtimeState: "disconnected"
+};
+var STDOUT_BACKPRESSURE_WAIT = new Int32Array(new SharedArrayBuffer(4));
+function writeAllSync(fd, buffer, opts = {}) {
+  const write = opts.write ?? writeSync;
+  const wait = opts.wait ?? (() => Atomics.wait(STDOUT_BACKPRESSURE_WAIT, 0, 0, 5));
+  let offset = 0;
+  while (offset < buffer.length) {
+    let written;
+    try {
+      written = write(fd, buffer, offset, buffer.length - offset);
+    } catch (err) {
+      if (err.code === "EAGAIN") {
+        wait();
+        continue;
+      }
+      throw err;
+    }
+    if (written <= 0) throw new Error("stdout write returned 0 bytes");
+    offset += written;
+  }
+}
 function emit(ev, tabId) {
   const payload = tabId ? { ...ev, tabId } : ev;
-  writeSync(1, Buffer.from(`${JSON.stringify(payload)}
+  writeAllSync(1, Buffer.from(`${JSON.stringify(payload)}
 `, "utf8"));
 }
 function tailLines(s, n) {
@@ -287,7 +309,16 @@ function emitSettings(tab) {
   );
 }
 function emitQQSettings(tab) {
-  emit({ type: "$qq_settings", ...loadDesktopQQState() }, tab.id);
+  const base = loadDesktopQQState();
+  emit(
+    {
+      type: "$qq_settings",
+      ...base,
+      runtimeState: desktopQqRuntimeSnapshot.runtimeState,
+      lastError: desktopQqRuntimeSnapshot.lastError
+    },
+    tab.id
+  );
 }
 async function emitBalance(tab) {
   if (!tab.runtime) return;
@@ -379,7 +410,8 @@ function emitCtxBreakdown(tab) {
   try {
     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);
+    const logTokens = tab.runtime.loop.getCurrentLogTokens();
+    emit({ type: "$ctx_breakdown", reservedTokens: sys + tools, logTokens }, tab.id);
   } catch {
   }
 }
@@ -540,6 +572,319 @@ async function desktopCommand(opts) {
     const id = tabContext.getStore();
     return id ? tabs.get(id) : void 0;
   }
+  let first;
+  const qqRuntime = {
+    channel: null,
+    runtimeState: "disconnected",
+    lastError: void 0,
+    pendingGateId: null,
+    interaction: { kind: null, payload: null },
+    replyThisTurn: false
+  };
+  function currentQqSettings() {
+    const base = loadDesktopQQState();
+    return {
+      type: "$qq_settings",
+      ...base,
+      runtimeState: qqRuntime.runtimeState,
+      lastError: qqRuntime.lastError
+    };
+  }
+  function activeDesktopTab() {
+    return (lastActiveTabId ? tabs.get(lastActiveTabId) : void 0) ?? first;
+  }
+  function broadcastQQSettings() {
+    for (const tab of tabs.values()) emit(currentQqSettings(), tab.id);
+  }
+  function setQQRuntimeState(runtimeState, lastError) {
+    qqRuntime.runtimeState = runtimeState;
+    qqRuntime.lastError = lastError;
+    desktopQqRuntimeSnapshot.runtimeState = runtimeState;
+    desktopQqRuntimeSnapshot.lastError = lastError;
+    broadcastQQSettings();
+  }
+  function sendQQInfo(message) {
+    const tab = activeDesktopTab();
+    if (tab) {
+      emit(
+        {
+          type: "status",
+          id: Date.now(),
+          ts: (/* @__PURE__ */ new Date()).toISOString(),
+          turn: 0,
+          text: message
+        },
+        tab.id
+      );
+    }
+    void qqRuntime.channel?.sendResponse(message).catch((err) => {
+      const active = activeDesktopTab();
+      if (active) {
+        emit({ type: "$error", message: `qq send failed: ${err.message}` }, active.id);
+      }
+    });
+  }
+  function parseIndexedChoice(text) {
+    const rawIndex = text.match(/^(\d+)/)?.[1];
+    return rawIndex ? Number.parseInt(rawIndex, 10) - 1 : -1;
+  }
+  function parseRunPermissionChoice(text) {
+    const lower = text.toLowerCase();
+    if (lower.includes("1") || lower.includes("run")) return "run_once";
+    if (lower.includes("2") || lower.includes("always")) return "always_allow";
+    return "deny";
+  }
+  function parsePlanChoice(text) {
+    const lower = text.toLowerCase();
+    if (lower.includes("1") || lower.includes("approve")) return "approve";
+    if (lower.includes("2") || lower.includes("refine")) return "refine";
+    return "cancel";
+  }
+  function parseCheckpointChoice(text) {
+    const lower = text.toLowerCase();
+    if (lower.includes("1") || lower.includes("continue")) return "continue";
+    if (lower.includes("2") || lower.includes("revise")) return "revise";
+    return "stop";
+  }
+  function parseRevisionChoice(text) {
+    const lower = text.toLowerCase();
+    if (lower.includes("1") || lower.includes("accept")) return "accept";
+    if (lower.includes("2") || lower.includes("reject")) return "reject";
+    return "cancel";
+  }
+  function stripFollowupPrefix(text) {
+    return text.replace(
+      /^(?:\d+\s*|approve\s*|refine\s*|cancel\s*|continue\s*|revise\s*|stop\s*|accept\s*|reject\s*|run\s*|always\s*|deny\s*)/iu,
+      ""
+    ).trim();
+  }
+  function handleQQPauseReply(text) {
+    if (qqRuntime.interaction.kind === null || qqRuntime.pendingGateId === null) return false;
+    qqRuntime.replyThisTurn = true;
+    const followup = stripFollowupPrefix(text);
+    const interaction = qqRuntime.interaction;
+    qqRuntime.interaction = { kind: null, payload: null };
+    const gateId = qqRuntime.pendingGateId;
+    qqRuntime.pendingGateId = null;
+    switch (interaction.kind) {
+      case "run_command":
+      case "run_background":
+      case "path_access":
+        pauseGate.resolve(gateId, parseRunPermissionChoice(text));
+        return true;
+      case "plan_proposed": {
+        const payload = interaction.payload ?? {};
+        const choice = parsePlanChoice(text);
+        if (choice === "cancel") {
+          pauseGate.cancel(gateId);
+        } else {
+          pauseGate.resolve(gateId, {
+            type: choice === "approve" ? "approve" : "refine",
+            feedback: followup,
+            override: {
+              plan: payload.plan ?? "",
+              mode: choice === "approve" ? "approve" : "refine"
+            }
+          });
+        }
+        return true;
+      }
+      case "plan_checkpoint": {
+        const payload = interaction.payload ?? {};
+        const choice = parseCheckpointChoice(text);
+        if (choice === "revise") {
+          pauseGate.resolve(gateId, {
+            type: "revise",
+            feedback: followup,
+            checkpoint: { stepId: payload.stepId ?? "", title: payload.title }
+          });
+        } else {
+          pauseGate.resolve(gateId, { type: choice });
+        }
+        return true;
+      }
+      case "plan_revision":
+        pauseGate.resolve(gateId, parseRevisionChoice(text));
+        return true;
+      case "choice": {
+        const payload = interaction.payload ?? {};
+        const options = payload.options ?? [];
+        const pickedIndex = parseIndexedChoice(text);
+        if (pickedIndex >= 0 && pickedIndex < options.length) {
+          const selected = options[pickedIndex];
+          if (selected) pauseGate.resolve(gateId, { type: "pick", optionId: selected.id });
+          return true;
+        }
+        for (const option of options) {
+          if (text.toLowerCase().includes(option.title.toLowerCase())) {
+            pauseGate.resolve(gateId, { type: "pick", optionId: option.id });
+            return true;
+          }
+        }
+        pauseGate.resolve(
+          gateId,
+          payload.allowCustom ? { type: "text", text } : { type: "cancel" }
+        );
+        return true;
+      }
+      default:
+        return false;
+    }
+  }
+  function handleQQPauseRequest(tab, kind, payload) {
+    if (!qqRuntime.channel) return;
+    qqRuntime.interaction = { kind, payload };
+    let qqMessage = "";
+    switch (kind) {
+      case "run_command":
+      case "run_background": {
+        const p = payload;
+        qqMessage = `Need confirmation
+
+Command: \`${p.command}\`
+
+Reply with:
+1. Run once
+2. Always allow
+3. Deny`;
+        break;
+      }
+      case "path_access": {
+        const p = payload;
+        const intentText = p.intent === "read" ? "Read" : "Write";
+        qqMessage = `Need file access confirmation
+
+Action: ${intentText}
+Path: ${p.path}
+Tool: ${p.toolName}
+
+Reply with:
+1. Run once
+2. Always allow
+3. Deny`;
+        break;
+      }
+      case "plan_proposed": {
+        const p = payload;
+        qqMessage = `Plan confirmation
+
+${p.plan}
+
+Reply with:
+1. Approve
+2. Refine
+3. Cancel`;
+        break;
+      }
+      case "plan_checkpoint": {
+        const p = payload;
+        qqMessage = `Step complete (${tab.completedStepIds.size}/${tab.planTotalSteps})
+
+${p.title ? `Step: ${p.title}
+` : ""}Result: ${p.result}
+
+Reply with:
+1. Continue
+2. Revise
+3. Stop`;
+        break;
+      }
+      case "plan_revision": {
+        const p = payload;
+        qqMessage = `Plan revision proposed
+
+${p.reason}
+
+Reply with:
+1. Accept
+2. Reject
+3. Cancel`;
+        break;
+      }
+      case "choice": {
+        const p = payload;
+        const optionsList = p.options.map((opt, idx) => `${idx + 1}. ${opt.title}`).join("\n");
+        qqMessage = `Please choose
+
+${p.question}
+
+Options:
+${optionsList}${p.allowCustom ? "\n\n(You can also reply with custom text.)" : ""}`;
+        break;
+      }
+    }
+    if (qqMessage) {
+      void qqRuntime.channel.sendResponse(qqMessage).catch((err) => {
+        emit({ type: "$error", message: `qq send failed: ${err.message}` }, tab.id);
+      });
+    }
+  }
+  async function startDesktopQQ(shouldPersistEnabled = true) {
+    const current = loadQQConfig();
+    if (!(current.appId && current.appSecret)) {
+      throw new Error("QQ App ID and App Secret are required.");
+    }
+    if (qqRuntime.channel) {
+      qqRuntime.channel.refreshAccessConfig();
+      setQQRuntimeState("connected");
+      return;
+    }
+    setQQRuntimeState("connecting");
+    const channel = new QQChannel({
+      onSubmitMessage: (text) => {
+        const tab = activeDesktopTab();
+        if (!tab) return;
+        const trimmed = text.trim();
+        if (!trimmed) return;
+        emit(
+          {
+            type: "user.message",
+            id: Date.now(),
+            ts: (/* @__PURE__ */ new Date()).toISOString(),
+            turn: 0,
+            text: trimmed
+          },
+          tab.id
+        );
+        if (handleQQPauseReply(trimmed)) return;
+        if (tab.aborter) {
+          void channel.sendResponse(
+            "Session is busy. Wait for the current turn or reply to the pending prompt."
+          ).catch(() => void 0);
+          return;
+        }
+        qqRuntime.replyThisTurn = true;
+        void runTurn(tab, trimmed, true);
+      },
+      onError: (message) => {
+        const tab = activeDesktopTab();
+        setQQRuntimeState("failed", message);
+        if (tab) emit({ type: "$error", message: `QQ: ${message}` }, tab.id);
+      }
+    });
+    try {
+      await channel.start();
+      qqRuntime.channel = channel;
+      if (shouldPersistEnabled) setDesktopQQEnabled(true);
+      setQQRuntimeState("connected");
+    } catch (err) {
+      await channel.stop().catch(() => void 0);
+      qqRuntime.channel = null;
+      if (shouldPersistEnabled) setDesktopQQEnabled(false);
+      setQQRuntimeState("failed", err.message);
+      throw err;
+    }
+  }
+  async function stopDesktopQQ(shouldDisable = true) {
+    const channel = qqRuntime.channel;
+    qqRuntime.channel = null;
+    qqRuntime.interaction = { kind: null, payload: null };
+    qqRuntime.pendingGateId = null;
+    qqRuntime.replyThisTurn = false;
+    if (channel) await channel.stop();
+    if (shouldDisable) setDesktopQQEnabled(false);
+    setQQRuntimeState("disconnected");
+  }
   function createTabSkeleton(initialDir) {
     const dir = resolve(initialDir ?? opts.dir ?? loadWorkspaceDir() ?? process.cwd());
     pushRecentWorkspace(dir);
@@ -667,10 +1012,12 @@ async function desktopCommand(opts) {
     persistOpenTabs();
     emit({ type: "$tab_closed" }, tab.id);
   }
-  async function runTurn(tab, text) {
+  async function runTurn(tab, text, fromQQ = false) {
     if (!tab.runtime) return;
     const rt = tab.runtime;
     tab.aborter = new AbortController();
+    qqRuntime.replyThisTurn = fromQQ;
+    let lastAssistantText = "";
     if (tab.currentSession) {
       const existing = loadSessionMeta(tab.currentSession).summary;
       if (!existing || !existing.trim()) {
@@ -686,6 +1033,9 @@ async function desktopCommand(opts) {
     await tabContext.run(tab.id, async () => {
       try {
         for await (const ev of rt.loop.step(text)) {
+          if (ev.role === "assistant_final" && ev.content) {
+            lastAssistantText = ev.content;
+          }
           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);
@@ -696,6 +1046,12 @@ async function desktopCommand(opts) {
         emit({ type: "$error", message: err.message }, tab.id);
       } finally {
         tab.aborter = null;
+        if (fromQQ && lastAssistantText && qqRuntime.channel && qqRuntime.replyThisTurn) {
+          await qqRuntime.channel.sendResponse(lastAssistantText).catch((err) => {
+            emit({ type: "$error", message: `qq send failed: ${err.message}` }, tab.id);
+          });
+        }
+        qqRuntime.replyThisTurn = false;
         emit({ type: "$turn_complete" }, tab.id);
         if (tab.planTotalSteps > 0 && tab.completedStepIds.size >= tab.planTotalSteps) {
           tab.completedStepIds.clear();
@@ -828,11 +1184,11 @@ async function desktopCommand(opts) {
       emit({ type: "$plan_cleared" }, tab.id);
     }
   }
-  let first;
   let shuttingDown = false;
   async function gracefulShutdown() {
     if (shuttingDown) return;
     shuttingDown = true;
+    await stopDesktopQQ(false).catch(() => void 0);
     await Promise.allSettled(
       [...tabs.values()].map((t) => t.toolset?.jobs.shutdown(1500) ?? Promise.resolve())
     );
@@ -848,6 +1204,7 @@ async function desktopCommand(opts) {
     const tab = activeRunningTab();
     const tabId = tab?.id;
     if (tab) tab.pendingGateIds.add(req.id);
+    qqRuntime.pendingGateId = req.id;
     const auto = autoResolveVerdict(req, loadEditMode());
     if (auto !== null) {
       if (req.kind === "plan_checkpoint") {
@@ -874,6 +1231,7 @@ async function desktopCommand(opts) {
         { type: "$confirm_required", id: req.id, kind: req.kind, command: payload.command ?? "" },
         tabId
       );
+      if (tab) handleQQPauseRequest(tab, req.kind, payload);
       return;
     }
     if (req.kind === "path_access") {
@@ -890,6 +1248,7 @@ async function desktopCommand(opts) {
         },
         tabId
       );
+      if (tab) handleQQPauseRequest(tab, req.kind, payload);
       return;
     }
     if (req.kind === "choice") {
@@ -904,6 +1263,7 @@ async function desktopCommand(opts) {
         },
         tabId
       );
+      if (tab) handleQQPauseRequest(tab, req.kind, payload);
       return;
     }
     if (req.kind === "plan_proposed") {
@@ -922,6 +1282,7 @@ async function desktopCommand(opts) {
         },
         tabId
       );
+      if (tab) handleQQPauseRequest(tab, req.kind, payload);
       return;
     }
     if (req.kind === "plan_checkpoint") {
@@ -950,6 +1311,7 @@ async function desktopCommand(opts) {
         },
         tabId
       );
+      if (tab) handleQQPauseRequest(tab, req.kind, payload);
       return;
     }
     if (req.kind === "plan_revision") {
@@ -964,6 +1326,7 @@ async function desktopCommand(opts) {
         },
         tabId
       );
+      if (tab) handleQQPauseRequest(tab, req.kind, payload);
       return;
     }
     const exhaustive = req.kind;
@@ -1035,6 +1398,12 @@ async function desktopCommand(opts) {
   const activeIdx = savedTabs.findIndex((t) => t.active);
   lastActiveTabId = ((activeIdx >= 0 ? restored[activeIdx] : first) ?? first).id;
   persistOpenTabs();
+  const qqConfig = loadQQConfig();
+  if (qqConfig.enabled && qqConfig.appId && qqConfig.appSecret) {
+    void startDesktopQQ(false).catch(() => void 0);
+  } else {
+    broadcastQQSettings();
+  }
   const rl = createInterface({ input: stdin });
   rl.on("line", (line) => {
     const trimmed = line.trim();
@@ -1126,6 +1495,25 @@ async function desktopCommand(opts) {
       }
       return;
     }
+    if (msg.cmd === "desktop_resync") {
+      const hasKey = !!loadApiKey();
+      for (const t of tabs.values()) {
+        emit(
+          { type: "$tab_opened", workspaceDir: t.rootDir, active: t.id === lastActiveTabId },
+          t.id
+        );
+        emitSessions(t);
+        emitSettings(t);
+        emitMcpSpecs(t);
+        emitSkills(t);
+        emitMemory(t);
+        emitQQSettings(t);
+        if (!hasKey) emit({ type: "$needs_setup", reason: "no_api_key" }, t.id);
+        else if (t.toolset) emit({ type: "$ready" }, t.id);
+        void emitBalance(t);
+      }
+      return;
+    }
     if (msg.cmd === "jobs_list") {
       emitJobs();
       return;
@@ -1367,18 +1755,38 @@ ${found.body}${argsLine}`;
     if (msg.cmd === "qq_connect") {
       try {
         const current = loadQQConfig();
-        setDesktopQQEnabled(true);
         emit(
           {
             type: "status",
             id: Date.now(),
             ts: (/* @__PURE__ */ new Date()).toISOString(),
             turn: 0,
-            text: `QQ enabled for CLI (${current.sandbox ? "sandbox" : "production"}) \u2014 start the bot by running \`reasonix\` in a terminal`
+            text: `QQ connecting (${current.sandbox ? "sandbox" : "production"})`
           },
           tab.id
         );
-        emitQQSettings(tab);
+        void startDesktopQQ(true).then(
+          () => {
+            emit(
+              {
+                type: "status",
+                id: Date.now(),
+                ts: (/* @__PURE__ */ new Date()).toISOString(),
+                turn: 0,
+                text: `QQ connected (${current.sandbox ? "sandbox" : "production"})`
+              },
+              tab.id
+            );
+            emitQQSettings(tab);
+          },
+          (err) => {
+            emit(
+              { type: "$error", message: `qq_connect failed: ${err.message}` },
+              tab.id
+            );
+            emitQQSettings(tab);
+          }
+        );
       } catch (err) {
         emit({ type: "$error", message: `qq_connect failed: ${err.message}` }, tab.id);
         emitQQSettings(tab);
@@ -1387,18 +1795,27 @@ ${found.body}${argsLine}`;
     }
     if (msg.cmd === "qq_disconnect") {
       try {
-        setDesktopQQEnabled(false);
-        emit(
-          {
-            type: "status",
-            id: Date.now(),
-            ts: (/* @__PURE__ */ new Date()).toISOString(),
-            turn: 0,
-            text: "QQ disabled for CLI (next `reasonix` terminal session won't auto-start the bot)"
+        void stopDesktopQQ(true).then(
+          () => {
+            emit(
+              {
+                type: "status",
+                id: Date.now(),
+                ts: (/* @__PURE__ */ new Date()).toISOString(),
+                turn: 0,
+                text: "QQ disabled"
+              },
+              tab.id
+            );
+            emitQQSettings(tab);
           },
-          tab.id
+          (err) => {
+            emit(
+              { type: "$error", message: `qq_disconnect failed: ${err.message}` },
+              tab.id
+            );
+          }
         );
-        emitQQSettings(tab);
       } catch (err) {
         emit(
           { type: "$error", message: `qq_disconnect failed: ${err.message}` },
@@ -1481,7 +1898,7 @@ ${found.body}${argsLine}`;
     }
     if (msg.cmd === "compact_history") {
       if (!tab.runtime) return;
-      void tab.runtime.loop.compactHistory().catch((err) => {
+      void tab.runtime.loop.compactHistory().then(() => emitCtxBreakdown(tab)).catch((err) => {
         emit({ type: "$error", message: `/compact failed: ${err.message}` }, tab.id);
       });
       return;
@@ -1535,6 +1952,7 @@ ${found.body}${argsLine}`;
 }
 export {
   desktopCommand,
-  installDesktopCrashGuards
+  installDesktopCrashGuards,
+  writeAllSync
 };
-//# sourceMappingURL=desktop-EG6P5SF2.js.map
+//# sourceMappingURL=desktop-562OPWIU.js.map