@xqyz/xq-cli 0.3.0 → 0.3.2

package/CHANGELOG.md

@@ -10,12 +10,26 @@
 
 ## [Unreleased]
 
-### WorkBuddy
+## [0.3.2] - 2026-08-17
+
+### xq-cli / WorkBuddy 规划模式
+
+- 规划模式首次 `outline --plan-mode 1` 在解析完成后明确返回“智能解读待审核”，不再误报大纲已完成或提前进入正文。
+- WorkBuddy 新增智能解读审核、补充/修正暂存和确认续跑流程；确认时才调用喜鹊 `generateDirectoryByCid` 生成大纲。
+- 新增 CLI 与 WorkBuddy 回归测试，验证同一 `cid` / `runId` 不重复提交。
+
+### xq-cli `0.3.1` / WorkBuddy `0.10.1`
+
+- 修复普通项目在后端 `task_status=6`（文件解析中）时被误判为多标包/EPC，导致没有调用正常大纲生成接口、任务长时间停留在解析状态的问题。
+- 轮询 GET 请求统一增加网络重试，并识别 `stream has been aborted`、连接提前关闭等瞬时传输错误；不会因一次流中断误报生成失败。
+- WorkBuddy 对大纲阶段的传输中断保留同一 `cid` 继续核验，禁止重复创建任务；新增回归测试覆盖该恢复路径。
+- 本次配套版本：`@xqyz/xq-cli@0.3.1`、`@xqyz/workbuddy-plugin-xique@0.10.1`、Connector `0.10.1`。
 
-- 修复计划模式默认值：未提供 `planMode` 时明确使用快速（`--plan-mode 0`），用户明确选择规划时保留 `--plan-mode 1`，不再发生模式被错误回退的问题。
-- 准备发布 WorkBuddy Plugin/Connector `0.9.4`：恢复配置页“计划模式=快速/规划”选择，并将用户选择原样传递给 xq-cli。
-- 统一 Skill、安装脚本、MCP Server 和 Connector 的版本指向，避免继续加载 `0.9.3` 的快速模式固定包。
-- 新增 [版本与迭代记录](./docs/VERSION-HISTORY.md)，记录 xq-cli、Plugin、Connector 的功能、依赖、测试和发布结果。
+### WorkBuddy / SkillHub（待发布）
+
+- 修复 SkillHub 旧版 Skill 将用户明确选择的“规划”强制改为“快速”的规则冲突；规划模式现在必须传递 `--plan-mode 1`。
+- 增加 Skill 文案回归断言，禁止再次出现“固定使用计划模式=快速”或“不得接受规划模式”。
+- 发布清单新增 SkillHub 同步、客户本地更新和新会话验收步骤，避免 npm Plugin 与 SkillHub Skill 版本脱节。
 
 ## [0.3.0] - 2026-08-14
 
@@ -26,6 +40,14 @@
 - AI 大纲候选不再生成本地伪章节 ID；最终保存请求与前端一致，仅提交章节内容、主题、重要度和续写标记，交由后台分配节点 ID。
 - 增加规划模式模拟 API 回归测试，覆盖意见提交、AI 候选不提前落库、候选确认和最终目录生成的顺序。
 
