@qwen-code/qwen-code 0.19.5 → 0.19.6-nightly.20260704.5dc2e1501

package/chunks/{acpAgent-4F36XM3X.js → acpAgent-2CMYPFHV.js}

@@ -3,13 +3,13 @@
 import {
   classifyApiError,
   prefixMidTurnUserMessageParts
-} from "./chunk-6KPZJJ6U.js";
+} from "./chunk-P2OIJOKP.js";
 import {
   EXTENSION_CONTEXT_BUDGET,
   buildExtensionMentionContext,
   matchExtensionByRef,
   parseExtensionRef
-} from "./chunk-SJVPSHXU.js";
+} from "./chunk-4OIKNWUQ.js";
 import {
   HistoryReplayer,
   MessageEmitter,
@@ -20,91 +20,78 @@ import {
   insertAfterFunctionResponses,
   isSlashCommand,
   normalizePartList
-} from "./chunk-4MCC4XHH.js";
+} from "./chunk-KBKWNEPS.js";
 import {
   appEvents,
   buildDisabledSkillNamesProvider,
   loadCliConfig,
   normalizeDisabledToolList
-} from "./chunk-EJ7BN3EN.js";
+} from "./chunk-WSOGYJMT.js";
+import {
+  collectContextData,
+  formatContextUsageText
+} from "./chunk-NGCPNXJC.js";
 import {
   getCommandSubcommandNames
-} from "./chunk-IMAMNLY6.js";
-import "./chunk-NDY7OENU.js";
+} from "./chunk-N6AGVKMC.js";
+import "./chunk-N3QDCSLP.js";
 import {
   getEffectiveSupportedModes
-} from "./chunk-UJT42DB6.js";
-import "./chunk-JZSY4WP3.js";
-import {
-  collectContextData,
-  formatContextUsageText
-} from "./chunk-WZ724G6K.js";
+} from "./chunk-5QC7Y5TJ.js";
 import {
   isTerminalGoalStatusKind
 } from "./chunk-KSPVDFE4.js";
 import "./chunk-MRO43B25.js";
-import "./chunk-5B2WNM6V.js";
 import "./chunk-VXGPYF7U.js";
-import "./chunk-XKZXGIRM.js";
+import "./chunk-HNGXPBWR.js";
 import "./chunk-KYMBIKIW.js";
 import "./chunk-HTWHAN44.js";
+import "./chunk-JZSY4WP3.js";
+import "./chunk-TE6JTKY5.js";
+import "./chunk-3GONHQOA.js";
+import "./chunk-3ZSJDRNO.js";
+import "./chunk-ZI4MGBB5.js";
 import {
   MAX_REMEMBER_CONTENT_BYTES,
   extractRememberErrorCode,
+  formatWorkspaceMemoryForgetSummary,
   isValidServerName
-} from "./chunk-RM3PGSGL.js";
+} from "./chunk-6SHO7WFF.js";
 import "./chunk-L7QPM2YD.js";
 import "./chunk-54YZOP7P.js";
-import "./chunk-2CAII5HD.js";
+import "./chunk-MWGIMAYM.js";
+import "./chunk-UPYORLKQ.js";
+import "./chunk-KHDZHZMH.js";
+import {
+  formatAcpModelId,
+  parseAcpBaseModelId,
+  parseAcpModelOption,
+  sanitizeProviderBaseUrl
+} from "./chunk-XPOO5OMB.js";
+import {
+  mapSkillConfigToStatus
+} from "./chunk-6IAWPIQ6.js";
 import {
   PERMISSION_RULE_TYPES,
   PermissionRulesValidationError,
   buildPermissionSettings,
   normalizePermissionRules,
   readPermissionRuleSet
-} from "./chunk-6QVQZAW6.js";
-import "./chunk-Y4UQT3PM.js";
+} from "./chunk-537ZUZEH.js";
+import "./chunk-QQXG2BL6.js";
 import "./chunk-NIOPRZNN.js";
 import "./chunk-AHNXYU4O.js";
 import "./chunk-RNBYOUGV.js";
