@xqyz/xq-cli 0.3.1 → 0.3.2

package/CHANGELOG.md

@@ -10,6 +10,14 @@
 
 ## [Unreleased]
 
+## [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，导致没有调用正常大纲生成接口、任务长时间停留在解析状态的问题。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xqyz/xq-cli",
-  "version": "0.3.1",
+  "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,10 +1856,6 @@ 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);
-    }
-
     // 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
@@ -1875,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);
@@ -2369,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;