@qwen-code/qwen-code 0.18.1-nightly.20260616.a68b2e1e7 → 0.18.1-preview.1

package/chunks/{serve-Y5E4LKUI.js → serve-CQF2R7SG.js}

@@ -22,6 +22,7 @@ import {
   InvalidSessionMetadataError,
   InvalidSessionScopeError,
   MAX_WORKSPACE_PATH_LENGTH,
+  MID_TURN_QUEUE_DRAIN_METHOD,
   McpServerNotFoundError,
   McpServerRestartFailedError,
   MissingCliEntryError,
@@ -65,7 +66,7 @@ import {
   loadSettings,
   mapDomainErrorToErrorKind,
   reloadEnvironment
-} from "./chunk-ABRZC6FA.js";
+} from "./chunk-BRU4Z5BG.js";
 import {
   ClientSideConnection,
   PROTOCOL_VERSION,
@@ -76,7 +77,7 @@ import {
   SUPPORTED_LANGUAGES,
   writeStderrLine,
   writeStdoutLine
-} from "./chunk-UOB6KPGG.js";
+} from "./chunk-R53CLQY7.js";
 import {
   ALL_PROVIDERS,
   APPROVAL_MODES,
@@ -107,9 +108,9 @@ import {
   resolveBaseUrl,
   shouldShowStep,
   writeWorkspaceContextFile
-} from "./chunk-H4ZDM3N6.js";
+} from "./chunk-UKLVRIWE.js";
 import "./chunk-K5PGHDBN.js";
-import "./chunk-VXHYMZXW.js";
+import "./chunk-VIEIRAK3.js";
 import "./chunk-O4PICXES.js";
 import "./chunk-TW522KN6.js";
 import "./chunk-BJ5HQ23U.js";
@@ -153,14 +154,14 @@ import {
   resolveTelemetrySettings,
   shutdownTelemetry,
   withDaemonRequestSpan
-} from "./chunk-A3OEZT2F.js";
+} from "./chunk-L6F7VZPZ.js";
 import "./chunk-3PJXIDKI.js";
 import "./chunk-UWCTAVOD.js";
 import "./chunk-OFEVLU4C.js";
 import "./chunk-IQHSD7K5.js";
 import "./chunk-LYRSMKLS.js";
-import "./chunk-26QELEL2.js";
-import "./chunk-6WPY6ES3.js";
+import "./chunk-RTTAC5VW.js";
+import "./chunk-ZNUMXPNK.js";
 import {
   QwenOAuth2Client,
   QwenOAuthPollError,
@@ -17129,9 +17130,6 @@ var MultiClientPermissionMediator = class {
   }
 };
 
-// packages/acp-bridge/src/bridgeTypes.ts
-init_esbuild_shims();
-
 // packages/acp-bridge/src/bridgeOptions.ts
 init_esbuild_shims();
 
@@ -17409,6 +17407,7 @@ function sliceLineRange(content, startLine, endLine) {
   return content.slice(offset, end > offset ? end - 1 : end);
 }
 __name(sliceLineRange, "sliceLineRange");