-import "./chunk-HISPEX42.js";
+import "./chunk-G645A66S.js";
 import "./chunk-BJBWRCSK.js";
-import "./chunk-DRS2HTNT.js";
-import "./chunk-3GONHQOA.js";
-import "./chunk-JJ6B3ZD3.js";
+import "./chunk-U7UXWKGG.js";
+import "./chunk-6BEOH4KK.js";
+import "./chunk-S6RLAIUR.js";
+import "./chunk-MX2YXRER.js";
 import "./chunk-YHTNWGRR.js";
 import {
   createLoadedSettingsAdapter
-} from "./chunk-R3UWLLRQ.js";
-import "./chunk-JKGCBO3O.js";
-import "./chunk-KHDZHZMH.js";
-import "./chunk-RSBQS6M4.js";
-import {
-  NOT_CURRENTLY_GENERATING_CANCEL_MESSAGE
-} from "./chunk-T22H4V4R.js";
-import {
-  CLIENT_MCP_OVER_WS_CONFIG_FLAG,
-  MID_TURN_QUEUE_DRAIN_METHOD
-} from "./chunk-EWALXUAD.js";
-import "./chunk-SEZC2725.js";
-import "./chunk-ALX6BUYW.js";
-import {
-  formatAcpModelId,
-  parseAcpBaseModelId,
-  parseAcpModelOption,
-  sanitizeProviderBaseUrl
-} from "./chunk-K4I4STSL.js";
-import {
-  mapSkillConfigToStatus
-} from "./chunk-CXBG27SF.js";
-import {
-  ACP_PREFLIGHT_KINDS,
-  IDLE_HOOK_EVENTS,
-  SERVE_CONTROL_EXT_METHODS,
-  SERVE_STATUS_EXT_METHODS,
-  STATUS_SCHEMA_VERSION,
-  mapDomainErrorToErrorKind
-} from "./chunk-LHMZCIKL.js";
+} from "./chunk-KP6O77UN.js";
 import {
   OUTPUT_LANGUAGE_AUTO,
   getOutputLanguageFilePath,
@@ -115,36 +102,55 @@ import {
   resolveOutputLanguage,
   updateOutputLanguageFile,
   writeOutputLanguageAndRegisterPath
-} from "./chunk-BC4R5C5R.js";
+} from "./chunk-5WYLPENX.js";
 import {
   SUPPORTED_LANGUAGES,
   getCurrentLanguage,
   setLanguageAsync
-} from "./chunk-DM4E337C.js";
+} from "./chunk-X3UQVEBR.js";
 import "./chunk-TLRYABYP.js";
