From faba180380436a8f65cbc84c3d2fef4d74fbe744 Mon Sep 17 00:00:00 2001 From: Shaojin Wen Date: Thu, 2 Jul 2026 14:32:33 +0800 Subject: [PATCH 1/5] fix(serve): keep skill slash commands available after the ACP child is reaped MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit `GET /workspace/skills` is answered exclusively by the ACP child — the daemon has no local SkillManager. `requestWorkspaceStatus` only checks for an already-live channel (`liveChannelInfo()`, never `ensureChannel()`), so when no child is running it returns the idle placeholder (`initialized: false`, empty `skills`). That is the norm before the first session, and — crucially — again after the child is reaped on session close, which happens immediately by default (`--channel-idle-timeout-ms` defaults to 0 = immediate kill). Unlike `/workspace/providers`, skills have no daemon-local status provider to fall back on. So once a user has created and closed a session, every subsequent pre-first-prompt `/workspace/skills` query returns empty, the Web Shell's slash-command list falls back to the hardcoded built-ins (which omit skills), and `/rev` stops autocompleting `/review`. Retain the last skills status a live child produced and replay it while no channel is live, so skill-backed slash commands keep autocompleting; the next live query refreshes the cache. `initialized` cleanly separates a real child answer (always `true`) from the idle placeholder (always `false`). Completes #6153, which wired the Web Shell to fetch `/workspace/skills` in the deferred-connect path but could not surface skills the daemon was unable to answer without a live child. --- .../__tests__/facade.test.ts | 71 +++++++++++++++++++ .../cli/src/serve/workspace-service/index.ts | 24 ++++++- 2 files changed, 94 insertions(+), 1 deletion(-) diff --git a/packages/cli/src/serve/workspace-service/__tests__/facade.test.ts b/packages/cli/src/serve/workspace-service/__tests__/facade.test.ts index 935f09980ac..b41fdae1745 100644 --- a/packages/cli/src/serve/workspace-service/__tests__/facade.test.ts +++ b/packages/cli/src/serve/workspace-service/__tests__/facade.test.ts @@ -642,6 +642,77 @@ describe('createDaemonWorkspaceService', () => { expect(result.skills).toEqual([]); }); + it('getWorkspaceSkillsStatus replays the last live child status when the channel is idle', async () => { + const liveStatus = { + v: 1, + workspaceCwd: '/ws', + initialized: true, + skills: [ + { + kind: 'skill', + status: 'ok', + name: 'review', + description: 'Review changed code', + level: 'bundled', + modelInvocable: true, + }, + ], + }; + let channelLive = true; + const queryWorkspaceStatus = vi + .fn() + .mockImplementation((_m: string, idle: () => unknown) => + Promise.resolve(channelLive ? liveStatus : idle()), + ); + const svc = createDaemonWorkspaceService( + makeDeps({ queryWorkspaceStatus, boundWorkspace: '/ws' }), + ); + + // Channel live: authoritative skills from the ACP child, cached. + const first = await svc.getWorkspaceSkillsStatus(makeCtx()); + expect(first.initialized).toBe(true); + expect(first.skills.map((s) => s.name)).toEqual(['review']); + + // Channel reaped: queryWorkspaceStatus falls back to the empty idle + // placeholder, but the facade replays the last live status so + // skill-backed slash commands (e.g. /review) keep autocompleting. + channelLive = false; + const second = await svc.getWorkspaceSkillsStatus(makeCtx()); + expect(second.initialized).toBe(true); + expect(second.skills.map((s) => s.name)).toEqual(['review']); + }); + + it('getWorkspaceSkillsStatus refreshes the cached status on a newer live answer', async () => { + const statuses = [ + { + v: 1, + workspaceCwd: '/ws', + initialized: true, + skills: [{ kind: 'skill', status: 'ok', name: 'review' }], + }, + { + v: 1, + workspaceCwd: '/ws', + initialized: true, + skills: [ + { kind: 'skill', status: 'ok', name: 'review' }, + { kind: 'skill', status: 'ok', name: 'plan' }, + ], + }, + ]; + let call = 0; + const queryWorkspaceStatus = vi + .fn() + .mockImplementation(() => Promise.resolve(statuses[call++])); + const svc = createDaemonWorkspaceService( + makeDeps({ queryWorkspaceStatus, boundWorkspace: '/ws' }), + ); + + await svc.getWorkspaceSkillsStatus(makeCtx()); + const refreshed = await svc.getWorkspaceSkillsStatus(makeCtx()); + expect(refreshed.skills.map((s) => s.name)).toEqual(['review', 'plan']); + }); + it('getWorkspaceProvidersStatus uses daemon-local provider when present', async () => { const queryWorkspaceStatus = vi .fn() diff --git a/packages/cli/src/serve/workspace-service/index.ts b/packages/cli/src/serve/workspace-service/index.ts index 8cde332c3af..188166de7f5 100644 --- a/packages/cli/src/serve/workspace-service/index.ts +++ b/packages/cli/src/serve/workspace-service/index.ts @@ -28,6 +28,7 @@ import { createIdleEnvStatus, createIdleAcpPreflightCells, type ServeWorkspacePreflightStatus, + type ServeWorkspaceSkillsStatus, } from '@qwen-code/acp-bridge/status'; import { @@ -171,6 +172,11 @@ export function createDaemonWorkspaceService( publishWorkspaceEvent, } = deps; + // Last skills status answered by a live ACP child, retained so + // skill-backed slash commands (e.g. `/review`) keep autocompleting after + // the child channel has been reaped. See `getWorkspaceSkillsStatus`. + let lastWorkspaceSkillsStatus: ServeWorkspaceSkillsStatus | undefined; + // -- Facade -- return { // -- Status queries (delegate to ACP child via queryWorkspaceStatus) -- @@ -182,10 +188,26 @@ export function createDaemonWorkspaceService( }, async getWorkspaceSkillsStatus(_ctx: WorkspaceRequestContext) { - return queryWorkspaceStatus( + // Skills are enumerated only by the ACP child; the daemon has no local + // SkillManager. `queryWorkspaceStatus` therefore returns the idle + // placeholder (`initialized: false`, empty `skills`) whenever no child + // channel is live — the norm before the first session, and again after + // the child is reaped on session close (`--channel-idle-timeout-ms` + // defaults to an immediate kill). In that window the Web Shell's + // pre-first-prompt slash-command list would otherwise drop every skill, + // so `/rev` stops autocompleting `/review`. Serve the last status a live + // child produced instead, so skill-backed commands keep autocompleting; + // the next live query refreshes it. `initialized` cleanly separates a + // real child answer (always `true`) from the idle placeholder (`false`). + const status = await queryWorkspaceStatus( SERVE_STATUS_EXT_METHODS.workspaceSkills, () => createIdleWorkspaceSkillsStatus(boundWorkspace), ); + if (status.initialized) { + lastWorkspaceSkillsStatus = status; + return status; + } + return lastWorkspaceSkillsStatus ?? status; }, async getWorkspaceProvidersStatus(_ctx: WorkspaceRequestContext) { From f613a764e941078cb8fcd67c858136afb194ccb2 Mon Sep 17 00:00:00 2001 From: Shaojin Wen Date: Thu, 2 Jul 2026 16:17:41 +0800 Subject: [PATCH 2/5] fix(serve): enumerate workspace skills locally when the ACP child is unavailable MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The cache from the previous commit keeps the last child answer alive across a reap, but it never warms when the child never answers at all — most visibly under `npm run dev`, where the on-demand-transpiled child's `initialize` handshake routinely exceeds the 10s preheat budget, so preheat times out and no channel ever comes up. `/workspace/skills` then stays empty until the first prompt, dropping `/review` and every other skill from the Web Shell's pre-first-prompt autocomplete even though the skills exist on disk (typing `/review` in full still runs it, since submitting spawns a session — hence "not in the list, but usable"). Add a daemon-local skills provider that enumerates skills straight from the filesystem via SkillManager (a lightweight Config shim — no child, no MCP init), mirroring the existing daemon-local providers-status provider. The facade falls back to it only after both a live child answer and the cached last answer are unavailable, so the live child stays authoritative (and keeps extension-provided skills) while a never-preheated child still yields the on-disk skills — `/review` included. --- packages/cli/src/serve/run-qwen-serve.ts | 7 ++ packages/cli/src/serve/server.ts | 2 + .../__tests__/facade.test.ts | 94 ++++++++++++++ .../cli/src/serve/workspace-service/index.ts | 31 +++-- .../cli/src/serve/workspace-service/types.ts | 10 ++ .../src/serve/workspace-skills-status.test.ts | 34 +++++ .../cli/src/serve/workspace-skills-status.ts | 116 ++++++++++++++++++ 7 files changed, 284 insertions(+), 10 deletions(-) create mode 100644 packages/cli/src/serve/workspace-skills-status.test.ts create mode 100644 packages/cli/src/serve/workspace-skills-status.ts diff --git a/packages/cli/src/serve/run-qwen-serve.ts b/packages/cli/src/serve/run-qwen-serve.ts index ab2d332ff16..1c529294ce2 100644 --- a/packages/cli/src/serve/run-qwen-serve.ts +++ b/packages/cli/src/serve/run-qwen-serve.ts @@ -692,6 +692,7 @@ async function loadServeRuntimeModules() { workspaceTypesModule, daemonStatusProviderModule, workspaceProvidersStatusModule, + workspaceSkillsStatusModule, ] = await Promise.all([ import('./server.js'), import('@qwen-code/acp-bridge/bridge'), @@ -700,6 +701,7 @@ async function loadServeRuntimeModules() { import('./workspace-service/types.js'), import('./daemon-status-provider.js'), import('./workspace-providers-status.js'), + import('./workspace-skills-status.js'), ]); return { createServeApp: serverModule.createServeApp, @@ -714,6 +716,8 @@ async function loadServeRuntimeModules() { daemonStatusProviderModule.createDaemonStatusProvider, createWorkspaceProvidersStatusProvider: workspaceProvidersStatusModule.createWorkspaceProvidersStatusProvider, + createWorkspaceSkillsStatusProvider: + workspaceSkillsStatusModule.createWorkspaceSkillsStatusProvider, }; } @@ -2031,6 +2035,8 @@ export async function runQwenServe( const statusProvider = runtime.createDaemonStatusProvider(); const workspaceProvidersStatusProvider = runtime.createWorkspaceProvidersStatusProvider(); + const workspaceSkillsStatusProvider = + runtime.createWorkspaceSkillsStatusProvider(); // Reverse tool channel (issue #5626, Phase 2). ONE sender registry shared // between the bridge (which answers the ACP child's `client_mcp/message` // ext-method via `clientMcpSender`) and the WS provider in `createServeApp` @@ -2161,6 +2167,7 @@ export async function runQwenServe( contextFilename: contextFilenameForInit ?? 'QWEN.md', statusProvider, workspaceProvidersStatusProvider, + workspaceSkillsStatusProvider, isChannelLive: () => bridge.isChannelLive(), persistDisabledTools: persistDisabledToolsFn, persistSetting: persistSettingFn, diff --git a/packages/cli/src/serve/server.ts b/packages/cli/src/serve/server.ts index ef3aef0af33..058dae08fcd 100644 --- a/packages/cli/src/serve/server.ts +++ b/packages/cli/src/serve/server.ts @@ -25,6 +25,7 @@ import type { DaemonStatusProvider } from '@qwen-code/acp-bridge'; import { createBridgeFileSystemAdapter } from './bridge-file-system-adapter.js'; import { createDaemonStatusProvider } from './daemon-status-provider.js'; import { createWorkspaceProvidersStatusProvider } from './workspace-providers-status.js'; +import { createWorkspaceSkillsStatusProvider } from './workspace-skills-status.js'; import { mountAcpHttp, type AcpHttpHandle } from './acp-http/index.js'; import { createVoiceWsConnectionHandler } from './voice/voice-ws.js'; import { @@ -411,6 +412,7 @@ export function createServeApp( statusProvider, workspaceProvidersStatusProvider: createWorkspaceProvidersStatusProvider(), + workspaceSkillsStatusProvider: createWorkspaceSkillsStatusProvider(), isChannelLive: () => bridge.isChannelLive(), persistDisabledTools: deps.persistDisabledTools ?? diff --git a/packages/cli/src/serve/workspace-service/__tests__/facade.test.ts b/packages/cli/src/serve/workspace-service/__tests__/facade.test.ts index b41fdae1745..75c5336fb6a 100644 --- a/packages/cli/src/serve/workspace-service/__tests__/facade.test.ts +++ b/packages/cli/src/serve/workspace-service/__tests__/facade.test.ts @@ -713,6 +713,100 @@ describe('createDaemonWorkspaceService', () => { expect(refreshed.skills.map((s) => s.name)).toEqual(['review', 'plan']); }); + it('getWorkspaceSkillsStatus falls back to the daemon-local provider when the child never answered', async () => { + const queryWorkspaceStatus = vi + .fn() + .mockImplementation((_m: string, idle: () => unknown) => + Promise.resolve(idle()), + ); + const workspaceSkillsStatusProvider = vi.fn().mockResolvedValue({ + v: 1, + workspaceCwd: '/ws', + initialized: true, + skills: [ + { + kind: 'skill', + status: 'ok', + name: 'review', + description: 'Review changed code', + level: 'bundled', + modelInvocable: true, + }, + ], + }); + const svc = createDaemonWorkspaceService( + makeDeps({ + queryWorkspaceStatus, + workspaceSkillsStatusProvider, + boundWorkspace: '/ws', + }), + ); + + const result = await svc.getWorkspaceSkillsStatus(makeCtx()); + + expect(workspaceSkillsStatusProvider).toHaveBeenCalledWith('/ws'); + expect(result.initialized).toBe(true); + expect(result.skills.map((s) => s.name)).toEqual(['review']); + }); + + it('getWorkspaceSkillsStatus prefers the cached child answer over the daemon-local provider', async () => { + const liveStatus = { + v: 1, + workspaceCwd: '/ws', + initialized: true, + skills: [{ kind: 'skill', status: 'ok', name: 'review' }], + }; + let channelLive = true; + const queryWorkspaceStatus = vi + .fn() + .mockImplementation((_m: string, idle: () => unknown) => + Promise.resolve(channelLive ? liveStatus : idle()), + ); + const workspaceSkillsStatusProvider = vi.fn().mockResolvedValue({ + v: 1, + workspaceCwd: '/ws', + initialized: true, + skills: [], + }); + const svc = createDaemonWorkspaceService( + makeDeps({ + queryWorkspaceStatus, + workspaceSkillsStatusProvider, + boundWorkspace: '/ws', + }), + ); + + await svc.getWorkspaceSkillsStatus(makeCtx()); // warms cache (child live) + channelLive = false; + const result = await svc.getWorkspaceSkillsStatus(makeCtx()); + + expect(result.skills.map((s) => s.name)).toEqual(['review']); + expect(workspaceSkillsStatusProvider).not.toHaveBeenCalled(); + }); + + it('getWorkspaceSkillsStatus does not use the daemon-local provider while the child answers', async () => { + const liveStatus = { + v: 1, + workspaceCwd: '/ws', + initialized: true, + skills: [{ kind: 'skill', status: 'ok', name: 'review' }], + }; + const queryWorkspaceStatus = vi.fn().mockResolvedValue(liveStatus); + const workspaceSkillsStatusProvider = vi.fn().mockResolvedValue({ + v: 1, + workspaceCwd: '/ws', + initialized: true, + skills: [], + }); + const svc = createDaemonWorkspaceService( + makeDeps({ queryWorkspaceStatus, workspaceSkillsStatusProvider }), + ); + + await svc.getWorkspaceSkillsStatus(makeCtx()); + + expect(workspaceSkillsStatusProvider).not.toHaveBeenCalled(); + }); + it('getWorkspaceProvidersStatus uses daemon-local provider when present', async () => { const queryWorkspaceStatus = vi .fn() diff --git a/packages/cli/src/serve/workspace-service/index.ts b/packages/cli/src/serve/workspace-service/index.ts index 188166de7f5..805f6823877 100644 --- a/packages/cli/src/serve/workspace-service/index.ts +++ b/packages/cli/src/serve/workspace-service/index.ts @@ -162,6 +162,7 @@ export function createDaemonWorkspaceService( contextFilename, statusProvider, workspaceProvidersStatusProvider, + workspaceSkillsStatusProvider, isChannelLive, persistDisabledTools, persistSetting, @@ -188,17 +189,16 @@ export function createDaemonWorkspaceService( }, async getWorkspaceSkillsStatus(_ctx: WorkspaceRequestContext) { - // Skills are enumerated only by the ACP child; the daemon has no local - // SkillManager. `queryWorkspaceStatus` therefore returns the idle - // placeholder (`initialized: false`, empty `skills`) whenever no child - // channel is live — the norm before the first session, and again after + // Skills are enumerated by the ACP child, which owns the live + // SkillManager (including extension-provided skills). `queryWorkspaceStatus` + // returns the idle placeholder (`initialized: false`, empty `skills`) + // whenever no child channel is live — before the first session, after // the child is reaped on session close (`--channel-idle-timeout-ms` - // defaults to an immediate kill). In that window the Web Shell's + // defaults to an immediate kill), and when a cold-start preheat times + // out before the child ever answers. In those windows the Web Shell's // pre-first-prompt slash-command list would otherwise drop every skill, - // so `/rev` stops autocompleting `/review`. Serve the last status a live - // child produced instead, so skill-backed commands keep autocompleting; - // the next live query refreshes it. `initialized` cleanly separates a - // real child answer (always `true`) from the idle placeholder (`false`). + // so `/rev` stops autocompleting `/review`. `initialized` cleanly + // separates a real child answer (always `true`) from the placeholder. const status = await queryWorkspaceStatus( SERVE_STATUS_EXT_METHODS.workspaceSkills, () => createIdleWorkspaceSkillsStatus(boundWorkspace), @@ -207,7 +207,18 @@ export function createDaemonWorkspaceService( lastWorkspaceSkillsStatus = status; return status; } - return lastWorkspaceSkillsStatus ?? status; + // Live child unavailable. Prefer the last answer it produced (keeps the + // full, extension-aware list available across a reap)... + if (lastWorkspaceSkillsStatus) { + return lastWorkspaceSkillsStatus; + } + // ...then fall back to daemon-local enumeration, so a child that has not + // answered even once (e.g. a preheat that times out under `npm run dev`) + // still yields the on-disk skills — `/review` included. + if (workspaceSkillsStatusProvider) { + return workspaceSkillsStatusProvider(boundWorkspace); + } + return status; }, async getWorkspaceProvidersStatus(_ctx: WorkspaceRequestContext) { diff --git a/packages/cli/src/serve/workspace-service/types.ts b/packages/cli/src/serve/workspace-service/types.ts index f16a9ade4ae..96337078b5a 100644 --- a/packages/cli/src/serve/workspace-service/types.ts +++ b/packages/cli/src/serve/workspace-service/types.ts @@ -38,6 +38,7 @@ import type { import type { WorkspaceVoiceStatus } from '../../services/voice-service.js'; import type { VoiceMode } from '../../services/voice-settings.js'; import type { WorkspaceProvidersStatusProvider } from '../workspace-providers-status.js'; +import type { WorkspaceSkillsStatusProvider } from '../workspace-skills-status.js'; // --------------------------------------------------------------------------- // WorkspaceRequestContext @@ -324,6 +325,15 @@ export interface DaemonWorkspaceServiceDeps { */ workspaceProvidersStatusProvider?: WorkspaceProvidersStatusProvider; + /** + * Daemon-local skill enumeration. Used as a fallback for + * `/workspace/skills` when the ACP child cannot answer (e.g. before the + * first prompt on a cold daemon whose preheat has not yet — or cannot — + * bring the child up), so skill-backed slash commands autocomplete without + * waiting on the child. The live child stays authoritative when present. + */ + workspaceSkillsStatusProvider?: WorkspaceSkillsStatusProvider; + /** * Returns whether the ACP channel is currently live. Used by * `getWorkspaceEnvStatus` to populate the `acpChannelLive` field diff --git a/packages/cli/src/serve/workspace-skills-status.test.ts b/packages/cli/src/serve/workspace-skills-status.test.ts new file mode 100644 index 00000000000..3c0fa9b68ef --- /dev/null +++ b/packages/cli/src/serve/workspace-skills-status.test.ts @@ -0,0 +1,34 @@ +/** + * @license + * Copyright 2025 Qwen Team + * SPDX-License-Identifier: Apache-2.0 + */ + +import { describe, it, expect } from 'vitest'; +import { createWorkspaceSkillsStatusProvider } from './workspace-skills-status.js'; + +describe('createWorkspaceSkillsStatusProvider', () => { + it('enumerates bundled skills (including /review) without an ACP child', async () => { + const provider = createWorkspaceSkillsStatusProvider(); + + const status = await provider(process.cwd()); + + expect(status.initialized).toBe(true); + const review = status.skills.find((skill) => skill.name === 'review'); + expect(review).toBeDefined(); + expect(review?.kind).toBe('skill'); + expect(review?.level).toBe('bundled'); + // Skill-tool listing exposes the model-invocable flag; bundled /review is + // invocable, and the argument hint drives the slash-command autocomplete. + expect(review?.modelInvocable).toBe(true); + expect(review?.argumentHint).toBeTruthy(); + }); + + it('reports the queried workspace path', async () => { + const provider = createWorkspaceSkillsStatusProvider(); + + const status = await provider('/some/workspace'); + + expect(status.workspaceCwd).toBe('/some/workspace'); + }); +}); diff --git a/packages/cli/src/serve/workspace-skills-status.ts b/packages/cli/src/serve/workspace-skills-status.ts new file mode 100644 index 00000000000..ca59ad50de6 --- /dev/null +++ b/packages/cli/src/serve/workspace-skills-status.ts @@ -0,0 +1,116 @@ +/** + * @license + * Copyright 2025 Qwen Team + * SPDX-License-Identifier: Apache-2.0 + */ + +/** + * Daemon-local workspace skills enumeration. + * + * `/workspace/skills` is normally answered by the ACP child (which owns the + * live `SkillManager`). But the child is not always available before the + * first prompt: session creation is deferred until then, and the startup + * preheat can time out on a slow cold start — most visibly under + * `npm run dev`, where the child is transpiled on demand and its + * `initialize` handshake routinely exceeds the 10s preheat budget, so no + * channel ever comes up. In that window the child cannot list skills, which + * drops skill-backed slash commands (e.g. `/review`) from the Web Shell's + * pre-first-prompt autocomplete even though the skills exist on disk. + * + * This provider enumerates skills directly from the filesystem via + * `SkillManager`, with no child and no MCP initialization, so the daemon can + * answer `/workspace/skills` instantly whenever the child is unavailable. + * `SkillManager.listSkills()` only reads a handful of `Config` getters + * (safe/bare mode, project root, active extensions), so a lightweight config + * shim is sufficient — no full `Config` construction (and no `initialize()` + * side effects) required. The live child, when present, stays authoritative: + * the facade only falls back here after a real child answer and the cached + * last answer are both unavailable, and this daemon-local view intentionally + * omits extension-provided skills (there is no active-extension context + * outside the child) — those still surface once a session exists. + */ + +import { SkillManager } from '@qwen-code/qwen-code-core'; +import type { Config, SkillConfig } from '@qwen-code/qwen-code-core'; +import type { + ServeWorkspaceSkillStatus, + ServeWorkspaceSkillsStatus, +} from '@qwen-code/acp-bridge/status'; +import { STATUS_SCHEMA_VERSION } from '@qwen-code/acp-bridge/status'; + +export type WorkspaceSkillsStatusProvider = ( + workspaceCwd: string, +) => Promise; + +/** + * The `Config` surface `SkillManager.listSkills()` actually reads. Declaring it + * as a `Pick` (rather than casting an inline object literal) type-checks the + * shimmed getters against `Config`'s real signatures, so a signature drift is + * caught at compile time. Should `SkillManager` grow a dependency on some other + * `Config` method, that call would be `undefined` at runtime — which + * `buildWorkspaceSkillsStatus`'s try/catch turns into an empty, non-initialized + * status (the facade then leaves skills to the live child) rather than a crash. + */ +type SkillManagerConfigShim = Pick< + Config, + 'isSafeMode' | 'getBareMode' | 'getProjectRoot' | 'getActiveExtensions' +>; + +export function createWorkspaceSkillsStatusProvider(): WorkspaceSkillsStatusProvider { + return (workspaceCwd) => buildWorkspaceSkillsStatus(workspaceCwd); +} + +async function buildWorkspaceSkillsStatus( + workspaceCwd: string, +): Promise { + try { + const shim: SkillManagerConfigShim = { + // The daemon binds to an operator-chosen workspace and only lists skills + // for autocomplete (the child gates execution), so enumerate all levels + // rather than restricting to bundled-only safe mode. + isSafeMode: () => false, + getBareMode: () => false, + getProjectRoot: () => workspaceCwd, + // Extension skills need active-extension context that only the child + // has; omit them here and let the session snapshot surface them. + getActiveExtensions: () => [], + }; + const skillManager = new SkillManager(shim as Config); + const skills = await skillManager.listSkills(); + return { + v: STATUS_SCHEMA_VERSION, + workspaceCwd, + initialized: true, + skills: skills.map(mapSkill), + }; + } catch (error) { + return { + v: STATUS_SCHEMA_VERSION, + workspaceCwd, + initialized: false, + skills: [], + errors: [ + { + kind: 'skills', + status: 'error', + error: error instanceof Error ? error.message : String(error), + }, + ], + }; + } +} + +function mapSkill(skill: SkillConfig): ServeWorkspaceSkillStatus { + const modelInvocable = skill.disableModelInvocation !== true; + return { + kind: 'skill', + status: modelInvocable ? 'ok' : 'disabled', + name: skill.name, + description: skill.description, + level: skill.level, + modelInvocable, + ...(skill.argumentHint ? { argumentHint: skill.argumentHint } : {}), + ...(skill.model ? { model: skill.model } : {}), + ...(skill.extensionName ? { extensionName: skill.extensionName } : {}), + }; +} From 8bf6ae86638a5ef5a01145198a45c765f6d2433d Mon Sep 17 00:00:00 2001 From: Shaojin Wen Date: Thu, 2 Jul 2026 16:33:28 +0800 Subject: [PATCH 3/5] fix(serve): fall back to cached/local skills when the child query throws mid-flight Addresses review feedback on #6169: the channel can die after `liveChannelInfo()` returns a valid channel but before the RPC completes, so `queryWorkspaceStatus` rejects. Previously that exception propagated even though the cache or the daemon-local provider could still answer. Wrap the query in try/catch (logging via writeStderrLine, matching getWorkspaceEnvStatus / getWorkspacePreflightStatus) and treat a mid-flight failure as "no live child", so the request degrades to the cached last answer or daemon-local enumeration instead of failing. --- .../__tests__/facade.test.ts | 51 +++++++++++++++++++ .../cli/src/serve/workspace-service/index.ts | 21 ++++++-- 2 files changed, 68 insertions(+), 4 deletions(-) diff --git a/packages/cli/src/serve/workspace-service/__tests__/facade.test.ts b/packages/cli/src/serve/workspace-service/__tests__/facade.test.ts index 75c5336fb6a..5cd10878c1f 100644 --- a/packages/cli/src/serve/workspace-service/__tests__/facade.test.ts +++ b/packages/cli/src/serve/workspace-service/__tests__/facade.test.ts @@ -807,6 +807,57 @@ describe('createDaemonWorkspaceService', () => { expect(workspaceSkillsStatusProvider).not.toHaveBeenCalled(); }); + it('getWorkspaceSkillsStatus replays the cache when the query throws mid-flight', async () => { + const liveStatus = { + v: 1, + workspaceCwd: '/ws', + initialized: true, + skills: [{ kind: 'skill', status: 'ok', name: 'review' }], + }; + let shouldThrow = false; + const queryWorkspaceStatus = vi + .fn() + .mockImplementation(() => + shouldThrow + ? Promise.reject(new Error('channel closed mid-request')) + : Promise.resolve(liveStatus), + ); + const svc = createDaemonWorkspaceService( + makeDeps({ queryWorkspaceStatus, boundWorkspace: '/ws' }), + ); + + await svc.getWorkspaceSkillsStatus(makeCtx()); // warms cache (live) + shouldThrow = true; + const result = await svc.getWorkspaceSkillsStatus(makeCtx()); + + // Mid-flight failure resolves to the cached answer, not a rejection. + expect(result.skills.map((s) => s.name)).toEqual(['review']); + }); + + it('getWorkspaceSkillsStatus falls back to daemon-local when the query throws with no cache', async () => { + const queryWorkspaceStatus = vi + .fn() + .mockRejectedValue(new Error('channel closed mid-request')); + const workspaceSkillsStatusProvider = vi.fn().mockResolvedValue({ + v: 1, + workspaceCwd: '/ws', + initialized: true, + skills: [{ kind: 'skill', status: 'ok', name: 'review' }], + }); + const svc = createDaemonWorkspaceService( + makeDeps({ + queryWorkspaceStatus, + workspaceSkillsStatusProvider, + boundWorkspace: '/ws', + }), + ); + + const result = await svc.getWorkspaceSkillsStatus(makeCtx()); + + expect(workspaceSkillsStatusProvider).toHaveBeenCalledWith('/ws'); + expect(result.skills.map((s) => s.name)).toEqual(['review']); + }); + it('getWorkspaceProvidersStatus uses daemon-local provider when present', async () => { const queryWorkspaceStatus = vi .fn() diff --git a/packages/cli/src/serve/workspace-service/index.ts b/packages/cli/src/serve/workspace-service/index.ts index 805f6823877..33bd8d78ad3 100644 --- a/packages/cli/src/serve/workspace-service/index.ts +++ b/packages/cli/src/serve/workspace-service/index.ts @@ -199,10 +199,23 @@ export function createDaemonWorkspaceService( // pre-first-prompt slash-command list would otherwise drop every skill, // so `/rev` stops autocompleting `/review`. `initialized` cleanly // separates a real child answer (always `true`) from the placeholder. - const status = await queryWorkspaceStatus( - SERVE_STATUS_EXT_METHODS.workspaceSkills, - () => createIdleWorkspaceSkillsStatus(boundWorkspace), - ); + let status: ServeWorkspaceSkillsStatus; + try { + status = await queryWorkspaceStatus( + SERVE_STATUS_EXT_METHODS.workspaceSkills, + () => createIdleWorkspaceSkillsStatus(boundWorkspace), + ); + } catch (err) { + // The channel can die mid-RPC (`liveChannelInfo()` was valid at the + // check but the child exited before the call completed). Treat that + // like "no live child" and fall back to the cache / daemon-local + // enumeration below instead of failing the request — matching + // getWorkspaceEnvStatus / getWorkspacePreflightStatus. + writeStderrLine( + `qwen serve: getWorkspaceSkillsStatus query failed: ${err instanceof Error ? err.message : String(err)}`, + ); + status = createIdleWorkspaceSkillsStatus(boundWorkspace); + } if (status.initialized) { lastWorkspaceSkillsStatus = status; return status; From 8eb98ab52833f7aeb804849163d9659875dd3352 Mon Sep 17 00:00:00 2001 From: Shaojin Wen Date: Thu, 2 Jul 2026 17:29:12 +0800 Subject: [PATCH 4/5] refactor(serve): address review feedback on daemon-local skills provider MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - Extract the SkillConfig → ServeWorkspaceSkillStatus mapping into a shared workspace-skills-mapping module used by both the ACP child's buildWorkspaceSkillsStatus and the daemon-local provider, so the two skill listings can't drift; cover it (including the disable-model-invocation branch) with a unit test. - Memoize the SkillManager per workspace so repeat queries reuse its in-memory cache instead of re-scanning every skill level on each call. - Honor the safe-mode env (isSafeModeEnv, as Config does) instead of hardcoding isSafeMode to false; keep bareMode off (the daemon never runs `--bare`). - Log daemon-local enumeration failures via writeStderrLine, matching the rest of the workspace-service error handling. --- packages/cli/src/acp-integration/acpAgent.ts | 19 +---- .../serve/workspace-skills-mapping.test.ts | 59 +++++++++++++++ .../cli/src/serve/workspace-skills-mapping.ts | 32 ++++++++ .../cli/src/serve/workspace-skills-status.ts | 74 ++++++++++--------- 4 files changed, 131 insertions(+), 53 deletions(-) create mode 100644 packages/cli/src/serve/workspace-skills-mapping.test.ts create mode 100644 packages/cli/src/serve/workspace-skills-mapping.ts diff --git a/packages/cli/src/acp-integration/acpAgent.ts b/packages/cli/src/acp-integration/acpAgent.ts index 392d0247573..59a2ddecf26 100644 --- a/packages/cli/src/acp-integration/acpAgent.ts +++ b/packages/cli/src/acp-integration/acpAgent.ts @@ -157,6 +157,7 @@ import { loadCliConfig, } from '../config/config.js'; import { extractRememberErrorCode } from '../serve/workspace-remember-errors.js'; +import { mapSkillConfigToStatus } from '../serve/workspace-skills-mapping.js'; import { Session, buildAvailableCommandsSnapshot } from './session/Session.js'; import { buildSessionTasksStatus } from './session/tasksSnapshot.js'; import { HistoryReplayer } from './session/HistoryReplayer.js'; @@ -216,7 +217,6 @@ import { type ServeWorkspaceProviderModel, type ServeWorkspaceProviderStatus, type ServeWorkspaceProvidersStatus, - type ServeWorkspaceSkillStatus, type ServeWorkspaceSkillsStatus, type ServeWorkspaceToolStatus, type ServeWorkspaceToolsStatus, @@ -3896,22 +3896,7 @@ class QwenAgent implements Agent { v: STATUS_SCHEMA_VERSION, workspaceCwd: this.workspaceCwd(config), initialized: true, - skills: skills.map((skill): ServeWorkspaceSkillStatus => { - const modelInvocable = skill.disableModelInvocation !== true; - return { - kind: 'skill', - status: modelInvocable ? 'ok' : 'disabled', - name: skill.name, - description: skill.description, - level: skill.level, - modelInvocable, - ...(skill.argumentHint ? { argumentHint: skill.argumentHint } : {}), - ...(skill.model ? { model: skill.model } : {}), - ...(skill.extensionName - ? { extensionName: skill.extensionName } - : {}), - }; - }), + skills: skills.map(mapSkillConfigToStatus), }; } catch (error) { return { diff --git a/packages/cli/src/serve/workspace-skills-mapping.test.ts b/packages/cli/src/serve/workspace-skills-mapping.test.ts new file mode 100644 index 00000000000..33f73acb49c --- /dev/null +++ b/packages/cli/src/serve/workspace-skills-mapping.test.ts @@ -0,0 +1,59 @@ +/** + * @license + * Copyright 2025 Qwen Team + * SPDX-License-Identifier: Apache-2.0 + */ + +import { describe, it, expect } from 'vitest'; +import type { SkillConfig } from '@qwen-code/qwen-code-core'; +import { mapSkillConfigToStatus } from './workspace-skills-mapping.js'; + +function makeSkill(overrides: Partial = {}): SkillConfig { + return { + name: 'review', + description: 'Review changed code', + level: 'bundled', + ...overrides, + } as SkillConfig; +} + +describe('mapSkillConfigToStatus', () => { + it('maps an invocable skill to an ok status with its core fields', () => { + const status = mapSkillConfigToStatus( + makeSkill({ argumentHint: '[pr-number]' }), + ); + + expect(status).toEqual({ + kind: 'skill', + status: 'ok', + name: 'review', + description: 'Review changed code', + level: 'bundled', + modelInvocable: true, + argumentHint: '[pr-number]', + }); + }); + + it('marks a disable-model-invocation skill as disabled', () => { + const status = mapSkillConfigToStatus( + makeSkill({ name: 'internal', disableModelInvocation: true }), + ); + + expect(status.status).toBe('disabled'); + expect(status.modelInvocable).toBe(false); + expect(status.name).toBe('internal'); + }); + + it('surfaces optional model and extensionName only when present', () => { + expect(mapSkillConfigToStatus(makeSkill())).not.toHaveProperty('model'); + expect(mapSkillConfigToStatus(makeSkill())).not.toHaveProperty( + 'extensionName', + ); + + const status = mapSkillConfigToStatus( + makeSkill({ model: 'gpt-4o', extensionName: 'acme' }), + ); + expect(status.model).toBe('gpt-4o'); + expect(status.extensionName).toBe('acme'); + }); +}); diff --git a/packages/cli/src/serve/workspace-skills-mapping.ts b/packages/cli/src/serve/workspace-skills-mapping.ts new file mode 100644 index 00000000000..97e13080e3b --- /dev/null +++ b/packages/cli/src/serve/workspace-skills-mapping.ts @@ -0,0 +1,32 @@ +/** + * @license + * Copyright 2025 Qwen Team + * SPDX-License-Identifier: Apache-2.0 + */ + +import type { SkillConfig } from '@qwen-code/qwen-code-core'; +import type { ServeWorkspaceSkillStatus } from '@qwen-code/acp-bridge/status'; + +/** + * Maps a `SkillConfig` (as `SkillManager.listSkills()` returns) to the + * `/workspace/skills` wire status. Shared by the ACP child's + * `buildWorkspaceSkillsStatus` and the daemon-local + * `workspace-skills-status` provider so the two skill listings can never + * drift in shape. + */ +export function mapSkillConfigToStatus( + skill: SkillConfig, +): ServeWorkspaceSkillStatus { + const modelInvocable = skill.disableModelInvocation !== true; + return { + kind: 'skill', + status: modelInvocable ? 'ok' : 'disabled', + name: skill.name, + description: skill.description, + level: skill.level, + modelInvocable, + ...(skill.argumentHint ? { argumentHint: skill.argumentHint } : {}), + ...(skill.model ? { model: skill.model } : {}), + ...(skill.extensionName ? { extensionName: skill.extensionName } : {}), + }; +} diff --git a/packages/cli/src/serve/workspace-skills-status.ts b/packages/cli/src/serve/workspace-skills-status.ts index ca59ad50de6..8d0b333e733 100644 --- a/packages/cli/src/serve/workspace-skills-status.ts +++ b/packages/cli/src/serve/workspace-skills-status.ts @@ -30,13 +30,12 @@ * outside the child) — those still surface once a session exists. */ -import { SkillManager } from '@qwen-code/qwen-code-core'; -import type { Config, SkillConfig } from '@qwen-code/qwen-code-core'; -import type { - ServeWorkspaceSkillStatus, - ServeWorkspaceSkillsStatus, -} from '@qwen-code/acp-bridge/status'; +import { SkillManager, isSafeModeEnv } from '@qwen-code/qwen-code-core'; +import type { Config } from '@qwen-code/qwen-code-core'; +import type { ServeWorkspaceSkillsStatus } from '@qwen-code/acp-bridge/status'; import { STATUS_SCHEMA_VERSION } from '@qwen-code/acp-bridge/status'; +import { writeStderrLine } from '../utils/stdioHelpers.js'; +import { mapSkillConfigToStatus } from './workspace-skills-mapping.js'; export type WorkspaceSkillsStatusProvider = ( workspaceCwd: string, @@ -57,33 +56,51 @@ type SkillManagerConfigShim = Pick< >; export function createWorkspaceSkillsStatusProvider(): WorkspaceSkillsStatusProvider { - return (workspaceCwd) => buildWorkspaceSkillsStatus(workspaceCwd); + // Reuse one SkillManager per workspace so repeat queries hit its in-memory + // skills cache instead of re-scanning (and re-parsing frontmatter / compiling + // globs for) every level on each call. This is a best-effort pre-child + // fallback, so the slight staleness — a skill added on disk mid-run is not + // picked up until the daemon restarts — is acceptable: the live child + // re-lists authoritatively once a session exists. + const managers = new Map(); + return (workspaceCwd) => buildWorkspaceSkillsStatus(workspaceCwd, managers); } async function buildWorkspaceSkillsStatus( workspaceCwd: string, + managers: Map, ): Promise { try { - const shim: SkillManagerConfigShim = { - // The daemon binds to an operator-chosen workspace and only lists skills - // for autocomplete (the child gates execution), so enumerate all levels - // rather than restricting to bundled-only safe mode. - isSafeMode: () => false, - getBareMode: () => false, - getProjectRoot: () => workspaceCwd, - // Extension skills need active-extension context that only the child - // has; omit them here and let the session snapshot surface them. - getActiveExtensions: () => [], - }; - const skillManager = new SkillManager(shim as Config); + let skillManager = managers.get(workspaceCwd); + if (!skillManager) { + const shim: SkillManagerConfigShim = { + // Honor the safe-mode env the same way `Config` does when no explicit + // flag is passed, so an operator running in safe mode gets the same + // bundled-only listing the child would produce. + isSafeMode: () => isSafeModeEnv(), + // Bare mode is the interactive `--bare` CLI flag; the daemon never runs + // bare, so it is always off here. + getBareMode: () => false, + getProjectRoot: () => workspaceCwd, + // Extension skills need active-extension context that only the child + // has; omit them here and let the session snapshot surface them. + getActiveExtensions: () => [], + }; + skillManager = new SkillManager(shim as Config); + managers.set(workspaceCwd, skillManager); + } const skills = await skillManager.listSkills(); return { v: STATUS_SCHEMA_VERSION, workspaceCwd, initialized: true, - skills: skills.map(mapSkill), + skills: skills.map(mapSkillConfigToStatus), }; } catch (error) { + const message = error instanceof Error ? error.message : String(error); + writeStderrLine( + `qwen serve: daemon-local skills enumeration failed for ${workspaceCwd}: ${message}`, + ); return { v: STATUS_SCHEMA_VERSION, workspaceCwd, @@ -93,24 +110,9 @@ async function buildWorkspaceSkillsStatus( { kind: 'skills', status: 'error', - error: error instanceof Error ? error.message : String(error), + error: message, }, ], }; } } - -function mapSkill(skill: SkillConfig): ServeWorkspaceSkillStatus { - const modelInvocable = skill.disableModelInvocation !== true; - return { - kind: 'skill', - status: modelInvocable ? 'ok' : 'disabled', - name: skill.name, - description: skill.description, - level: skill.level, - modelInvocable, - ...(skill.argumentHint ? { argumentHint: skill.argumentHint } : {}), - ...(skill.model ? { model: skill.model } : {}), - ...(skill.extensionName ? { extensionName: skill.extensionName } : {}), - }; -} From d7ccd966c67381e4f48e52bf2e51ee9d1a695456 Mon Sep 17 00:00:00 2001 From: Shaojin Wen Date: Thu, 2 Jul 2026 19:07:52 +0800 Subject: [PATCH 5/5] test(serve): cover daemon-local skills error path; guard the facade provider call - Test the previously-uncovered `buildWorkspaceSkillsStatus` catch branch: when enumeration fails it returns `{ initialized: false, skills: [], errors: [{ kind: 'skills', status: 'error', error }] }` and logs to stderr. Also cover the per-workspace SkillManager memoization. - Wrap the facade's `workspaceSkillsStatusProvider` call in try/catch so a throwing injected provider degrades to the idle placeholder instead of failing the request (matching getWorkspaceEnvStatus / getWorkspacePreflightStatus), with a facade test for the throw path. --- .../__tests__/facade.test.ts | 26 +++++++++++ .../cli/src/serve/workspace-service/index.ts | 13 +++++- .../src/serve/workspace-skills-status.test.ts | 46 ++++++++++++++++++- 3 files changed, 82 insertions(+), 3 deletions(-) diff --git a/packages/cli/src/serve/workspace-service/__tests__/facade.test.ts b/packages/cli/src/serve/workspace-service/__tests__/facade.test.ts index 5cd10878c1f..e5921dcc26e 100644 --- a/packages/cli/src/serve/workspace-service/__tests__/facade.test.ts +++ b/packages/cli/src/serve/workspace-service/__tests__/facade.test.ts @@ -858,6 +858,32 @@ describe('createDaemonWorkspaceService', () => { expect(result.skills.map((s) => s.name)).toEqual(['review']); }); + it('getWorkspaceSkillsStatus degrades to the idle placeholder when the daemon-local provider throws', async () => { + const queryWorkspaceStatus = vi + .fn() + .mockImplementation((_m: string, idle: () => unknown) => + Promise.resolve(idle()), + ); + const workspaceSkillsStatusProvider = vi + .fn() + .mockRejectedValue(new Error('local enumeration blew up')); + const svc = createDaemonWorkspaceService( + makeDeps({ + queryWorkspaceStatus, + workspaceSkillsStatusProvider, + boundWorkspace: '/ws', + }), + ); + + // A throwing injected provider must not fail the request. + const result = await svc.getWorkspaceSkillsStatus(makeCtx()); + + expect(workspaceSkillsStatusProvider).toHaveBeenCalledWith('/ws'); + expect(result.initialized).toBe(false); + expect(result.skills).toEqual([]); + expect(mockWriteStderrLine).toHaveBeenCalled(); + }); + it('getWorkspaceProvidersStatus uses daemon-local provider when present', async () => { const queryWorkspaceStatus = vi .fn() diff --git a/packages/cli/src/serve/workspace-service/index.ts b/packages/cli/src/serve/workspace-service/index.ts index 33bd8d78ad3..9a696bf4352 100644 --- a/packages/cli/src/serve/workspace-service/index.ts +++ b/packages/cli/src/serve/workspace-service/index.ts @@ -227,9 +227,18 @@ export function createDaemonWorkspaceService( } // ...then fall back to daemon-local enumeration, so a child that has not // answered even once (e.g. a preheat that times out under `npm run dev`) - // still yields the on-disk skills — `/review` included. + // still yields the on-disk skills — `/review` included. The provider + // handles its own errors, but it is injected, so guard the call too and + // degrade to the idle placeholder rather than failing the request — + // matching getWorkspaceEnvStatus / getWorkspacePreflightStatus. if (workspaceSkillsStatusProvider) { - return workspaceSkillsStatusProvider(boundWorkspace); + try { + return await workspaceSkillsStatusProvider(boundWorkspace); + } catch (err) { + writeStderrLine( + `qwen serve: getWorkspaceSkillsStatus local provider failed: ${err instanceof Error ? err.message : String(err)}`, + ); + } } return status; }, diff --git a/packages/cli/src/serve/workspace-skills-status.test.ts b/packages/cli/src/serve/workspace-skills-status.test.ts index 3c0fa9b68ef..7ee0ecab819 100644 --- a/packages/cli/src/serve/workspace-skills-status.test.ts +++ b/packages/cli/src/serve/workspace-skills-status.test.ts @@ -4,10 +4,22 @@ * SPDX-License-Identifier: Apache-2.0 */ -import { describe, it, expect } from 'vitest'; +import { describe, it, expect, vi, afterEach } from 'vitest'; + +const mockWriteStderrLine = vi.hoisted(() => vi.fn()); +vi.mock('../utils/stdioHelpers.js', () => ({ + writeStderrLine: mockWriteStderrLine, +})); + +import { SkillManager } from '@qwen-code/qwen-code-core'; import { createWorkspaceSkillsStatusProvider } from './workspace-skills-status.js'; describe('createWorkspaceSkillsStatusProvider', () => { + afterEach(() => { + vi.restoreAllMocks(); + mockWriteStderrLine.mockClear(); + }); + it('enumerates bundled skills (including /review) without an ACP child', async () => { const provider = createWorkspaceSkillsStatusProvider(); @@ -31,4 +43,36 @@ describe('createWorkspaceSkillsStatusProvider', () => { expect(status.workspaceCwd).toBe('/some/workspace'); }); + + it('returns a non-initialized error status (and logs) when enumeration fails', async () => { + vi.spyOn(SkillManager.prototype, 'listSkills').mockRejectedValueOnce( + new Error('boom'), + ); + const provider = createWorkspaceSkillsStatusProvider(); + + const status = await provider('/ws'); + + expect(status.initialized).toBe(false); + expect(status.skills).toEqual([]); + expect(status.workspaceCwd).toBe('/ws'); + expect(status.errors).toEqual([ + { kind: 'skills', status: 'error', error: 'boom' }, + ]); + // Non-fatal failures are logged to the daemon's stderr. + expect(mockWriteStderrLine).toHaveBeenCalledTimes(1); + expect(mockWriteStderrLine.mock.calls[0][0]).toContain('boom'); + }); + + it('reuses one SkillManager per workspace across calls', async () => { + const listSpy = vi.spyOn(SkillManager.prototype, 'listSkills'); + const provider = createWorkspaceSkillsStatusProvider(); + + await provider('/ws'); + await provider('/ws'); + + // Memoized: the second query reuses the first SkillManager instance, so + // listSkills is invoked on the same object rather than a freshly-scanned one. + expect(listSpy).toHaveBeenCalledTimes(2); + expect(listSpy.mock.instances[0]).toBe(listSpy.mock.instances[1]); + }); });