feat(cli): Add channel worker settings reload for serve --channel

docs/developers/daemon/15-channel-adapters.md

@@ -162,6 +162,15 @@ sequenceDiagram
 - `shutdown()` closes every active session and the underlying transport (the channel's WebSocket / long-poll).
 - DingTalk's WebSocket stream supports server-push; WeChat's long-poll requires a backoff strategy on idle responses; Telegram's long-poll has a built-in `timeout` parameter.
 
+### Settings reload (`POST /workspace/channel/reload`)
+
+The daemon reads channel settings from `settings.json` once, when the channel worker starts (`packages/cli/src/commands/channel/daemon-worker.ts` → `loadSettings` → `loadChannelsConfig`). To apply changes without a full daemon restart, the daemon exposes `POST /workspace/channel/reload` (strict mutation gate; SDK `DaemonClient.reloadChannelWorker()`; CLI `qwen channel reload`):
+
+- The route calls `ChannelWorkerSupervisor.restart()` (`packages/cli/src/serve/channel-worker-supervisor.ts`), which stops the current worker child and relaunches it. The relaunched worker re-reads `settings.json`, so channel tokens, `proxy`, and per-channel `model` all take effect.
+- Concurrent reloads coalesce onto a single stop+relaunch. `restart()` also resets the crash-restart budget, so a worker parked in `failed` recovers on an explicit reload.
+- If the relaunch fails (for example, settings were edited into an invalid state), the channels stay down, the route returns 5xx with the latest snapshot, and `GET /daemon/status` reports `failed`.
+- The `channel_reload` capability and the route are advertised only when the daemon was started with `--channel`. Adding a brand-new channel name to a `--channel <names>` selection still requires a daemon restart; `--channel all` picks up newly-configured channels on reload.
+
 ## Dependencies
 
 - `packages/channels/base/` — `ChannelBase`, `DaemonChannelBridge`, `types.ts` (`ChannelConfig`, `Envelope`, `SessionScope`, `ChannelPlugin`).
@@ -196,6 +205,8 @@ Channel-specific keys layer on top (DingTalk: `streamCredentials`; WeChat: `ilin
 - `packages/channels/base/src/DaemonChannelBridge.ts`
 - `packages/channels/base/src/ChannelBase.ts`
 - `packages/channels/base/src/types.ts`
+- `packages/cli/src/serve/channel-worker-supervisor.ts` (worker supervision + `restart()`)
+- `packages/cli/src/serve/routes/workspace-channel-control.ts` (`POST /workspace/channel/reload`)
 - `packages/channels/dingtalk/src/DingtalkAdapter.ts`
 - `packages/channels/weixin/src/WeixinAdapter.ts`
 - `packages/channels/telegram/src/TelegramAdapter.ts`

docs/users/qwen-serve.md

@@ -15,7 +15,7 @@ Run Qwen Code as a local HTTP daemon so multiple clients (IDE plugins, web UIs,
 - **Reconnect-safe streaming** — SSE with `Last-Event-ID` reconnect lets a client drop and pick up exactly where it left off (within the ring's replay window).
 - **First-responder permissions** — when the agent asks for permission to run a tool, every connected client sees the request; whichever client answers first wins.
 - **One daemon, one workspace** — each `qwen serve` process binds to exactly one workspace at boot (per [#3803](https://github.com/QwenLM/qwen-code/issues/3803) §02). Multi-workspace deployments run one daemon per workspace on separate ports (or behind an orchestrator).
-- **Experimental daemon-managed channels** — `qwen serve --channel <name>` starts a channel worker owned by the daemon lifecycle. The worker is a separate process, connects back to the daemon through the SDK, and reports its state in `GET /daemon/status`.
+- **Experimental daemon-managed channels** — `qwen serve --channel <name>` starts a channel worker owned by the daemon lifecycle. The worker is a separate process, connects back to the daemon through the SDK, and reports its state in `GET /daemon/status`. After editing channel settings, reload it in place with `POST /workspace/channel/reload` (or `qwen channel reload`) — no full daemon restart needed.
 - **Remote runtime control** ([#4175](https://github.com/QwenLM/qwen-code/issues/4175) PR 17) — change a session's approval mode (`POST /session/:id/approval-mode`), toggle a tool per workspace (`POST /workspace/tools/:name/enable`), scaffold an empty `QWEN.md` (`POST /workspace/init`, mechanical only — does NOT call the model; for AI-fill, follow up with `POST /session/:id/prompt`), restart a single MCP server with a budget pre-check (`POST /workspace/mcp/:server/restart`), or add/remove MCP servers at runtime without a daemon restart (`POST /workspace/mcp/servers`, `DELETE /workspace/mcp/servers/:name`). All strict-gated — configure `--token` first.
 - **Session recap** ([#4175](https://github.com/QwenLM/qwen-code/issues/4175) follow-up) — fetch a one-sentence "where did I leave off" summary of an active session (`POST /session/:id/recap`). Wraps core's `generateSessionRecap` as a side-query against the fast model; pollutes neither the main chat history nor the SSE stream. Non-strict gate (same posture as `/prompt`); SDK helper `client.recapSession(sessionId)`.
   - **Known limit — token-cost amplification:** the route is a pure-cost endpoint (each call is an LLM side-query, no state benefit) and the daemon has no per-route rate limit in v1. On a no-token loopback default a buggy or malicious local client can spam it to burn tokens. Configure `--token` (and optionally `--require-auth`) on shared dev hosts before exposing the daemon.
@@ -96,7 +96,9 @@ qwen serve --channel telegram --channel feishu
 qwen serve --channel all
 ```
 
-This mode is experimental and daemon-managed. It does not replace the standalone `qwen channel start` command: standalone channels still use the ACP-backed `AcpBridge` service. With `qwen serve --channel`, the daemon launches one channel worker process after the HTTP runtime is ready. If the worker exits after startup, the daemon keeps running and `GET /daemon/status` reports a `channel_worker_exited` warning. Automatic worker restart is deferred.
+This mode is experimental and daemon-managed. It does not replace the standalone `qwen channel start` command: standalone channels still use the ACP-backed `AcpBridge` service. With `qwen serve --channel`, the daemon launches one channel worker process after the HTTP runtime is ready. If the worker crashes after startup, the daemon keeps running, relaunches it under a bounded restart policy, and reports its state (including `channel_worker_exited` warnings) in `GET /daemon/status`.
+
+The daemon reads each channel's settings (tokens, `proxy`, per-channel `model`) from `settings.json` once, when the worker starts. To apply changes without restarting the whole daemon, call `POST /workspace/channel/reload` (strict-gated; SDK `client.reloadChannelWorker()`, or `qwen channel reload`). The daemon stops and relaunches the channel worker, which re-reads `settings.json`; every selected channel briefly disconnects and reconnects, and persisted threads are restored from disk. The route is advertised as the `channel_reload` capability only when the daemon was started with `--channel`. Adding a brand-new channel name to a `--channel <names>` selection still requires a daemon restart (or use `--channel all`, which picks up newly-configured channels on reload).
 
 The daemon is bound to one workspace, so every selected channel's `cwd` must resolve to the daemon workspace. `--channel all` cannot be combined with named channels.
 

integration-tests/cli/qwen-serve-routes.test.ts

@@ -225,9 +225,10 @@ describe('qwen serve — capabilities envelope', () => {
     //
     // Conditional tags absent under this suite's spawn flags (no
     // `--require-auth` / `--allow-origin` / deadline env vars /
-    // rate-limit opt-in, no configured batch ASR model): `require_auth`,
-    // `allow_origin`, `cdp_tunnel_over_ws`, `prompt_absolute_deadline`,
-    // `writer_idle_timeout`, `workspace_voice_transcription`, `rate_limit`.
+    // rate-limit opt-in, no `--channel`, no configured batch ASR model):
+    // `require_auth`, `allow_origin`, `cdp_tunnel_over_ws`,
+    // `prompt_absolute_deadline`, `writer_idle_timeout`,
+    // `workspace_voice_transcription`, `rate_limit`, `channel_reload`.
     // Pool tags (`mcp_workspace_pool`, `mcp_pool_restart`) ARE present
     // because the workspace MCP pool is on by default, as are
     // `workspace_settings`, `workspace_permissions`, `workspace_voice`,

packages/cli/src/commands/channel.ts

@@ -2,6 +2,7 @@ import type { CommandModule, Argv } from 'yargs';
 import { startCommand } from './channel/start.js';
 import { stopCommand } from './channel/stop.js';
 import { statusCommand } from './channel/status.js';
+import { reloadCommand } from './channel/reload.js';
 import { daemonWorkerCommand } from './channel/daemon-worker.js';
 import {
   pairingListCommand,
@@ -30,6 +31,7 @@ export const channelCommand: CommandModule = {
       .command(daemonWorkerCommand)
       .command(stopCommand)
       .command(statusCommand)
+      .command(reloadCommand)
       .command(pairingCommand)
       .command(configureWeixinCommand)
       .demandCommand(1, 'You need at least one command before continuing.')

packages/cli/src/commands/channel/reload.test.ts

@@ -0,0 +1,115 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+const mockReloadChannelWorker = vi.hoisted(() => vi.fn());
+const mockDaemonClient = vi.hoisted(() =>
+  vi.fn(() => ({ reloadChannelWorker: mockReloadChannelWorker })),
+);
+const mockWriteStdoutLine = vi.hoisted(() => vi.fn());
+const mockWriteStderrLine = vi.hoisted(() => vi.fn());
+
+vi.mock('@qwen-code/sdk/daemon', () => ({
+  DaemonClient: mockDaemonClient,
+}));
+vi.mock('../../utils/stdioHelpers.js', () => ({
+  writeStdoutLine: mockWriteStdoutLine,
+  writeStderrLine: mockWriteStderrLine,
+}));
+
+import { reloadCommand } from './reload.js';
+
+type ReloadHandler = NonNullable<typeof reloadCommand.handler>;
+
+async function runHandler(argv: Record<string, unknown>): Promise<void> {
+  await (reloadCommand.handler as ReloadHandler)({
+    _: [],
+    $0: 'qwen',
+    ...argv,
+  } as never);
+}
+
+describe('channel reload command', () => {
+  beforeEach(() => {
+    vi.spyOn(process, 'exit').mockImplementation((() => undefined) as never);
+    vi.unstubAllEnvs();
+    vi.stubEnv('QWEN_DAEMON_URL', undefined);
+    vi.stubEnv('QWEN_SERVER_TOKEN', undefined);
+    vi.stubEnv('QWEN_DAEMON_TOKEN', undefined);
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+    vi.unstubAllEnvs();
+    mockReloadChannelWorker.mockReset();
+    mockDaemonClient.mockClear();
+    mockWriteStdoutLine.mockClear();
+    mockWriteStderrLine.mockClear();
+  });
+
+  it('reloads via the resolved daemon URL/token and prints the snapshot', async () => {
+    mockReloadChannelWorker.mockResolvedValue({
+      reloaded: true,
+      worker: {
+        enabled: true,
+        state: 'running',
+        channels: ['telegram'],
+        pid: 4321,
+        restartCount: 2,
+      },
+    });
+
+    await runHandler({ 'daemon-url': 'http://daemon:9', token: 'secret' });
+
+    expect(mockDaemonClient).toHaveBeenCalledWith({
+      baseUrl: 'http://daemon:9',
+      token: 'secret',
+    });
+    expect(mockReloadChannelWorker).toHaveBeenCalledTimes(1);
+    const line = mockWriteStdoutLine.mock.calls[0]?.[0] as string;
+    expect(line).toContain('state=running');
+    expect(line).toContain('channels=telegram');
+    expect(line).toContain('pid=4321');
+    expect(line).toContain('restarts=2');
+    expect(process.exit).toHaveBeenCalledWith(0);
+    expect(mockWriteStderrLine).not.toHaveBeenCalled();
+  });
+
+  it('defaults the daemon URL and omits the token when neither flag nor env is set', async () => {
+    mockReloadChannelWorker.mockResolvedValue({
+      reloaded: true,
+      worker: { enabled: true, state: 'running', channels: [] },
+    });
+
+    await runHandler({});
+
+    expect(mockDaemonClient).toHaveBeenCalledWith({
+      baseUrl: 'http://127.0.0.1:4170',
+    });
+  });
+
+  it('falls back to QWEN_DAEMON_URL and QWEN_SERVER_TOKEN from the environment', async () => {
+    vi.stubEnv('QWEN_DAEMON_URL', 'http://env-daemon:5');
+    vi.stubEnv('QWEN_SERVER_TOKEN', 'env-token');
+    mockReloadChannelWorker.mockResolvedValue({
+      reloaded: true,
+      worker: { enabled: true, state: 'running', channels: [] },
+    });
+
+    await runHandler({});
+
+    expect(mockDaemonClient).toHaveBeenCalledWith({
+      baseUrl: 'http://env-daemon:5',
+      token: 'env-token',
+    });
+  });
+
+  it('reports failures on stderr and exits non-zero', async () => {
+    mockReloadChannelWorker.mockRejectedValue(new Error('no channel worker'));
+
+    await runHandler({ 'daemon-url': 'http://daemon:9' });
+
+    const line = mockWriteStderrLine.mock.calls[0]?.[0] as string;
+    expect(line).toContain('Reload failed');
+    expect(line).toContain('no channel worker');
+    expect(process.exit).toHaveBeenCalledWith(1);
+  });
+});

packages/cli/src/commands/channel/reload.ts

@@ -0,0 +1,123 @@
+import type { CommandModule } from 'yargs';
+import { writeStderrLine, writeStdoutLine } from '../../utils/stdioHelpers.js';
+import {
+  QWEN_DAEMON_TOKEN_ENV,
+  QWEN_DAEMON_URL_ENV,
+  QWEN_SERVER_TOKEN_ENV,
+} from '../../serve/channel-worker-env.js';
+
+const DEFAULT_DAEMON_URL = 'http://127.0.0.1:4170';
+
+// Structural subset of the SDK's DaemonChannelReloadResult. Kept local (like
+// daemon-worker.ts's DaemonSdkLike) so this command doesn't take a static
+// type dependency on the SDK subpath.
+interface ChannelReloadResultLike {
+  reloaded: boolean;
+  worker: {
+    state: string;
+    channels: string[];
+    pid?: number;
+    restartCount?: number;
+    error?: string;
+  };
+}
+
+interface DaemonClientLike {
+  reloadChannelWorker(opts?: {
+    clientId?: string;
+    timeoutMs?: number;
+  }): Promise<ChannelReloadResultLike>;
+}
+
+interface DaemonSdkLike {
+  DaemonClient: new (opts: {
+    baseUrl: string;
+    token?: string;
+  }) => DaemonClientLike;
+}
+
+interface ReloadArgs {
+  'daemon-url'?: string;
+  token?: string;
+  timeout?: number;
+}
+
+function resolveDaemonUrl(flag: string | undefined): string {
+  // `||` (not `??`) so an empty flag or empty env var falls through to the
+  // default rather than producing an unusable empty base URL.
+  return flag || process.env[QWEN_DAEMON_URL_ENV] || DEFAULT_DAEMON_URL;
+}
+
+function resolveToken(flag: string | undefined): string | undefined {
+  return (
+    flag ??
+    process.env[QWEN_SERVER_TOKEN_ENV] ??
+    process.env[QWEN_DAEMON_TOKEN_ENV]
+  );
+}
+
+export const reloadCommand: CommandModule<unknown, ReloadArgs> = {
+  command: 'reload',
+  describe:
+    'Reload the daemon-managed channel worker so it re-reads settings.json',
+  builder: (yargs) =>
+    yargs
+      .option('daemon-url', {
+        type: 'string',
+        description: `Daemon base URL (default: $${QWEN_DAEMON_URL_ENV} or ${DEFAULT_DAEMON_URL})`,
+      })
+      .option('token', {
+        type: 'string',
+        description: `Bearer token (default: $${QWEN_SERVER_TOKEN_ENV})`,
+      })
+      .option('timeout', {
+        type: 'number',
+        description: 'Request timeout in milliseconds',
+      }),
+  handler: async (argv) => {
+    const baseUrl = resolveDaemonUrl(argv['daemon-url']);
+    const token = resolveToken(argv.token);
+
+    let sdk: DaemonSdkLike;
+    try {
+      sdk = (await import('@qwen-code/sdk/daemon')) as unknown as DaemonSdkLike;
+    } catch (err) {
+      writeStderrLine(
+        `[Channel] Failed to load daemon SDK: ${
+          err instanceof Error ? err.message : String(err)
+        }`,
+      );
+      process.exit(1);
+    }
+
+    const client = new sdk.DaemonClient({
+      baseUrl,
+      ...(token ? { token } : {}),
+    });
+
+    try {
+      const result = await client.reloadChannelWorker(
+        argv.timeout !== undefined ? { timeoutMs: argv.timeout } : undefined,
+      );
+      const worker = result.worker;
+      const parts = [
+        `state=${worker.state}`,
+        `channels=${worker.channels.join(', ') || 'none'}`,
+        ...(worker.pid !== undefined ? [`pid=${worker.pid}`] : []),
+        ...(worker.restartCount !== undefined
+          ? [`restarts=${worker.restartCount}`]
+          : []),
+        ...(worker.error ? [`error=${worker.error}`] : []),
+      ];
+      writeStdoutLine(`[Channel] Reloaded (${parts.join(', ')}).`);
+      process.exit(0);
+    } catch (err) {
+      writeStderrLine(
+        `[Channel] Reload failed (${baseUrl}): ${
+          err instanceof Error ? err.message : String(err)
+        }`,
+      );
+      process.exit(1);
+    }
+  },
+};

packages/cli/src/serve/capabilities.ts

@@ -258,6 +258,13 @@ export const SERVE_CAPABILITY_REGISTRY = {
   session_branch: { since: 'v1' },
   rate_limit: { since: 'v1' },
   workspace_reload: { since: 'v1' },
+  // Daemon supports reloading its daemon-managed channel worker via
+  // `POST /workspace/channel/reload`. The worker is stopped and relaunched;
+  // on relaunch it re-reads settings.json (channels / proxy / per-channel
+  // model), so channel settings changes apply without a full daemon restart.
+  // Advertised CONDITIONALLY — only when the daemon was started with
+  // `--channel` (i.e. a channel worker exists to reload).
+  channel_reload: { since: 'v1' },
   // Multi-workspace sessions closed loop (issue #6378 Phase 2a). Advertised
   // only when one daemon hosts more than one registered workspace runtime.
   multi_workspace_sessions: { since: 'v1' },
@@ -313,6 +320,12 @@ export interface AdvertiseFeatureToggles {
   sessionShellCommandEnabled?: boolean;
   rateLimit?: boolean;
   reloadAvailable?: boolean;
+  /**
+   * Whether the daemon exposes the channel worker reload route
+   * (`channel_reload`). Set only when the daemon was started with
+   * `--channel`, so a channel worker exists to reload.
+   */
+  channelReloadAvailable?: boolean;
   /**
    * Whether the daemon will accept client-hosted MCP servers over the WS
    * (`client_mcp_over_ws`, issue #5626).
@@ -396,6 +409,7 @@ export const CONDITIONAL_SERVE_FEATURES: ReadonlyMap<
   ],
   ['rate_limit', (toggles) => toggles.rateLimit === true],
   ['workspace_reload', (toggles) => toggles.reloadAvailable === true],
+  ['channel_reload', (toggles) => toggles.channelReloadAvailable === true],
   [
     'multi_workspace_sessions',
     (toggles) => toggles.multiWorkspaceSessionsEnabled === true,