-import "./chunk-S6RLAIUR.js";
-import "./chunk-MX2YXRER.js";
-import "./chunk-7DMQRPC7.js";
+import "./chunk-4RQIB5UZ.js";
+import {
+  NOT_CURRENTLY_GENERATING_CANCEL_MESSAGE
+} from "./chunk-T22H4V4R.js";
+import {
+  CLIENT_MCP_OVER_WS_CONFIG_FLAG,
+  MID_TURN_QUEUE_DRAIN_METHOD
+} from "./chunk-EWALXUAD.js";
+import "./chunk-SEZC2725.js";
+import "./chunk-ALX6BUYW.js";
 import {
   AgentSideConnection,
   PROTOCOL_VERSION,
-  RequestError,
+  RequestError
+} from "./chunk-VRDMOSQS.js";
+import {
   ndJsonStream
-} from "./chunk-UFC57OYT.js";
-import "./chunk-PPFWEV7G.js";
+} from "./chunk-3VJ7MT3N.js";
+import {
+  ACP_PREFLIGHT_KINDS,
+  IDLE_HOOK_EVENTS,
+  SERVE_CONTROL_EXT_METHODS,
+  SERVE_STATUS_EXT_METHODS,
+  STATUS_SCHEMA_VERSION,
+  mapDomainErrorToErrorKind
+} from "./chunk-SZFYG244.js";
+import "./chunk-3RW4AZJV.js";
+import "./chunk-P2RRV2UB.js";
 import {
   isFolderTrustEnabled,
   isWorkspaceTrusted,
   loadTrustedFolders
-} from "./chunk-Z7XNVNPM.js";
-import "./chunk-Y6Z2O3WR.js";
+} from "./chunk-EMSRFDBD.js";
+import {
+  writeStderrLine
+} from "./chunk-Y6Z2O3WR.js";
 import "./chunk-QYUE6W3T.js";
 import {
   ALL_PROVIDERS,
   APPROVAL_MODE_INFO,
   BTW_MAX_INPUT_LENGTH,
   ExtensionManager,
-  FORK_SUBAGENT_TYPE,
   InvalidMcpConfigError,
   LoopTickResolver,
   MAX_TRANSCRIPT_MESSAGES,
@@ -224,6 +230,7 @@ import {
   resolveBaseUrl,
   restoreWorktreeContext,
   runForkedAgent,
+  runManagedAutoMemoryDream,
   runManagedRememberByAgent,
   runVisionBridge,
   sessionIdContext,
@@ -238,34 +245,35 @@ import {
   subagentGenerator,
   unregisterGoalHook,
   updateSetting
-} from "./chunk-6QTCOQX7.js";
+} from "./chunk-B5ZACOMA.js";
 import "./chunk-5P5XGNYH.js";
+import "./chunk-SKAZWEV5.js";
 import {
   external_exports
 } from "./chunk-K5PGHDBN.js";
-import "./chunk-SKAZWEV5.js";
+import "./chunk-CLQPBI4H.js";
 import "./chunk-QOMAHFYI.js";
 import "./chunk-G7OQ3RFJ.js";
 import "./chunk-LKWAVAB5.js";
 import {
   runSideQuery
-} from "./chunk-L7OJ3ZO3.js";
-import "./chunk-R6RI2HIC.js";
+} from "./chunk-5ES5YPED.js";
 import "./chunk-2MPVVENX.js";
 import "./chunk-ZTQ26VBE.js";
-import "./chunk-SJBIFVD2.js";
+import "./chunk-DMSNJDWG.js";
 import "./chunk-MLZQVCF3.js";
 import "./chunk-LQ7TMOCE.js";
 import "./chunk-E5A7LHNN.js";
 import {
-  APPROVAL_MODES
-} from "./chunk-BPFJQGY7.js";
+  APPROVAL_MODES,
+  FORK_SUBAGENT_TYPE
+} from "./chunk-LM3YCCZJ.js";
 import "./chunk-GO6LNQXT.js";
 import "./chunk-B236XPGF.js";
 import {
   HookEventName,
   createHookOutput
-} from "./chunk-YXK4GPYO.js";
+} from "./chunk-NVFJSIAX.js";
 import "./chunk-TOAUDIS7.js";
 import "./chunk-NPQWQYU6.js";
 import {
@@ -285,12 +293,14 @@ import {
   logPromptSuggestion,
   logToolCall,
   logUserPrompt,
+  registerAcpEventLoopLagGauge,
   runInToolSpanContext,
+  startEventLoopLagMonitor,
   startToolExecutionSpan,
   startToolSpan,
   uiTelemetryService,
   withInteractionSpan
-} from "./chunk-CHY5C5T4.js";
+} from "./chunk-TDMIHT6B.js";
 import "./chunk-E6US47KI.js";
 import "./chunk-UWCTAVOD.js";
 import "./chunk-OFEVLU4C.js";
@@ -300,11 +310,11 @@ import {
   getUserAutoMemoryRoot
 } from "./chunk-MOUXUCXQ.js";
 import "./chunk-BZHLWC6T.js";