+var MID_TURN_MESSAGE_INJECTED_EVENT = "mid_turn_message_injected";
 var BridgeClient = class {
   constructor(resolveEntry, resolvePendingRestoreEvents, mediator, permissionTimeoutMs, maxPendingPerSession, fileSystem, onModelPromoted, onModePromoted) {
     this.resolveEntry = resolveEntry;
@@ -17551,6 +17550,49 @@ var BridgeClient = class {
    * call and exits on settle (success or failure).
    */
   inFlightRestoreIds = /* @__PURE__ */ new Set();
+  /**
+   * Handle child->bridge ACP `extMethod` requests (calls that expect a
+   * response, unlike `extNotification`). The only method served today is
+   * `craft/drainMidTurnQueue`: the ACP child calls it between tool batches to
+   * pull any messages the browser queued mid-turn. We splice the per-session
+   * queue, return them to the child as the response, and — when non-empty —
+   * publish a `mid_turn_message_injected` SSE frame so the browser can move
+   * those messages out of its pending queue (a dedupe signal, not a transcript
+   * render). Unknown methods reject with ACP `methodNotFound` (-32601), matching
+   * the SDK's
+   * default for an unimplemented client surface; the child's drain caller
+   * treats that as "drain unsupported" and stops asking.
+   */
+  async extMethod(method, params) {
+    if (method !== MID_TURN_QUEUE_DRAIN_METHOD) {
+      throw RequestError.methodNotFound(method);
+    }
+    const sessionId = typeof params["sessionId"] === "string" ? params["sessionId"] : void 0;
+    if (!sessionId) return { messages: [] };
+    const entry = this.resolveEntry(sessionId);
+    if (!entry) return { messages: [] };
+    const drained = entry.midTurnMessageQueue.splice(0);
+    const messages = drained.map((item) => item.text);
+    if (drained.length > 0) {
+      const byOriginator = /* @__PURE__ */ new Map();
+      for (const item of drained) {
+        const group = byOriginator.get(item.originatorClientId);
+        if (group) group.push(item.text);
+        else byOriginator.set(item.originatorClientId, [item.text]);
+      }
+      for (const [originatorClientId, texts] of byOriginator) {
+        const published = entry.events.publish({
+          type: MID_TURN_MESSAGE_INJECTED_EVENT,
+          data: { sessionId: entry.sessionId, messages: texts },
+          ...originatorClientId ? { originatorClientId } : {}
+        });
+        writeStderrLine2(
+          published ? `[mid-turn] session=${entry.sessionId} drained=${texts.length}${originatorClientId ? ` originator=${originatorClientId}` : ""} injected into running turn` : `[mid-turn] session=${entry.sessionId} drained=${texts.length} echo frame dropped (bus closed); browser may resend next turn`
+        );
+      }
+    }
+    return { messages };
+  }
   /**
    * Handle child->bridge ACP `extNotification` calls. Six methods are
    * recognized — `qwen/notify/session/model-update`,
@@ -18540,6 +18582,7 @@ var SESSION_RECAP_TIMEOUT_MS = 6e4;
 var SESSION_BTW_TIMEOUT_MS = 6e4;
 var SHELL_COMMAND_TIMEOUT_MS = 12e4;
 var MAX_SHELL_OUTPUT_FOR_HISTORY = 1e4;
+var MAX_MID_TURN_QUEUE_DEPTH = 20;
 var DEFAULT_MAX_SESSIONS = 20;
 var DEFAULT_MAX_PENDING_PROMPTS_PER_SESSION = 5;
 var MAX_EVENT_RING_SIZE = 1e6;
@@ -19263,6 +19306,7 @@ function createAcpSessionBridge(opts) {
       events,
       promptQueue: Promise.resolve(),
       pendingPromptCount: 0,
+      midTurnMessageQueue: [],
       modelChangeQueue: Promise.resolve(),
       approvalModeQueue: Promise.resolve(),
       modelPublishGeneration: 0,
@@ -19566,6 +19610,37 @@ function createAcpSessionBridge(opts) {
   __name(closeSessionImpl, "closeSessionImpl");
   startSessionReaper();
   return {
+    getDaemonStatusSnapshot() {
+      return {
+        limits: {
+          maxSessions: maxSessions === Infinity ? null : maxSessions,
+          maxPendingPromptsPerSession: maxPendingPromptsPerSession === Infinity ? null : maxPendingPromptsPerSession,
+          eventRingSize,
+          channelIdleTimeoutMs: resolvedChannelIdleTimeoutMs(),
+          sessionIdleTimeoutMs
+        },
+        sessionCount: byId.size,
+        pendingPermissionCount: permissionMediator.pendingCount,
+        channelLive: !!liveChannelInfo(),
+        permissionPolicy: permissionMediator.policy,
+        sessions: [...byId.values()].map((entry) => ({
+          sessionId: entry.sessionId,
+          workspaceCwd: entry.workspaceCwd,
+          createdAt: entry.createdAt,
+          ...entry.displayName ? { displayName: entry.displayName } : {},
+          clientCount: entry.clientIds.size,
+          subscriberCount: entry.events.subscriberCount,
+          attachCount: entry.attachCount,
+          pendingPromptCount: entry.pendingPromptCount,
+          pendingPermissionCount: entry.pendingPermissionIds.size,
+          hasActivePrompt: entry.promptActive,
+          lastEventId: entry.events.lastEventId,
+          ...entry.sessionLastSeenAt !== void 0 ? { lastSeenAt: entry.sessionLastSeenAt } : {},
+          ...entry.currentModelId ? { currentModelId: entry.currentModelId } : {},
+          ...entry.currentApprovalMode ? { currentApprovalMode: entry.currentApprovalMode } : {}
+        }))
+      };
+    },
     get sessionCount() {
       return byId.size;
     },
@@ -19840,7 +19915,15 @@ function createAcpSessionBridge(opts) {
         () => void 0,
         () => void 0
       );
-      result.finally(releasePromptSlot).catch(() => {
+      result.finally(() => {
+        releasePromptSlot();
+        if (entry.pendingPromptCount === 0 && entry.midTurnMessageQueue.length > 0) {
+          writeStderrLine2(
+            `[mid-turn] session=${entry.sessionId} dropped ${entry.midTurnMessageQueue.length} undrained message(s) at idle; browser resends next turn`
+          );
+          entry.midTurnMessageQueue.length = 0;
+        }
+      }).catch(() => {
       });
       return result;
     },
@@ -20545,6 +20628,29 @@ function createAcpSessionBridge(opts) {
         recap: response.recap ?? null
       };
     },
+    enqueueMidTurnMessage(sessionId, message, context) {
+      const entry = byId.get(sessionId);
+      if (!entry) throw new SessionNotFoundError(sessionId);
+      const originatorClientId = resolveTrustedClientId(
+        entry,
+        context?.clientId
+      );
+      const trimmed = message.trim();
+      if (trimmed.length === 0 || entry.pendingPromptCount === 0) {
+        writeStderrLine2(
+          `[mid-turn] session=${entry.sessionId} rejected: ${trimmed.length === 0 ? "empty message" : "session idle"}; browser keeps it for next turn`
+        );
+        return { accepted: false };
+      }
+      if (entry.midTurnMessageQueue.length >= MAX_MID_TURN_QUEUE_DEPTH) {
+        writeStderrLine2(
+          `[mid-turn] session=${entry.sessionId} rejected: queue full (depth ${entry.midTurnMessageQueue.length} >= ${MAX_MID_TURN_QUEUE_DEPTH}); browser keeps it for next turn`
+        );
+        return { accepted: false };
+      }
+      entry.midTurnMessageQueue.push({ text: trimmed, originatorClientId });
+      return { accepted: true };
+    },
     async generateSessionBtw(sessionId, question, signal, _context) {
       const entry = byId.get(sessionId);
       if (!entry) throw new SessionNotFoundError(sessionId);
@@ -25222,6 +25328,43 @@ var AcpConnection = class {
     }
     return binding;
   }
+  getDiagnostic() {
+    const liveStreams = /* @__PURE__ */ new Set();
+    if (this.connStream && !this.connStream.isClosed) {
+      liveStreams.add(this.connStream);
+    }
+    let sessionStreams = 0;
+    let bufferedSessionFrames = 0;
+    for (const binding of this.sessions.values()) {
+      bufferedSessionFrames += binding.buffer.length;
+      if (binding.stream && !binding.stream.isClosed) {
+        sessionStreams += 1;
+        liveStreams.add(binding.stream);
+      }
+    }
+    let sseStreams = 0;
+    let wsStreams = 0;
+    for (const stream of liveStreams) {
+      if (stream.kind === "sse") sseStreams += 1;
+      if (stream.kind === "ws") wsStreams += 1;
+    }
+    return {
+      connectionIdPrefix: this.connectionId.slice(0, 8),
+      fromLoopback: this.fromLoopback,
+      destroyed: this.destroyed,
+      lastActiveMs: this.lastActiveMs,
+      ownedSessionCount: this.ownedSessions.size,
+      sessionBindingCount: this.sessions.size,
+      closingSessionCount: this.closingSessions.size,
+      pendingClientRequests: this.pending.size,
+      connectionStreamOpen: this.connStream !== void 0 && !this.connStream.isClosed,
+      sessionStreams,
+      sseStreams,
+      wsStreams,
+      bufferedConnectionFrames: this.connBuffer.length,
+      bufferedSessionFrames
+    };
+  }
   /** Send a frame on the connection-scoped stream (buffer until it attaches). */
   sendConn(frame) {
     if (this.connStream && !this.connStream.isClosed) {
@@ -25403,6 +25546,24 @@ var ConnectionRegistry = class {
   get connectionCap() {
     return this.maxConnections;
   }
+  getSnapshot() {
+    const connections = [...this.byId.values()].map(
+      (conn) => conn.getDiagnostic()
+    );
+    return {
+      connectionCount: this.byId.size,
+      connectionCap: this.maxConnections > 0 && Number.isFinite(this.maxConnections) ? this.maxConnections : null,
+      connectionStreams: connections.filter((conn) => conn.connectionStreamOpen).length,
+      sessionStreams: sumBy(connections, (conn) => conn.sessionStreams),
+      sseStreams: sumBy(connections, (conn) => conn.sseStreams),
+      wsStreams: sumBy(connections, (conn) => conn.wsStreams),
+      pendingClientRequests: sumBy(
+        connections,
+        (conn) => conn.pendingClientRequests
+      ),
+      connections
+    };
+  }
   dispose() {
     clearInterval(this.sweepTimer);
     for (const id of [...this.byId.keys()]) this.delete(id);
@@ -25418,6 +25579,12 @@ var ConnectionRegistry = class {
     }
   }
 };
+function sumBy(values, select) {
+  let total = 0;
+  for (const value of values) total += select(value);
+  return total;
+}
+__name(sumBy, "sumBy");
 
 // packages/cli/src/serve/acpHttp/sseStream.ts
 init_esbuild_shims();
@@ -25430,6 +25597,7 @@ var SseStream = class {
   static {
     __name(this, "SseStream");
   }
+  kind = "sse";
   writeChain = Promise.resolve();
   heartbeat;
   closed = false;
@@ -25576,6 +25744,7 @@ var WsStream = class {
   static {
     __name(this, "WsStream");
   }
+  kind = "ws";
   writeChain = Promise.resolve();
   _closed = false;
   heartbeat;
@@ -26170,6 +26339,439 @@ function isLoopbackReq(req) {
 }
 __name(isLoopbackReq, "isLoopbackReq");
 
+// packages/cli/src/serve/daemonStatus.ts
+init_esbuild_shims();
+var DEFAULT_LISTENER_MAX_CONNECTIONS = 256;
+var SECTION_TIMEOUT_MS = 1e3;
+var CAPACITY_WARNING_RATIO = 0.8;
+var SectionTimeoutError = class extends Error {
+  constructor(section, timeoutMs) {
+    super(`${section} status timed out after ${timeoutMs}ms`);
+    this.section = section;
+    this.timeoutMs = timeoutMs;
+    this.name = "SectionTimeoutError";
+  }
+  static {
+    __name(this, "SectionTimeoutError");
+  }
+};
+function parseDaemonStatusDetail(raw) {
+  if (raw === void 0) return { ok: true, detail: "summary" };
+  if (raw === "summary" || raw === "full") {
+    return { ok: true, detail: raw };
+  }
+  return { ok: false };
+}
+__name(parseDaemonStatusDetail, "parseDaemonStatusDetail");
+async function buildDaemonStatusResponse(detail, input) {
+  const bridgeSnapshot = input.bridge.getDaemonStatusSnapshot();
+  const acpSnapshot = input.acpHandle?.registry.getSnapshot();
+  const rateLimitHits = input.rateLimiter?.getHitCounts() ?? zeroRateHits();
+  const issues = [];
+  let full;
+  pushRuntimeIssues(issues, bridgeSnapshot, acpSnapshot, rateLimitHits, input);
+  if (detail === "full") {
+    full = await buildFullStatus(input, bridgeSnapshot, acpSnapshot);
+    pushFullIssues(issues, full);
+  }
+  return {
+    v: 1,
+    detail,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    status: rollupStatus(issues),
+    issues,
+    daemon: {
+      pid: process.pid,
+      uptimeMs: Math.round(process.uptime() * 1e3),
+      mode: input.opts.mode,
+      workspaceCwd: input.boundWorkspace,
+      ...input.qwenCodeVersion ? { qwenCodeVersion: input.qwenCodeVersion } : {},
+      ...input.daemonLog?.getDaemonId() ? { daemonId: input.daemonLog.getDaemonId() } : {},
+      ...detail === "full" && input.daemonLog?.getLogPath() ? { logPath: input.daemonLog.getLogPath() } : {}
+    },
+    security: {
+      tokenConfigured: Boolean(input.opts.token),
+      requireAuth: input.opts.requireAuth === true,
+      loopbackBind: isLoopbackBind(input.opts.hostname),
+      allowOriginConfigured: input.opts.allowOrigins !== void 0 && input.opts.allowOrigins.length > 0,
+      allowOriginMode: allowOriginMode(input.opts.allowOrigins),
+      sessionShellCommandEnabled: input.sessionShellCommandEnabled
+    },
+    limits: {
+      maxSessions: bridgeSnapshot.limits.maxSessions,
+      maxPendingPromptsPerSession: bridgeSnapshot.limits.maxPendingPromptsPerSession,
+      listenerMaxConnections: listenerMaxConnections(input.opts.maxConnections),
+      eventRingSize: bridgeSnapshot.limits.eventRingSize,
+      promptDeadlineMs: positiveFiniteOrNull(input.opts.promptDeadlineMs),
+      writerIdleTimeoutMs: positiveFiniteOrNull(input.opts.writerIdleTimeoutMs),
+      channelIdleTimeoutMs: bridgeSnapshot.limits.channelIdleTimeoutMs,
+      sessionIdleTimeoutMs: bridgeSnapshot.limits.sessionIdleTimeoutMs,
+      acpConnectionCap: acpSnapshot?.connectionCap ?? null
+    },
+    capabilities: {
+      protocolVersions: input.protocolVersions,
+      features: [...input.features]
+    },
+    runtime: {
+      sessions: { active: bridgeSnapshot.sessionCount },
+      permissions: {
+        pending: bridgeSnapshot.pendingPermissionCount,
+        policy: bridgeSnapshot.permissionPolicy
+      },
+      channel: { live: bridgeSnapshot.channelLive },
+      transport: {
+        restSseActive: input.getRestSseActive(),
+        acp: {
+          enabled: acpSnapshot !== void 0,
+          connections: acpSnapshot?.connectionCount ?? 0,
+          connectionStreams: acpSnapshot?.connectionStreams ?? 0,
+          sessionStreams: acpSnapshot?.sessionStreams ?? 0,
+          sseStreams: acpSnapshot?.sseStreams ?? 0,
+          wsStreams: acpSnapshot?.wsStreams ?? 0,
+          pendingClientRequests: acpSnapshot?.pendingClientRequests ?? 0
+        }
+      },
+      rateLimit: {
+        enabled: input.opts.rateLimit === true,
+        rejectedSinceStart: rateLimitHits
+      },
+      process: process.memoryUsage()
+    },
+    ...full ? { full } : {}
+  };
+}
+__name(buildDaemonStatusResponse, "buildDaemonStatusResponse");
+async function buildFullStatus(input, bridgeSnapshot, acpSnapshot) {
+  const ctx = {
+    route: "GET /daemon/status",
+    workspaceCwd: input.boundWorkspace
+  };
+  const [mcp, skills, tools, providers, env, preflight, hooks, extensions] = await Promise.all([
+    collectSection(
+      "workspace.mcp",
+      () => input.workspace.getWorkspaceMcpStatus(ctx)
+    ),
+    collectSection(
+      "workspace.skills",
+      () => input.workspace.getWorkspaceSkillsStatus(ctx)
+    ),
+    collectSection(
+      "workspace.tools",
+      () => input.bridge.getWorkspaceToolsStatus()
+    ),
+    collectSection(
+      "workspace.providers",
+      () => input.workspace.getWorkspaceProvidersStatus(ctx)
+    ),
+    collectSection(
+      "workspace.env",
+      () => input.workspace.getWorkspaceEnvStatus(ctx)
+    ),
+    collectSection(
+      "workspace.preflight",
+      () => input.workspace.getWorkspacePreflightStatus(ctx)
+    ),
+    collectSection(
+      "workspace.hooks",
+      () => input.workspace.getWorkspaceHooksStatus(ctx)
+    ),
+    collectSection(
+      "workspace.extensions",
+      () => input.workspace.getWorkspaceExtensionsStatus(ctx)
+    )
+  ]);
+  return {
+    sessions: bridgeSnapshot.sessions,
+    acpConnections: acpSnapshot?.connections ?? [],
+    workspace: {
+      mcp,
+      skills,
+      tools,
+      providers,
+      env,
+      preflight,
+      hooks,
+      extensions
+    },
+    auth: {
+      supportedDeviceFlowProviders: [...input.supportedDeviceFlowProviders],
+      pendingDeviceFlowCount: input.deviceFlowRegistry.listPending().length
+    }
+  };
+}
+__name(buildFullStatus, "buildFullStatus");
+async function collectSection(name, read) {
+  const startMs = Date.now();
+  try {
+    const data = await withTimeout2(read(), name, SECTION_TIMEOUT_MS);
+    return {
+      status: inferSectionStatus(data),
+      durationMs: Date.now() - startMs,
+      summary: summarizeStatusData(data),
+      data
+    };
+  } catch (err) {
+    return {
+      status: "unavailable",
+      durationMs: Date.now() - startMs,
+      error: {
+        kind: err instanceof SectionTimeoutError ? "timeout" : "error",
+        message: err instanceof Error ? err.message : String(err)
+      }
+    };
+  }
+}
+__name(collectSection, "collectSection");
+async function withTimeout2(promise, section, timeoutMs) {
+  let timer;
+  try {
+    return await Promise.race([
+      promise,
+      new Promise((_resolve, reject) => {
+        timer = setTimeout(
+          () => reject(new SectionTimeoutError(section, timeoutMs)),
+          timeoutMs
+        );
+      })
+    ]);
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+__name(withTimeout2, "withTimeout");
+function pushRuntimeIssues(issues, bridgeSnapshot, acpSnapshot, rateLimitHits, input) {
+  if (bridgeSnapshot.limits.maxSessions !== null && bridgeSnapshot.limits.maxSessions > 0 && bridgeSnapshot.sessionCount / bridgeSnapshot.limits.maxSessions >= CAPACITY_WARNING_RATIO) {
+    issues.push({
+      code: "session_capacity_high",
+      severity: "warning",
+      message: `Active sessions are at ${bridgeSnapshot.sessionCount}/${bridgeSnapshot.limits.maxSessions}.`
+    });
+  }
+  if (acpSnapshot !== void 0 && acpSnapshot.connectionCap !== null && acpSnapshot.connectionCap > 0 && acpSnapshot.connectionCount / acpSnapshot.connectionCap >= CAPACITY_WARNING_RATIO) {
+    issues.push({
+      code: "connection_capacity_high",
+      severity: "warning",
+      message: `ACP connections are at ${acpSnapshot.connectionCount}/${acpSnapshot.connectionCap}.`
+    });
+  }
+  if (bridgeSnapshot.pendingPermissionCount > 0) {
+    issues.push({
+      code: "pending_permissions",
+      severity: "warning",
+      message: `${bridgeSnapshot.pendingPermissionCount} permission request(s) are pending.`
+    });
+  }
+  if (bridgeSnapshot.sessionCount > 0 && !bridgeSnapshot.channelLive) {
+    issues.push({
+      code: "acp_channel_down",
+      severity: "error",
+      message: "Active sessions exist but the ACP channel is not live."
+    });
+  }
+  if (input.opts.rateLimit === true && sumRateHits(rateLimitHits) > 0) {
+    issues.push({
+      code: "rate_limit_hits",
+      severity: "warning",
+      message: `${sumRateHits(rateLimitHits)} request(s) have been rejected by rate limiting since start.`
+    });
+  }
+}
+__name(pushRuntimeIssues, "pushRuntimeIssues");
+function pushFullIssues(issues, full) {
+  for (const [name, section] of Object.entries(full.workspace)) {
+    if (section.status === "unavailable") {
+      issues.push({
+        code: "workspace_status_unavailable",
+        severity: "warning",
+        section: name,
+        message: `${name} status is unavailable.`
+      });
+    }
+  }
+  const preflight = full.workspace["preflight"];
+  if (preflight && sectionHasStatus(preflight, "error")) {
+    issues.push({
+      code: "preflight_error",
+      severity: "error",
+      section: "preflight",
+      message: "Workspace preflight reports an error."
+    });
+  }
+  const mcp = full.workspace["mcp"];
+  const mcpBudget = mcp ? inspectMcpBudget(mcp) : void 0;
+  if (mcpBudget === "exhausted") {
+    issues.push({
+      code: "mcp_budget_exhausted",
+      severity: "error",
+      section: "mcp",
+      message: "MCP client budget is exhausted."
+    });
+  } else if (mcpBudget === "warning") {
+    issues.push({
+      code: "mcp_budget_warning",
+      severity: "warning",
+      section: "mcp",
+      message: "MCP client budget is near capacity."
+    });
+  }
+}
+__name(pushFullIssues, "pushFullIssues");
+function inferSectionStatus(data) {
+  const statuses = collectStatuses(data);
+  if (statuses.includes("error")) return "error";
+  if (statuses.includes("warning")) return "warning";
+  return "ok";
+}
+__name(inferSectionStatus, "inferSectionStatus");
+function summarizeStatusData(data) {
+  const summary = {};
+  if (!isRecord(data)) return summary;
+  copyBoolean(data, summary, "initialized");
+  copyBoolean(data, summary, "acpChannelLive");
+  copyString(data, summary, "discoveryState");
+  copyString(data, summary, "budgetMode");
+  copyNumber(data, summary, "clientCount");
+  copyNumber(data, summary, "clientBudget");
+  for (const key of [
+    "cells",
+    "errors",
+    "servers",
+    "budgets",
+    "skills",
+    "tools",
+    "providers",
+    "hooks",
+    "extensions"
+  ]) {
+    const value = data[key];
+    if (Array.isArray(value)) {
+      summary[`${key}Count`] = value.length;
+    }
+  }
+  return summary;
+}
+__name(summarizeStatusData, "summarizeStatusData");
+function collectStatuses(data) {
+  const statuses = [];
+  visitStatusContainers(data, (record) => {
+    const status = record["status"];
+    if (typeof status === "string") statuses.push(status);
+  });
+  return statuses;
+}
+__name(collectStatuses, "collectStatuses");
+function sectionHasStatus(section, status) {
+  return collectStatuses(section.data).includes(status);
+}
+__name(sectionHasStatus, "sectionHasStatus");
+function inspectMcpBudget(section) {
+  const data = section.data;
+  if (!isRecord(data)) return void 0;
+  const budgetIssue = inspectBudgetContainers(data);
+  if (budgetIssue) return budgetIssue;
+  const clientCount = numberValue(data["clientCount"]);
+  const clientBudget = numberValue(data["clientBudget"]);
+  if (clientCount !== void 0 && clientBudget !== void 0 && clientBudget > 0) {
+    const ratio = clientCount / clientBudget;
+    if (ratio >= 1) return "exhausted";
+    if (ratio >= 0.75) return "warning";
+  }
+  return void 0;
+}
+__name(inspectMcpBudget, "inspectMcpBudget");
+function inspectBudgetContainers(data) {
+  let result;
+  visitStatusContainers(data, (record) => {
+    if (result === "exhausted") return;
+    const errorKind = record["errorKind"];
+    const disabledReason = record["disabledReason"];
+    const status = record["status"];
+    const kind = record["kind"];
+    const refusedCount = numberValue(record["refusedCount"]);
+    if (errorKind === "budget_exhausted" || disabledReason === "budget" || kind === "mcp_budget" && status === "error" || refusedCount !== void 0 && refusedCount > 0) {
+      result = "exhausted";
+      return;
+    }
+    if (kind === "mcp_budget" && status === "warning") {
+      result = "warning";
+    }
+  });
+  return result;
+}
+__name(inspectBudgetContainers, "inspectBudgetContainers");
+function visitStatusContainers(data, visit) {
+  if (!isRecord(data)) return;
+  visit(data);
+  for (const key of [
+    "cells",
+    "errors",
+    "servers",
+    "budgets",
+    "skills",
+    "tools",
+    "providers",
+    "hooks",
+    "extensions"
+  ]) {
+    const value = data[key];
+    if (!Array.isArray(value)) continue;
+    for (const item of value) visitStatusContainers(item, visit);
+  }
+}
+__name(visitStatusContainers, "visitStatusContainers");
+function rollupStatus(issues) {
+  if (issues.some((issue) => issue.severity === "error")) return "error";
+  if (issues.length > 0) return "warning";
+  return "ok";
+}
+__name(rollupStatus, "rollupStatus");
+function allowOriginMode(allowOrigins) {
+  if (!allowOrigins || allowOrigins.length === 0) return "none";
+  return allowOrigins.includes("*") ? "any" : "specific";
+}
+__name(allowOriginMode, "allowOriginMode");
+function listenerMaxConnections(value) {
+  if (value === void 0) return DEFAULT_LISTENER_MAX_CONNECTIONS;
+  if (value === 0 || value === Infinity) return null;
+  return Number.isFinite(value) && value > 0 ? value : null;
+}
+__name(listenerMaxConnections, "listenerMaxConnections");
+function positiveFiniteOrNull(value) {
+  return value !== void 0 && Number.isFinite(value) && value > 0 ? value : null;
+}
+__name(positiveFiniteOrNull, "positiveFiniteOrNull");
+function zeroRateHits() {
+  return { prompt: 0, mutation: 0, read: 0 };
+}
+__name(zeroRateHits, "zeroRateHits");
+function sumRateHits(hits) {
+  return hits.prompt + hits.mutation + hits.read;
+}
+__name(sumRateHits, "sumRateHits");
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+__name(isRecord, "isRecord");
+function numberValue(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+__name(numberValue, "numberValue");
+function copyBoolean(from, to, key) {
+  const value = from[key];
+  if (typeof value === "boolean") to[key] = value;
+}
+__name(copyBoolean, "copyBoolean");
+function copyString(from, to, key) {
+  const value = from[key];
+  if (typeof value === "string") to[key] = value;
+}
+__name(copyString, "copyString");
+function copyNumber(from, to, key) {
+  const value = numberValue(from[key]);
+  if (value !== void 0) to[key] = value;
+}
+__name(copyNumber, "copyNumber");
+
 // packages/cli/src/serve/capabilities.ts
 init_esbuild_shims();
 var SERVE_PROTOCOL_VERSION = "v1";
@@ -26178,6 +26780,7 @@ var SUPPORTED_SERVE_PROTOCOL_VERSIONS = [
 ];
 var SERVE_CAPABILITY_REGISTRY = {
   health: { since: "v1" },
+  daemon_status: { since: "v1" },
   capabilities: { since: "v1" },
   session_create: { since: "v1" },
   session_scope_override: { since: "v1" },
@@ -30408,8 +31011,11 @@ function resolveDaemonTelemetryRoute(req) {
   if (req.method === "POST" && path14 === "/sessions/delete") {
     return { route: "POST /sessions/delete" };
   }
+  if (req.method === "GET" && path14 === "/daemon/status") {
+    return { route: "GET /daemon/status" };
+  }
   const sessionAction = path14.match(
-    /^\/session\/([^/]+)\/(load|resume|prompt|cancel|recap|btw|model|shell|detach|rewind|approval-mode|language|a2ui-action)$/
+    /^\/session\/([^/]+)\/(load|resume|prompt|cancel|recap|btw|mid-turn-message|model|shell|detach|rewind|approval-mode|language|a2ui-action)$/
   );
   const sessionActionId = sessionAction?.[1];
   const sessionActionName = sessionAction?.[2];
@@ -30815,23 +31421,65 @@ function createServeApp(opts, getPort = () => opts.port, deps = {}) {
   }
   __name(buildWorkspaceCtx, "buildWorkspaceCtx");
   const LANGUAGE_CODES = [...SUPPORTED_LANGUAGES.map((l) => l.code), "auto"];
+  const currentServeFeatures = /* @__PURE__ */ __name(() => getAdvertisedServeFeatures(void 0, {
+    requireAuth: opts.requireAuth === true,
+    mcpPoolActive: opts.mcpPoolActive !== false,
+    allowOriginActive: opts.allowOrigins !== void 0 && opts.allowOrigins.length > 0,
+    ...opts.promptDeadlineMs !== void 0 ? { promptDeadlineMs: opts.promptDeadlineMs } : {},
+    ...opts.writerIdleTimeoutMs !== void 0 ? { writerIdleTimeoutMs: opts.writerIdleTimeoutMs } : {},
+    persistSettingAvailable: deps.persistSetting !== void 0,
+    sessionShellCommandEnabled,
+    rateLimit: opts.rateLimit === true,
+    reloadAvailable: deps.workspace !== void 0
+  }), "currentServeFeatures");
+  const acpHandleRef = {};
+  app.get("/daemon/status", async (req, res) => {
+    const detail = parseDaemonStatusDetail(req.query["detail"]);
+    if (!detail.ok || !detail.detail) {
+      res.status(400).json({
+        error: "detail must be one of: summary, full",
+        code: "invalid_detail"
+      });
+      return;
+    }
+    try {
+      res.status(200).json(
+        await buildDaemonStatusResponse(detail.detail, {
+          opts,
+          boundWorkspace,
+          bridge,
+          workspace,
+          daemonLog,
+          qwenCodeVersion: deps.qwenCodeVersion,
+          acpHandle: acpHandleRef.current,
+          rateLimiter,
+          getRestSseActive: getActiveSseCount,
+          features: currentServeFeatures(),
+          protocolVersions: getServeProtocolVersions(),
+          supportedDeviceFlowProviders: Array.from(
+            deviceFlowProviderMap.keys()
+          ),
+          deviceFlowRegistry,
+          sessionShellCommandEnabled
+        })
+      );
+    } catch (err) {
+      writeStderrLine(
+        `qwen serve: /daemon/status failed: ${err instanceof Error ? err.message : String(err)}`
+      );
+      res.status(500).json({
+        error: "Failed to build daemon status",
+        code: "daemon_status_failed"
+      });
+    }
+  });
   app.get("/capabilities", (_req, res) => {
     const envelope = {
       v: CAPABILITIES_SCHEMA_VERSION,
       protocolVersions: getServeProtocolVersions(),
       ...deps.qwenCodeVersion ? { qwenCodeVersion: deps.qwenCodeVersion } : {},
       mode: opts.mode,
-      features: getAdvertisedServeFeatures(void 0, {
-        requireAuth: opts.requireAuth === true,
-        mcpPoolActive: opts.mcpPoolActive !== false,
-        allowOriginActive: opts.allowOrigins !== void 0 && opts.allowOrigins.length > 0,
-        ...opts.promptDeadlineMs !== void 0 ? { promptDeadlineMs: opts.promptDeadlineMs } : {},
-        ...opts.writerIdleTimeoutMs !== void 0 ? { writerIdleTimeoutMs: opts.writerIdleTimeoutMs } : {},
-        persistSettingAvailable: deps.persistSetting !== void 0,
-        sessionShellCommandEnabled,
-        rateLimit: opts.rateLimit === true,
-        reloadAvailable: deps.workspace !== void 0
-      }),
+      features: currentServeFeatures(),
       modelServices: [],
       // Surface the bound workspace so clients can detect mismatch
       // pre-flight and omit `cwd` on `POST /session`.
@@ -31882,6 +32530,41 @@ function createServeApp(opts, getPort = () => opts.port, deps = {}) {
       res.off("close", onResClose);
     }
   });
+  const MID_TURN_MESSAGE_MAX_LENGTH = 16 * 1024;
+  app.post("/session/:id/mid-turn-message", mutate(), (req, res) => {
+    const sessionId = requireSessionId(req, res);
+    if (sessionId === null) return;
+    const body = safeBody(req);
+    const message = body["message"];
+    const trimmed = typeof message === "string" ? message.trim() : "";
+    if (trimmed.length === 0) {
+      res.status(400).json({
+        error: "`message` is required and must be a non-empty string"
+      });
+      return;
+    }
+    if (trimmed.length > MID_TURN_MESSAGE_MAX_LENGTH) {
+      res.status(400).json({
+        error: `\`message\` must be at most ${MID_TURN_MESSAGE_MAX_LENGTH} characters`
+      });
+      return;
+    }
+    const clientId = parseClientIdHeader(req, res);
+    if (clientId === null) return;
+    try {
+      const result = bridge.enqueueMidTurnMessage(
+        sessionId,
+        trimmed,
+        clientId !== void 0 ? { clientId } : void 0
+      );
+      res.status(200).json(result);
+    } catch (err) {
+      sendBridgeError(res, err, {
+        route: "POST /session/:id/mid-turn-message",
+        sessionId
+      });
+    }
+  });
   app.post("/session/:id/shell", mutate({ strict: true }), async (req, res) => {
     const sessionId = req.params["id"];
     if (!sessionShellCommandEnabled) {
@@ -32594,7 +33277,7 @@ function createServeApp(opts, getPort = () => opts.port, deps = {}) {
       }
     })();
   });
-  const acpHandle = mountAcpHttp(app, bridge, {
+  acpHandleRef.current = mountAcpHttp(app, bridge, {
     boundWorkspace,
     workspace,
     fsFactory,
@@ -32603,8 +33286,8 @@ function createServeApp(opts, getPort = () => opts.port, deps = {}) {
     sessionShellCommandEnabled,
     checkRate: rateLimiter?.checkRate
   });
-  if (acpHandle) {
-    app.locals["acpHandle"] = acpHandle;
+  if (acpHandleRef.current) {
+    app.locals["acpHandle"] = acpHandleRef.current;
   }
   app.use(
     (err, _req, res, _next) => {