+## [0.10.0] - 2026-08-14
+
+### WorkBuddy
+
+- 固定依赖 `@xqyz/xq-cli@0.3.0`，支持完整规划模式命令链。
+- 更新 Skill、安装脚本、MCP Server、MCP App 和 Connector 启动参数到 `0.10.0`。
+- 通过 32 项 WorkBuddy 功能测试和 npm 包冒烟测试；npm `latest` 已指向 `0.10.0`。
+
 ## [0.2.1] - 2026-08-11
 
 ### 安全性

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xqyz/xq-cli",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "description": "CLI for xique bid-book task workflows",
   "type": "module",
   "scripts": {

package/src/cli.mjs

@@ -1278,7 +1278,10 @@ async function handleOutline(args, state) {
     }
     const params = buildOutlineParams(outlineSnapshot, effectiveArgs);
 
-    const triggerMode = await triggerOutlineGeneration(client, outlineSnapshot, params);
+    const planningMode = Number(params.planMode) === 1;
+    const triggerMode = planningMode
+        ? await preparePlanningAnalysis(client, params)
+        : await triggerOutlineGeneration(client, outlineSnapshot, params);
     saveTaskSnapshot(state, cid, {
         ...outlineSnapshot,
         ...pickTaskSnapshot(params),
@@ -1288,7 +1291,9 @@ async function handleOutline(args, state) {
 
     let waitResult = null;
     if (booleanOption(effectiveArgs, 'wait')) {
-        waitResult = await waitForOutlineReady(client, state, cid, outlineSnapshot.uuid, effectiveArgs);
+        waitResult = planningMode
+            ? await waitForPlanningAnalysisReady(client, state, cid, outlineSnapshot.uuid, effectiveArgs)
+            : await waitForOutlineReady(client, state, cid, outlineSnapshot.uuid, effectiveArgs);
     }
 
     const summaryLines = [
@@ -1299,7 +1304,9 @@ async function handleOutline(args, state) {
         `triggerMode: ${triggerMode}`,
     ];
 
-    if (waitResult?.phase === 'ready') {
+    if (waitResult?.phase === 'analysis_ready') {
+        summaryLines.push('planning analysis ready: review it, optionally add feedback, then run plan confirm-outline to generate the outline.');
+    } else if (waitResult?.phase === 'ready') {
         summaryLines.push(`outline ready: rootChapters=${countOutlineRoots(waitResult)}`);
     } else if (waitResult?.phase === 'supplement_required') {
         summaryLines.push(`outline blocked: supplement required (${waitResult.issues.join(', ')})`);
@@ -1849,12 +1856,16 @@ function buildOutlineParams(snapshot, args) {
 async function triggerOutlineGeneration(client, snapshot, params) {
     await postJson(client, '/task/preSet', params);
 
-    if (Number(params.planMode) === 1) {
-        await setPlanModePhase(client, params.cid, 1);
-    }
-
-    const hasTaskStatus = snapshot.task_status !== undefined && snapshot.task_status !== null;
-    if (hasTaskStatus && Number(snapshot.task_status) !== 0) {
+    // task_status=6 means "file parsing" in the Xique backend. It is not a
+    // signal that this is a multi-bid/EPC task. Only route through the
+    // special-selection endpoint when the caller actually supplied a
+    // multi-bid or EPC selection; ordinary tasks must use the normal
+    // generation endpoint even while the task is transitioning from parse.
+    const hasSpecialSelection = Boolean(
+        String(params.multiBidId ?? snapshot.multiBidId ?? '').trim()
+        || String(params.epcEngineerType ?? snapshot.epcEngineerType ?? '').trim()
+    );
+    if (hasSpecialSelection) {
         await getJson(client, '/proxy/multiBiddingChoice', compactObject({
             uuid: snapshot.uuid,
             multiBidId: params.multiBidId ?? snapshot.multiBidId,
@@ -1867,6 +1878,13 @@ async function triggerOutlineGeneration(client, snapshot, params) {
     return 'generateByRequirement';
 }
 
+async function preparePlanningAnalysis(client, params) {
+    // The backend intentionally pauses plan-mode tasks after parsing. The user
+    // must review that analysis before generateDirectoryByCid starts the outline.
+    await postJson(client, '/task/preSet', params);
+    return 'planningAnalysisPrepared';
+}
+
 async function setPlanModePhase(client, cid, planModePhase) {
     const response = await postJson(client, '/task/setPlanModePhase', { cid, planModePhase });
     const returned = normalizePlanModePhase(response?.data?.planModePhase);
@@ -2361,6 +2379,79 @@ async function waitForOutlineReady(client, state, cid, uuid, args) {
     });
 }
 
+async function waitForPlanningAnalysisReady(client, state, cid, uuid, args) {
+    const handledIssues = new Set();
+
+    return pollUntil(async () => {
+        const taskResponse = await getJson(client, `/task/getTaskDetail/${encodeURIComponent(cid)}`);
+        const taskDetail = taskResponse?.data || {};
+        saveTaskSnapshot(state, cid, pickTaskSnapshot(taskDetail));
+
+        if (Number(taskDetail.task_status) === 7) {
+            return {
+                done: true,
+                data: { phase: 'failed', taskDetail },
+                progressLabel: 'task_status=7',
+            };
+        }
+
+        const parseStatus = uuid
+            ? await fetchParseStatus(client, state, cid, uuid)
+            : { success: 1 };
+        const parseSuccess = Number(parseStatus.success);
+        const issues = collectParseIssues(parseStatus);
+        if (parseSuccess === 4 && issues.length > 0) {
+            const autoIgnore = resolveAutoIgnoreIssue(issues, args, uuid, handledIssues);
+            if (autoIgnore) {
+                await submitIntermediateChoice(client, autoIgnore.payload);
+                handledIssues.add(autoIgnore.issue);
+                return {
+                    done: false,
+                    data: null,
+                    progressLabel: `ignored ${autoIgnore.issue}, waiting planning analysis`,
+                };
+            }
+            return {
+                done: true,
+                data: {
+                    phase: 'supplement_required',
+                    issues,
+                    parseStatus,
+                    taskDetail,
+                },
+                progressLabel: `supplement_required=${issues.join(',')}`,
+            };
+        }
+
+        if (parseSuccess === 1 || (
+            parseSuccess > 0
+            && String(taskDetail.requirement || '').trim()
+            && String(taskDetail.rating || '').trim()
+        )) {
+            return {
+                done: true,
+                data: {
+                    phase: 'analysis_ready',
+                    taskDetail,
+                    parseStatus,
+                },
+                progressLabel: 'planning analysis ready; waiting for outline confirmation',
+            };
+        }
+
+        return {
+            done: false,
+            data: null,
+            progressLabel: `success=${parseSuccess}, task_status=${taskDetail.task_status ?? '-'}, planning analysis pending`,
+        };
+    }, {
+        intervalMs: secondsToMs(numberOption(args, 'intervalSec', DEFAULT_TASK_INTERVAL_MS / 1000)),
+        timeoutMs: secondsToMs(numberOption(args, 'timeoutSec', DEFAULT_TIMEOUT_MS / 1000)),
+        quiet: booleanOption(args, 'json'),
+        waitingText: 'waiting planning analysis',
+    });
+}
+
 async function pollContentUntilReady(client, state, cid, args) {
     let unfinishedTriggered = false;
     let lastUnfinishedTriggerAt = 0;
@@ -2760,7 +2851,23 @@ function isContentRunningOrDone(detail) {
 async function pollUntil(checkFn, options) {
     const startedAt = Date.now();
     while (true) {
-        const result = await checkFn();
+        let result;
+        try {
+            result = await checkFn();
+        } catch (error) {
+            // A transient connection reset must not turn an already accepted
+            // asynchronous backend task into a false failure. Read requests
+            // are retried by getJson; this catch keeps polling the same cid
+            // when a response stream still closes during that retry window.
+            if (!isRetryableNetworkError(error)) {
+                throw error;
+            }
+            result = {
+                done: false,
+                data: null,
+                progressLabel: `transient network error; retrying (${String(error?.message || error)})`,
+            };
+        }
         if (result.done) {
             return result.data;
         }
@@ -3908,7 +4015,10 @@ function normalizeApiKey(value) {
 async function getJson(client, url, params = {}, options = {}) {
     const response = await requestWithRetry(async () => {
         return client.get(url, { params });
-    }, options);
+    }, {
+        retries: DEFAULT_RETRY_COUNT,
+        ...options,
+    });
     return unwrapApiResponse(response);
 }
 
@@ -3964,7 +4074,7 @@ function isRetryableNetworkError(error) {
     if (RETRYABLE_NETWORK_CODES.has(code)) {
         return true;
     }
-    return /socket disconnected|econnreset|tls connection|network error|timeout/i.test(message);
+    return /socket disconnected|econnreset|tls connection|network error|timeout|stream has been aborted|socket hang up|premature close|aborted/i.test(message);
 }
 
 function unwrapApiResponse(response) {