-import "./chunk-DG573EOO.js";
+import "./chunk-RZORUN6X.js";
 import {
   ToolConfirmationOutcome,
   ToolNames
-} from "./chunk-MTNTVOJR.js";
+} from "./chunk-MJKMIQMK.js";
 import {
   clearCachedCredentialFile,
   qwenOAuth2Events
@@ -316,7 +326,7 @@ import "./chunk-SIUQ3YYX.js";
 import {
   DEFAULT_TOKEN_LIMIT,
   tokenLimit
-} from "./chunk-YTFBURQD.js";
+} from "./chunk-KYTQOCDE.js";
 import "./chunk-YPCPZSZB.js";
 import "./chunk-IRJWHZWU.js";
 import "./chunk-SYCJMSIJ.js";
@@ -332,10 +342,10 @@ import {
   getErrorStatus,
   isSubpath
 } from "./chunk-AVQDCKNF.js";
-import "./chunk-M5ITDKSM.js";
+import "./chunk-RUM2UEL3.js";
 import {
   runExitCleanup
-} from "./chunk-2YH27UNF.js";
+} from "./chunk-4YXBDLX7.js";
 import "./chunk-ZERZSAZL.js";
 import "./chunk-QN5NZ3UQ.js";
 import "./chunk-BR4QREVK.js";
@@ -1592,33 +1602,42 @@ async function buildAvailableCommandsSnapshot(config, abortSignal = AbortSignal.
     "acp",
     settings
   );
-  const availableCommands = slashCommands.map((cmd) => {
-    const acceptsInput = cmd.acceptsInput ?? (cmd.kind !== "built-in" /* BUILT_IN */ || cmd.completion != null || cmd.argumentHint != null || cmd.subCommands != null && cmd.subCommands.length > 0);
-    return {
-      name: cmd.name,
-      description: cmd.description,
-      input: acceptsInput ? { hint: cmd.argumentHint ?? "" } : null,
-      _meta: {
-        argumentHint: cmd.argumentHint,
-        source: cmd.source,
-        sourceLabel: cmd.sourceLabel,
-        supportedModes: getEffectiveSupportedModes(cmd),
-        subcommands: getCommandSubcommandNames(cmd),
-        modelInvocable: cmd.modelInvocable === true,
-        // Carry aliases so a channel consumer (which only sees the wire snapshot,
-        // not the command registry) can recognize an aliased command and avoid
-        // tagging it. _meta is ACP's extension point; omitted when there are none
-        // so command entries without aliases stay byte-identical on the wire.
-        ...cmd.altNames && cmd.altNames.length > 0 ? { altNames: cmd.altNames } : {}
-      }
-    };
+  const disabledSkillNames = config.getDisabledSkillNames();
+  const visibleSlashCommands = slashCommands.filter((cmd) => {
+    if (cmd.kind !== "skill" /* SKILL */ || !cmd.skillDetail) return true;
+    return !disabledSkillNames.has(cmd.skillDetail.name.toLowerCase());
   });
+  const availableCommands = visibleSlashCommands.map(
+    (cmd) => {
+      const acceptsInput = cmd.acceptsInput ?? (cmd.kind !== "built-in" /* BUILT_IN */ || cmd.completion != null || cmd.argumentHint != null || cmd.subCommands != null && cmd.subCommands.length > 0);
+      return {
+        name: cmd.name,
+        description: cmd.description,
+        input: acceptsInput ? { hint: cmd.argumentHint ?? "" } : null,
+        _meta: {
+          argumentHint: cmd.argumentHint,
+          source: cmd.source,
+          sourceLabel: cmd.sourceLabel,
+          supportedModes: getEffectiveSupportedModes(cmd),
+          subcommands: getCommandSubcommandNames(cmd),
+          modelInvocable: cmd.modelInvocable === true,
+          // Carry aliases so a channel consumer (which only sees the wire snapshot,
+          // not the command registry) can recognize an aliased command and avoid
+          // tagging it. _meta is ACP's extension point; omitted when there are none
+          // so command entries without aliases stay byte-identical on the wire.
+          ...cmd.altNames && cmd.altNames.length > 0 ? { altNames: cmd.altNames } : {}
+        }
+      };
+    }
+  );
   let availableSkills;
   const skillDetailsByName = /* @__PURE__ */ new Map();
   try {
     const skillManager = config.getSkillManager();
     if (skillManager) {
-      const skills = await skillManager.listSkills();
+      const skills = (await skillManager.listSkills()).filter(
+        (skill) => !disabledSkillNames.has(skill.name.toLowerCase())
+      );
       availableSkills = skills.map((skill) => skill.name);
       for (const skill of skills) {
         skillDetailsByName.set(skill.name, {
@@ -1634,7 +1653,7 @@ async function buildAvailableCommandsSnapshot(config, abortSignal = AbortSignal.
   } catch (error) {
     debugLogger5.error("Error loading available skills:", error);
   }
-  for (const command of slashCommands) {
+  for (const command of visibleSlashCommands) {
     if (command.kind !== "skill" /* SKILL */ || !command.skillDetail) {
       continue;
     }
@@ -4635,6 +4654,7 @@ ${this.pendingWorktreeNotice}
           const aborted = activeToolAbortSignal.aborted;
           const status = aborted ? "cancelled" : toolResult.error ? "error" : "success";
           const succeeded = status === "success";
+          const responseError = toolResult.error ? new Error(toolResult.error.message) : aborted ? new Error("Tool execution was cancelled") : void 0;
           if (hooksEnabledForTool && messageBusForTool && !toolResult.error && !aborted && !nestedPermissionCancelled) {
             const toolResponse = {
               llmContent: toolResult.llmContent,
@@ -4661,6 +4681,12 @@ ${this.pendingWorktreeNotice}
               const contextPart = { text: postHookResult.additionalContext };
               responseParts.push(contextPart);
             }
+            await this.emitHookArtifactsNotification({
+              hookEventName: "PostToolUse",
+              toolName,
+              toolCallId: callId,
+              artifacts: postHookResult.artifacts
+            });
           } else if (hooksEnabledForTool && messageBusForTool && (toolResult.error || aborted)) {
             const isInterrupt = aborted;
             const failureHookResult = await firePostToolUseFailureHook(
@@ -4679,6 +4705,12 @@ ${this.pendingWorktreeNotice}
                 `PostToolUseFailure hook additional context for ${toolName}: ${failureHookResult.additionalContext}`
               );
             }
+            await this.emitHookArtifactsNotification({
+              hookEventName: "PostToolUseFailure",
+              toolName,
+              toolCallId: callId,
+              artifacts: failureHookResult.artifacts
+            });
           }
           if (isTodoWriteTool) {
             const todos = this.planEmitter.extractTodos(
@@ -4689,15 +4721,15 @@ ${this.pendingWorktreeNotice}
               await this.planEmitter.emitPlan(todos ?? []);
             }
           } else {
-            const error = toolResult.error ? new Error(toolResult.error.message) : aborted ? new Error("Tool execution was cancelled") : void 0;
             await this.toolCallEmitter.emitResult({
               callId,
               toolName,
               args,
               message: responseParts,
               resultDisplay: toolResult.returnDisplay,
-              error,
-              success: succeeded
+              error: responseError,
+              success: succeeded,
+              artifacts: toolResult.artifacts
             });
           }
           const durationMs = Date.now() - startTime;
@@ -4755,6 +4787,12 @@ ${this.pendingWorktreeNotice}
                 `PostToolUseFailure hook additional context for ${toolName}: ${failureHookResult.additionalContext}`
               );
             }
+            await this.emitHookArtifactsNotification({
+              hookEventName: "PostToolUseFailure",
+              toolName,
+              toolCallId: callId,
+              artifacts: failureHookResult.artifacts
+            });
           }
           await this.toolCallEmitter.emitError(callId, toolName, error);
           const errorParts = [
@@ -4782,8 +4820,9 @@ ${this.pendingWorktreeNotice}
             toolName,
             error
           );
+          const responseParts = errorResponse(error);
           return {
-            parts: errorResponse(error),
+            parts: responseParts,
             stopAfterPermissionCancel: nestedPermissionCancelled,
             loopDetected
           };
@@ -5109,6 +5148,26 @@ ${contextPart.text}`
       debugLogger5.warn(msg);
     }
   }
+  async emitHookArtifactsNotification(args) {
+    if (!args.artifacts || args.artifacts.length === 0) {
+      return;
+    }
+    try {
+      await this.client.extNotification("qwen/notify/session/artifact-event", {
+        v: 1,
+        sessionId: this.sessionId,
+        source: "hook",
+        hookEventName: args.hookEventName,
+        toolName: args.toolName,
+        toolCallId: args.toolCallId,
+        artifacts: args.artifacts
+      });
+    } catch (error) {
+      writeStderrLine(
+        `Hook artifact notification dropped for ${args.toolName ?? args.hookEventName}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
   /**
    * Fire a notification hook and forward any terminalSequence to the ACP
    * client as an extNotification. Fire-and-forget — errors are logged at
@@ -5156,6 +5215,11 @@ function serializeAgentTask(entry, now) {
     ...optionalField("endTime", entry.endTime),
     ...optionalField("subagentType", entry.subagentType),
     isBackgrounded: entry.isBackgrounded,
+    // Nested-agent lineage for client-side tree rendering. AgentTask uses
+    // `null` parentAgentId for top-level launches — normalize to absent.
+    ...optionalField("parentAgentId", entry.parentAgentId ?? void 0),
+    ...optionalField("parentName", entry.parentName),
+    ...optionalField("depth", entry.depth),
     ...optionalField("error", entry.error),
     ...optionalField("resumeBlockedReason", entry.resumeBlockedReason),
     ...optionalField("stats", entry.stats),
@@ -5240,6 +5304,21 @@ __name(runWithAcpRuntimeOutputDir, "runWithAcpRuntimeOutputDir");
 var debugLogger6 = createDebugLogger("ACP_AGENT");
 var BTW_CHILD_TIMEOUT_MS = 55e3;
 var WORKSPACE_MEMORY_REMEMBER_CHILD_TIMEOUT_MS = 295e3;
+function createHiddenWorkspaceMemoryConfig(config) {
+  return new Proxy(config, {
+    get(target, prop) {
+      if (prop === "getChatRecordingService") {
+        return () => void 0;
+      }
+      if (prop === "getTranscriptPath") {
+        return () => "";
+      }
+      const value = Reflect.get(target, prop, target);
+      return typeof value === "function" ? value.bind(target) : value;
+    }
+  });
+}
+__name(createHiddenWorkspaceMemoryConfig, "createHiddenWorkspaceMemoryConfig");
 function collapseForkDirective(directive, maxLength) {
   const oneLine = directive.replace(/\s+/g, " ").trim();
   return oneLine.length > maxLength ? `${oneLine.slice(0, maxLength - 3)}\u2026` : oneLine;
@@ -6661,18 +6740,30 @@ async function runAcpAgent(config, settings, argv) {
     // client-hosted MCP server (#5626) round-trips over the parent WS.
     sendSdkMcpMessage: bootstrapClientMcpSender
   });
-  const stdout = Writable.toWeb(process.stdout);
-  const stdin = Readable.toWeb(process.stdin);
-  console.log = console.error;
-  console.info = console.error;
-  console.debug = console.error;
-  const stream = ndJsonStream(stdout, stdin);
+  const eventLoopMonitor = startEventLoopLagMonitor({
+    onNewMaxStall: /* @__PURE__ */ __name((maxMs) => {
+      console.error(`[perf] acp agent event loop stall: max=${maxMs}ms`);
+    }, "onNewMaxStall")
+  });
   let agentInstance;
-  const connection = new AgentSideConnection((conn) => {
-    acpConnection = conn;
-    agentInstance = new QwenAgent(config, settings, argv, conn);
-    return agentInstance;
-  }, stream);
+  let connection;
+  try {
+    const stdout = Writable.toWeb(process.stdout);
+    const stdin = Readable.toWeb(process.stdin);
+    console.log = console.error;
+    console.info = console.error;
+    console.debug = console.error;
+    const stream = ndJsonStream(stdout, stdin);
+    connection = new AgentSideConnection((conn) => {
+      acpConnection = conn;
+      agentInstance = new QwenAgent(config, settings, argv, conn);
+      return agentInstance;
+    }, stream);
+  } catch (err) {
+    eventLoopMonitor.dispose();
+    throw err;
+  }
+  registerAcpEventLoopLagGauge(() => eventLoopMonitor.snapshot());
   const drainPoolBeforeExit = /* @__PURE__ */ __name(async (label) => {
     if (!agentInstance) return;
     try {
@@ -6715,17 +6806,23 @@ async function runAcpAgent(config, settings, argv) {
     if (shuttingDown) return;
     shuttingDown = true;
     debugLogger6.debug("[ACP] Shutdown signal received, closing streams");
-    await fireSessionEndOnce("other" /* Other */);
-    agentInstance?.disposeSessions();
     try {
-      process.stdin.destroy();
-    } catch {
-    }
-    try {
-      process.stdout.destroy();
-    } catch {
+      await fireSessionEndOnce("other" /* Other */);
+      agentInstance?.disposeSessions();
+      try {
+        process.stdin.destroy();
+      } catch {
+      }
+      try {
+        process.stdout.destroy();
+      } catch {
+      }
+      await drainPoolBeforeExit("signal");
+    } catch (err) {
+      debugLogger6.error("[ACP] Shutdown error:", err);
+    } finally {
+      eventLoopMonitor.dispose();
     }
-    await drainPoolBeforeExit("signal");
     runExitCleanup().catch((err) => {
       debugLogger6.error("[ACP] Cleanup error:", err);
     }).finally(() => {
@@ -6734,12 +6831,16 @@ async function runAcpAgent(config, settings, argv) {
   }, "shutdownHandler");
   process.on("SIGTERM", shutdownHandler);
   process.on("SIGINT", shutdownHandler);
-  await connection.closed;
-  await fireSessionEndOnce("prompt_input_exit" /* PromptInputExit */);
-  await drainPoolBeforeExit("ide_close");
-  agentInstance?.disposeSessions();
-  process.off("SIGTERM", shutdownHandler);
-  process.off("SIGINT", shutdownHandler);
+  try {
+    await connection.closed;
+    await fireSessionEndOnce("prompt_input_exit" /* PromptInputExit */);
+    await drainPoolBeforeExit("ide_close");
+    agentInstance?.disposeSessions();
+  } finally {
+    process.off("SIGTERM", shutdownHandler);
+    process.off("SIGINT", shutdownHandler);
+    eventLoopMonitor.dispose();
+  }
 }
 __name(runAcpAgent, "runAcpAgent");
 function toStdioServer(server) {
@@ -7005,7 +7106,7 @@ var QwenAgent = class {
   async initialize(args) {
     this.clientCapabilities = args.clientCapabilities;
     const authMethods = buildAuthMethods();
-    const version = "0.19.5";
+    const version = "0.19.6-nightly.20260704.5dc2e1501";
     return {
       protocolVersion: PROTOCOL_VERSION,
       agentInfo: {
@@ -7878,12 +7979,13 @@ var QwenAgent = class {
       };
     }
     try {
+      const disabled = config.getDisabledSkillNames();
       const skills = await skillManager.listSkills();
       return {
         v: STATUS_SCHEMA_VERSION,
         workspaceCwd: this.workspaceCwd(config),
         initialized: true,
-        skills: skills.map(mapSkillConfigToStatus)
+        skills: skills.map((skill) => mapSkillConfigToStatus(skill, disabled))
       };
     } catch (error) {
       return {
@@ -9193,6 +9295,119 @@ var QwenAgent = class {
           );
         }
       }
+      case SERVE_CONTROL_EXT_METHODS.workspaceMemoryForget: {
+        const query = params["query"];
+        if (typeof query !== "string" || !query.trim()) {
+          throw RequestError.invalidParams(
+            void 0,
+            "Invalid or missing query"
+          );
+        }
+        const trimmedQuery = query.trim();
+        if (Buffer.byteLength(trimmedQuery, "utf8") > MAX_REMEMBER_CONTENT_BYTES) {
+          throw RequestError.invalidParams(
+            void 0,
+            "Query exceeds maximum size"
+          );
+        }
+        if (!this.config.isManagedMemoryAvailable()) {
+          throw new RequestError(
+            -32009,
+            "Managed memory is unavailable for this daemon workspace",
+            { errorKind: "managed_memory_unavailable" }
+          );
+        }
+        const childSignal = AbortSignal.timeout(
+          WORKSPACE_MEMORY_REMEMBER_CHILD_TIMEOUT_MS
+        );
+        try {
+          const projectRoot = this.config.getProjectRoot();
+          const hiddenConfig = createHiddenWorkspaceMemoryConfig(this.config);
+          const result = await this.config.getMemoryManager().forget(projectRoot, trimmedQuery, {
+            config: hiddenConfig,
+            abortSignal: childSignal
+          });
+          return {
+            summary: result.systemMessage ?? formatWorkspaceMemoryForgetSummary(result.removedEntries.length),
+            removedEntries: result.removedEntries,
+            touchedTopics: result.touchedTopics
+          };
+        } catch (err) {
+          if (err instanceof RequestError) {
+            throw err;
+          }
+          if (childSignal.aborted) {
+            throw new RequestError(
+              -32099,
+              "Workspace memory forget timed out",
+              {
+                errorKind: "forget_timeout"
+              }
+            );
+          }
+          const code = extractRememberErrorCode(err, "forget_failed");
+          if (code === "managed_memory_unavailable") {
+            throw new RequestError(
+              -32009,
+              "Managed memory is unavailable for this daemon workspace",
+              { errorKind: "managed_memory_unavailable" }
+            );
+          }
+          throw new RequestError(-32099, "Workspace memory forget failed", {
+            errorKind: code
+          });
+        }
+      }
+      case SERVE_CONTROL_EXT_METHODS.workspaceMemoryDream: {
+        if (!this.config.isManagedMemoryAvailable()) {
+          throw new RequestError(
+            -32009,
+            "Managed memory is unavailable for this daemon workspace",
+            { errorKind: "managed_memory_unavailable" }
+          );
+        }
+        const childSignal = AbortSignal.timeout(
+          WORKSPACE_MEMORY_REMEMBER_CHILD_TIMEOUT_MS
+        );
+        try {
+          const result = await runManagedAutoMemoryDream(
+            this.config.getProjectRoot(),
+            /* @__PURE__ */ new Date(),
+            createHiddenWorkspaceMemoryConfig(this.config),
+            childSignal,
+            {
+              trigger: "manual",
+              recordMetadata: true,
+              suppressChatRecording: true
+            }
+          );
+          return {
+            summary: result.systemMessage,
+            touchedTopics: result.touchedTopics,
+            dedupedEntries: result.dedupedEntries
+          };
+        } catch (err) {
+          if (err instanceof RequestError) {
+            throw err;
+          }
+          if (childSignal.aborted) {
+            throw new RequestError(-32099, "Workspace memory dream timed out", {
+              errorKind: "dream_timeout"
+            });
+          }
+          const code = extractRememberErrorCode(err, "dream_failed");
+          if (code === "managed_memory_unavailable") {
+            throw new RequestError(
+              -32009,
+              "Managed memory is unavailable for this daemon workspace",
+              { errorKind: "managed_memory_unavailable" }
+            );
+          }
+          throw new RequestError(-32099, "Workspace memory dream failed", {
+            errorKind: code
+          });
+        }
+      }
       case SERVE_CONTROL_EXT_METHODS.workspaceMcpRestart: {
         const serverName = params["serverName"];
         if (typeof serverName !== "string" || serverName.length === 0) {