@xqyz/xq-cli 0.3.14 → 0.3.16

package/src/cli.mjs

@@ -40,6 +40,7 @@ const DEFAULT_TIMEOUT_MS = 10 * 60 * 1000;
 // outline polling timeout.
 const DEFAULT_PARSER_WAKEUP_TIMEOUT_MS = 30_000;
 const PARSER_WAKEUP_INTERVAL_MS = 2_000;
+const KNOWN_PARSE_SUCCESS_CODES = new Set([0, 1, 2, 3, 4]);
 const DEFAULT_SOURCE_FROM = 'xique';
 const DEFAULT_LOGIN_TIMEOUT_MS = 5 * 60 * 1000;
 const API_KEY_MANAGEMENT_URL = 'https://xiquebiaoshu.com/account/api-keys';
@@ -397,9 +398,32 @@ async function main() {
         case 'period-confirm':
             await handlePeriodConfirm(parsed, state);
             return;
+        case 'page-scope-status':
+            await handlePageScopeStatus(parsed, state);
+            return;
+        case 'page-scope-accept':
+            await handlePageScopeAccept(parsed, state);
+            return;
+        case 'commercial-status':
+            await handleCommercialStatus(parsed, state);
+            return;
+        case 'commercial-confirm':
+            await handleCommercialConfirm(parsed, state);
+            return;
+        case 'company-list':
+            await handleCompanyList(parsed, state);
+            return;
         case 'bidder-role':
             await handleBidderRole(parsed, state);
             return;
+        case 'basis-select':
+        case 'directory-basis':
+            await handleBasisSelection(parsed, state);
+            return;
+        case 'supplement':
+        case 'score-supplement':
+            await handleSupplement(parsed, state);
+            return;
         case 'outline':
             if (isOutlineAction(parsed, ['view', 'show'])) {
                 await handleOutlineView(parsed, state);
@@ -469,7 +493,14 @@ Commands
   parse-status  Query or wait for parse completion
   period-status Query engineering project period confirmation status
   period-confirm Save confirmed engineering project period
+  page-scope-status Check whether the current outline supports the selected page scope
+  page-scope-accept Accept the backend's recommended page scope
+  commercial-status Query commercial bid framework status
+  commercial-confirm Confirm use of the commercial default framework
+  company-list  Query selectable bidder companies for commercial bids
   bidder-role  Save the bidder's goods supply method for the current task
+  basis-select  Save the parsing-stage outline basis for the current task
+  supplement   Submit missing requirement / bill / score / directory content and continue the same task
   outline       Pre-set task params and trigger outline generation
   outline view  View the current outline without triggering generation
   outline update Update the current outline from an edited JSON file
@@ -501,7 +532,13 @@ Examples
   $env:XQ_API_KEY="xq_sk_xxx"
   xq-cli init --file D:\\bids\\tender.docx --wait
   xq-cli parse-status --cid <cid> --uuid <uuid> --wait
+  xq-cli commercial-status --cid <cid> --wait
+  xq-cli commercial-confirm --cid <cid> --wait
+  xq-cli company-list --json
   xq-cli bidder-role --cid <cid> --uuid <uuid> --bidder-role <1|2>
+  xq-cli basis-select --cid <cid> --uuid <uuid> --basis <scoreAndDir|scoreOnly|dirOnly> --wait
+  xq-cli supplement --cid <cid> --uuid <uuid> --type score --text "评分细则..." --wait
+  xq-cli supplement --cid <cid> --uuid <uuid> --type score --file D:\\bids\\score.docx --wait
   xq-cli choices
   xq-cli choices outline --json
   xq-cli gallery-status --json
@@ -541,13 +578,19 @@ Common options
   --timeout-sec <n>  Poll timeout in seconds, default 600
   --interval-sec <n> Poll interval in seconds, default 10
   --reference-type <0|1|2>  Outline reference choice: 0=merge, 1=format only, 2=score only
+  --basis <scoreAndDir|scoreOnly|dirOnly>  Parsing-stage outline basis choice
   --bidder-role <1|2>      Goods supply method: 1=self production, 2=procured supply
+  --supplement-type/--type <type> Missing content type: score, requirement, billOfQuantities, or directory
+  --text <content>         Text content for a supplement (HTML is accepted)
+  --file <path>            Supplement file path (.doc/.docx/.pdf/.xls/.xlsx)
+  --ignore                  Explicitly skip a skippable missing-content check
   --api-key <key>    Save a user API key locally and verify it with /user/info
   --no-open          Do not open the local login page automatically
   --interactive      Open prompt menus for the current command
   --dry-run          Preview an outline update without saving it
   --yes              Confirm an outline update without an interactive prompt
   --allow-delete     Allow an outline update that removes existing chapters
+  --check-id <id>    Page-scope check ID returned by page-scope-status
   --ignore-short-requirement  Follow the frontend ignore/continue path for requirement_judgement=0
   --ignore-missing-bill       Follow the frontend ignore/continue path for billOfQuantities_judgement=0
 
@@ -771,6 +814,7 @@ async function handleInit(args, state) {
         cid,
         uuid: snapshot.uuid,
         title: snapshot.projectName || snapshot.title,
+        originType: snapshot.originType,
         files,
         fileTypes: fileMeta.types,
         parseResult: finalParse,
@@ -880,6 +924,216 @@ async function handlePeriodConfirm(args, state) {
     return payload;
 }
 
+async function handlePageScopeStatus(args, state) {
+    const client = createAuthorizedClient(args, state);
+    const cid = resolveCid(args, state);
+    const result = await checkPageScopeBeforeWrite(client, state, cid, args);
+    const payload = {
+        command: 'page-scope-status',
+        cid,
+        ...result,
+    };
+    outputResult(args, payload, [
+        `page-scope check: cid=${cid}`,
+        `phase: ${result.phase}`,
+        `checkStatus: ${result.pageScopeResult?.checkStatus ?? '-'}`,
+        result.phase === 'confirmation_required'
+            ? `confirmation required: target=${result.pageScopeResult?.targetPageScope ?? '-'}, recommended=${result.pageScopeResult?.recommendedPageScope ?? '-'}`
+            : result.phase === 'passed'
+                ? 'selected page scope is supported by the current outline'
+                : 'page-scope response is not recognized; do not start content generation',
+    ]);
+    return payload;
+}
+
+async function handlePageScopeAccept(args, state) {
+    const client = createAuthorizedClient(args, state);
+    const cid = resolveCid(args, state);
+    const checkId = requiredOption(args, 'checkId');
+    const authoritativeState = await fetchAuthoritativeTaskState(client, cid);
+    assertContentGenerationAllowed(authoritativeState, '接受建议篇幅');
+    const response = await postJson(client, '/task/acceptRecommendedPageScope', {
+        cid,
+        checkId: String(checkId),
+    });
+    const payload = {
+        command: 'page-scope-accept',
+        cid,
+        checkId: String(checkId),
+        accepted: true,
+        response,
+    };
+    outputResult(args, payload, [
+        `recommended page scope accepted: cid=${cid}`,
+        `checkId: ${String(checkId)}`,
+        'content generation has not been triggered; rerun write for the same cid.',
+    ]);
+    return payload;
+}
+
+async function handleCommercialStatus(args, state) {
+    const client = createAuthorizedClient(args, state);
+    const cid = resolveCid(args, state);
+    const taskResponse = await getJson(client, `/task/getTaskDetail/${encodeURIComponent(cid)}`, {}, { retries: DEFAULT_RETRY_COUNT });
+    const taskDetail = taskResponse?.data || {};
+    const originType = Number(taskDetail.originType);
+    if (originType !== 3) {
+        const payload = {
+            command: 'commercial-status',
+            cid,
+            originType: taskDetail.originType,
+            phase: 'not-commercial',
+            commercial: false,
+            taskDetail,
+        };
+        outputResult(args, payload, [
+            `commercial framework: cid=${cid}`,
+            'commercial framework is not required for this task',
+        ]);
+        return payload;
+    }
+
+    const result = booleanOption(args, 'wait')
+        ? await pollCommercialFrameworkUntilReady(client, cid, args)
+        : await fetchCommercialFrameworkStatus(client, cid);
+    const payload = {
+        command: 'commercial-status',
+        cid,
+        originType,
+        commercial: true,
+        ...result,
+    };
+    saveTaskSnapshot(state, cid, {
+        originType,
+        commercialFrameworkPhase: payload.phase,
+        commercialFrameworkStatus: payload.data,
+        commercialFrameworkCheckedAt: new Date().toISOString(),
+    });
+    outputResult(args, payload, [
+        `commercial framework: cid=${cid}`,
+        `phase: ${payload.phase}`,
+        `task_status: ${payload.data?.task_status ?? '-'}`,
+        `directories_ready: ${String(payload.data?.directories_ready ?? false)}`,
+        payload.phase === 'commercial_default_template_required'
+            ? 'confirmation required: use the default commercial bid framework'
+            : payload.phase === 'commercial_framework_ready'
+                ? 'commercial framework is ready; content generation may continue'
+                : payload.phase === 'commercial_framework_failed'
+                    ? `commercial framework failed: ${payload.data?.status_msg || payload.data?.status_message || '-'}`
+                    : 'commercial framework is still running',
+    ]);
+    return payload;
+}
+
+async function handleCommercialConfirm(args, state) {
+    const client = createAuthorizedClient(args, state);
+    const cid = resolveCid(args, state);
+    const taskResponse = await getJson(client, `/task/getTaskDetail/${encodeURIComponent(cid)}`, {}, { retries: DEFAULT_RETRY_COUNT });
+    if (Number(taskResponse?.data?.originType) !== 3) {
+        throw new Error('当前任务不是商务标，无需确认默认标书框架。');
+    }
+    const response = await postJson(client, '/commercial/default-template/confirm', { cid });
+    const status = booleanOption(args, 'wait')
+        ? await pollCommercialFrameworkUntilReady(client, cid, args)
+        : await fetchCommercialFrameworkStatus(client, cid);
+    const payload = {
+        command: 'commercial-confirm',
+        cid,
+        confirmationResponse: response,
+        ...status,
+    };
+    saveTaskSnapshot(state, cid, {
+        commercialFrameworkPhase: payload.phase,
+        commercialFrameworkStatus: payload.data,
+        commercialFrameworkConfirmedAt: new Date().toISOString(),
+    });
+    outputResult(args, payload, [
+        `commercial framework confirmed: cid=${cid}`,
+        `phase: ${payload.phase}`,
+        payload.phase === 'commercial_framework_ready'
+            ? 'commercial framework is ready; content generation may continue'
+            : 'commercial framework confirmation accepted; continue polling the same cid',
+    ]);
+    return payload;
+}
+
+async function handleCompanyList(args, state) {
+    const client = createAuthorizedClient(args, state);
+    const response = await postJson(client, '/xq/enterprise/company/list', {});
+    const rawList = response?.data?.list ?? response?.data ?? [];
+    const companies = (Array.isArray(rawList) ? rawList : [])
+        .map(item => {
+            if (!item || typeof item !== 'object') return null;
+            const id = String(item.id ?? item.companyId ?? '').trim();
+            const name = String(item.name ?? item.companyName ?? '').trim();
+            if (!id || !name) return null;
+            return {
+                id,
+                name,
+                industry: String(item.industry ?? '').trim(),
+                registeredCapital: String(item.registeredCapital ?? '').trim(),
+            };
+        })
+        .filter(Boolean);
+    const payload = {
+        command: 'company-list',
+        companies,
+        total: companies.length,
+    };
+    outputResult(args, payload, [
+        `bidder companies: ${companies.length}`,
+        ...companies.map(company => `${company.id}: ${company.name}`),
+    ]);
+    return payload;
+}
+
+async function fetchCommercialFrameworkStatus(client, cid) {
+    const response = await getJson(client, '/commercial/task/status', { cid }, { retries: DEFAULT_RETRY_COUNT });
+    const data = response?.data || {};
+    return {
+        phase: classifyCommercialFrameworkPhase(data),
+        data,
+    };
+}
+
+async function pollCommercialFrameworkUntilReady(client, cid, args) {
+    return pollUntil(async () => {
+        const result = await fetchCommercialFrameworkStatus(client, cid);
+        const terminal = [
+            'commercial_framework_ready',
+            'commercial_default_template_required',
+            'commercial_framework_failed',
+        ].includes(result.phase);
+        return {
+            done: terminal,
+            data: result,
+            progressLabel: `phase=${result.phase}, task_status=${result.data?.task_status ?? '-'}, directories_ready=${String(result.data?.directories_ready ?? false)}`,
+        };
+    }, {
+        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 commercial framework',
+    });
+}
+
+function classifyCommercialFrameworkPhase(data = {}) {
+    const taskStatus = Number(data.task_status);
+    const fallback = data.fallback_confirm_required === true
+        || data.fallback_confirm_required === 1
+        || ['1', 'true'].includes(String(data.fallback_confirm_required || '').trim().toLowerCase())
+        || taskStatus === 6;
+    if (fallback) return 'commercial_default_template_required';
+    // task_status=4 is downstream body processing; it does not mean the
+    // commercial framework construction failed when directories are ready.
+    if (taskStatus === 2) return 'commercial_framework_failed';
+    const ready = [true, 1, '1', 'true'].includes(
+        typeof data.directories_ready === 'string' ? data.directories_ready.trim().toLowerCase() : data.directories_ready,
+    );
+    if (ready) return 'commercial_framework_ready';
+    return 'commercial_framework_pending';
+}
+
 async function handleBidderRole(args, state) {
     const client = createAuthorizedClient(args, state);
     const cid = resolveCid(args, state);
@@ -915,6 +1169,312 @@ async function handleBidderRole(args, state) {
     return payload;
 }
 
+async function handleBasisSelection(args, state) {
+    const client = createAuthorizedClient(args, state);
+    const cid = resolveCid(args, state);
+    const snapshot = await hydrateTaskSnapshot(client, state, cid);
+    const uuid = stringOption(args, 'uuid', snapshot.uuid);
+    if (!uuid) {
+        throw new Error(`No uuid found for task ${cid}. Pass --uuid explicitly or run init first.`);
+    }
+
+    const basis = normalizeDirectoryBasis(stringOptionAny(args, ['basis', 'directoryBasis']));
+    if (!basis) {
+        throw new Error('Option --basis expects scoreAndDir, scoreOnly, or dirOnly.');
+    }
+    if (snapshot.directoryBasisSubmittedAt) {
+        if (snapshot.directoryBasis === basis) {
+            const payload = {
+                command: 'basis-select',
+                cid,
+                uuid,
+                basis,
+                alreadyApplied: true,
+                duplicateRequestPrevented: true,
+            };
+            outputResult(args, payload, [
+                `outline basis already applied: cid=${cid}, basis=${basis}`,
+                'duplicate request prevented; continue querying the same task.',
+            ]);
+            return payload;
+        }
+        throw new Error('该任务的解析阶段大纲依据已经提交，不能二次修改；请继续查询同一 cid。');
+    }
+
+    const parseStatus = await fetchParseStatus(client, state, cid, uuid);
+    const issues = collectParseIssues(parseStatus);
+    if (!issues.includes('scoreAndDirectory_judgement')) {
+        throw new Error('当前任务不在解析阶段大纲依据选择状态，请先查询 parse-status。');
+    }
+
+    const response = await getJson(client, '/proxy/saveDirectoryBasis', {
+        uuid,
+        basis,
+    });
+    saveTaskSnapshot(state, cid, {
+        uuid,
+        directoryBasis: basis,
+        directoryBasisSubmittedAt: new Date().toISOString(),
+        directoryBasisIssue: 'scoreAndDirectory_judgement',
+    });
+
+    const waitResult = booleanOption(args, 'wait')
+        ? await waitAfterSupplement(client, state, cid, uuid, args, 'scoreAndDirectory_judgement')
+        : null;
+    const payload = {
+        command: 'basis-select',
+        cid,
+        uuid,
+        basis,
+        response,
+        waitResult,
+    };
+    outputResult(args, payload, [
+        `outline basis submitted: cid=${cid}`,
+        `basis: ${basis} (${describeDirectoryBasis(basis)})`,
+        waitResult?.phase === 'ready'
+            ? 'same task outline is ready for review.'
+            : waitResult?.phase === 'analysis_ready'
+                ? 'same task analysis is ready; confirm outline generation next.'
+                : waitResult?.phase === 'basis_selection_required'
+                    ? 'same task still requires outline basis selection; do not submit a second choice.'
+                    : waitResult?.phase === 'reference_selection_required'
+                        ? 'same task now requires an explicit outline reference selection.'
+                        : waitResult?.phase === 'bidder_role_required'
+                            ? 'same task now requires a bidder supply-role selection.'
+                            : booleanOption(args, 'wait')
+                                ? 'same task is continuing; query status for the next stage.'
+                                : 'submission accepted; use parse-status or outline --wait to continue polling the same task.',
+    ]);
+    return payload;
+}
+
+function normalizeDirectoryBasis(value) {
+    const normalized = String(value || '').trim().toLowerCase();
+    const aliases = {
+        scoreanddir: 'scoreAndDir',
+        scoreanddirectory: 'scoreAndDir',
+        merge: 'scoreAndDir',
+        '融合评分和参考目录': 'scoreAndDir',
+        scoreonly: 'scoreOnly',
+        score: 'scoreOnly',
+        '仅依据评分': 'scoreOnly',
+        dironly: 'dirOnly',
+        directoryonly: 'dirOnly',
+        format: 'dirOnly',
+        '仅依据参考目录': 'dirOnly',
+    };
+    return aliases[normalized] || aliases[String(value || '').trim()] || '';
+}
+
+function describeDirectoryBasis(value) {
+    return {
+        scoreAndDir: '融合评分和参考目录',
+        scoreOnly: '仅依据评分',
+        dirOnly: '仅依据参考目录',
+    }[value] || value;
+}
+
+async function handleSupplement(args, state) {
+    const client = createAuthorizedClient(args, state);
+    const cid = resolveCid(args, state);
+    const snapshot = await hydrateTaskSnapshot(client, state, cid);
+    const uuid = stringOption(args, 'uuid', snapshot.uuid);
+    if (!uuid) {
+        throw new Error(`No uuid found for task ${cid}. Pass --uuid explicitly or run init first.`);
+    }
+
+    const issue = normalizeSupplementIssue(stringOptionAny(args, ['issue', 'supplementIssue']));
+    const type = normalizeSupplementType(stringOptionAny(args, ['supplementType', 'type']), issue);
+    const filePath = stringOption(args, 'file', stringOption(args, 'scoreFile'));
+    const text = stringOptionAny(args, ['text', 'content', 'score', 'requirement', 'directory']);
+    const ignore = booleanOption(args, 'ignore');
+    if (filePath && text) {
+        throw new Error('补充内容只能选择 --text 或 --file 其中一种。');
+    }
+    if (!ignore && !filePath && !text) {
+        throw new Error('补充内容需要 --text <内容> 或 --file <路径>；跳过可补充项时才使用 --ignore。');
+    }
+    if (ignore && (filePath || text)) {
+        throw new Error('--ignore 不能和 --text/--file 同时使用。');
+    }
+    if (!ignore && type === 'billOfQuantities' && text && !filePath) {
+        throw new Error('工程量清单请使用 --file 上传，网页端不支持直接输入文本。');
+    }
+    if (!ignore && type === 'directory' && filePath) {
+        throw new Error('技术方案目录要求请使用 --text 输入，网页端不支持以文件补充。');
+    }
+    if (filePath) {
+        ensureFileExists(filePath);
+    }
+
+    const currentIssues = collectParseIssues(await fetchParseStatus(client, state, cid, uuid));
+    const targetIssue = issue || currentIssues.find(item => issueType(item) === type) || currentIssues[0] || '';
+    if (ignore && (!targetIssue || !AUTO_IGNORE_ISSUE_CONFIG[targetIssue])) {
+        throw new Error('当前任务没有可忽略的对应解析问题；请传 --issue <问题字段>，或使用评分/需求补充内容。');
+    }
+    const payload = ignore
+        ? AUTO_IGNORE_ISSUE_CONFIG[targetIssue].buildPayload(uuid)
+        : filePath
+            ? null
+            : buildSupplementPayload(uuid, type, text);
+    const response = filePath
+        ? await submitSupplementFile(client, uuid, type, filePath)
+        : await submitIntermediateChoice(client, payload);
+
+    saveTaskSnapshot(state, cid, {
+        uuid,
+        supplementIssue: targetIssue,
+        supplementType: type,
+        supplementSubmittedAt: new Date().toISOString(),
+        ...(ignore ? { [targetIssue + '_ignored']: true } : {}),
+    });
+
+    const waitResult = booleanOption(args, 'wait')
+        ? await waitAfterSupplement(client, state, cid, uuid, args, targetIssue)
+        : null;
+    const resultPayload = {
+        command: 'supplement',
+        cid,
+        uuid,
+        issue: targetIssue || null,
+        type,
+        mode: ignore ? 'ignore' : filePath ? 'file' : 'text',
+        file: filePath || null,
+        response,
+        waitResult,
+    };
+    outputResult(args, resultPayload, [
+        `supplement submitted: cid=${cid}`,
+        `type: ${type}`,
+        `mode: ${resultPayload.mode}`,
+        targetIssue ? `issue: ${targetIssue}` : '',
+        waitResult?.phase === 'ready'
+            ? 'same task outline is ready for review.'
+            : waitResult?.phase === 'analysis_ready'
+                ? 'same task analysis is ready; confirm outline generation next.'
+                : waitResult?.phase === 'basis_selection_required'
+                    ? 'same task now requires an explicit parsing-stage outline basis selection.'
+                    : waitResult?.phase === 'reference_selection_required'
+                        ? 'same task now requires an explicit outline reference selection.'
+                        : waitResult?.phase === 'bidder_role_required'
+                            ? 'same task now requires a bidder supply-role selection.'
+                            : booleanOption(args, 'wait')
+                                ? 'same task is continuing; query status for the next stage.'
+                                : 'submission accepted; use --wait to continue polling the same task.',
+    ].filter(Boolean));
+    return resultPayload;
+}
+
+function normalizeSupplementIssue(value) {
+    if (!value) return '';
+    const aliases = {
+        requirement: 'requirement_exist',
+        requirement_short: 'requirement_judgement',
+        bill: 'billOfQuantities_judgement',
+        billOfQuantities: 'billOfQuantities_judgement',
+        score: 'score_judgement',
+        directory: 'directory_judgement',
+        basis: 'scoreAndDirectory_judgement',
+        bidder: 'bidderIdentity_judgement',
+    };
+    const normalized = String(value).trim();
+    return aliases[normalized] || normalized;
+}
+
+function normalizeSupplementType(value, issue = '') {
+    const normalized = String(value || '').trim().toLowerCase();
+    const aliases = {
+        score: 'score',
+        rating: 'score',
+        requirement: 'requirement',
+        demand: 'requirement',
+        bill: 'billOfQuantities',
+        billofquantities: 'billOfQuantities',
+        directory: 'directory',
+    };
+    if (normalized && aliases[normalized]) return aliases[normalized];
+    if (issue) return issueType(issue);
+    throw new Error('补充类型必须是 score、requirement、billOfQuantities 或 directory。');
+}
+
+function issueType(issue) {
+    if (issue === 'score_judgement') return 'score';
+    if (issue === 'billOfQuantities_judgement') return 'billOfQuantities';
+    if (issue === 'directory_judgement') return 'directory';
+    return 'requirement';
+}
+
+function buildSupplementPayload(uuid, type, text) {
+    const payload = {
+        uuid,
+        requirement: '',
+        score: '',
+        type,
+    };
+    if (type === 'score') payload.score = String(text || '').trim();
+    else if (type === 'directory') {
+        payload.directory = String(text || '').trim();
+        payload.modify = 1;
+    } else payload.requirement = String(text || '').trim();
+    if (!payload.score && !payload.requirement && !payload.directory) {
+        throw new Error('补充文本不能为空。');
+    }
+    return payload;
+}
+
+async function submitSupplementFile(client, uuid, type, filePath) {
+    const formData = new FormData();
+    formData.append('uuid', uuid);
+    formData.append('type', type);
+    formData.append('files', fs.createReadStream(filePath), path.basename(filePath));
+    return postForm(client, '/proxy/formatFileExtend/upload', formData);
+}
+
+async function waitAfterSupplement(client, state, cid, uuid, args, targetIssue = '') {
+    await waitForSupplementParseResolution(client, state, cid, uuid, args, normalizeSupplementIssue(targetIssue));
+    const task = await getJson(client, `/task/getTaskDetail/${encodeURIComponent(cid)}`, {}, { retries: DEFAULT_RETRY_COUNT });
+    // The mode was explicitly confirmed when the task was created. Prefer an
+    // explicit continuation argument, then that durable local snapshot, and
+    // only use the backend mirror as a fallback because older deployments may
+    // briefly omit or return a stale planMode after a supplement request.
+    const planning = Number(
+        args?.planMode
+        ?? args?.plan_mode
+        ?? state.tasks?.[cid]?.planMode
+        ?? task?.data?.planMode
+        ?? task?.data?.plan_mode,
+    ) === 1;
+    return planning
+        ? waitForPlanningAnalysisReady(client, state, cid, uuid, args)
+        : waitForOutlineReady(client, state, cid, uuid, args);
+}
+
+async function waitForSupplementParseResolution(client, state, cid, uuid, args, targetIssue = '') {
+    if (!targetIssue) return;
+    await pollUntil(async () => {
+        const result = await fetchParseStatus(client, state, cid, uuid);
+        const issues = collectParseIssues(result);
+        // The parsing-stage basis choice is acknowledged by a dedicated
+        // backend endpoint. Do not treat success=1/2 as resolved while the
+        // same judgement flag is still zero; that would make the continuation
+        // worker report a false next stage and could expose a duplicate card.
+        const resolved = !issues.includes(targetIssue)
+            || (targetIssue !== 'scoreAndDirectory_judgement'
+                && (Number(result.success) === 1 || Number(result.success) === 2));
+        return {
+            done: resolved,
+            data: result,
+            progressLabel: `success=${result.success}, pending=${issues.join(',') || 'none'}`,
+        };
+    }, {
+        intervalMs: secondsToMs(numberOption(args, 'intervalSec', DEFAULT_PARSE_INTERVAL_MS / 1000)),
+        timeoutMs: secondsToMs(numberOption(args, 'timeoutSec', DEFAULT_TIMEOUT_MS / 1000)),
+        quiet: booleanOption(args, 'json'),
+        waitingText: 'waiting supplement parse result',
+    });
+}
+
 function handleChoices(args) {
     const scope = normalizeChoicesScope(args._[1] || 'all');
     const payload = buildChoicesPayload(scope);
@@ -966,6 +1526,33 @@ async function handleWizard(args, state) {
         interactive: false,
     }, state);
 
+    // A wizard is still a staged workflow. If outline generation pauses for
+    // any user action, stop here and return the durable task identifiers so
+    // the caller can resume the same cid instead of starting body generation
+    // with an incomplete outline.
+    const outlinePhase = outlineResult?.waitResult?.phase || outlineResult?.phase || '';
+    const outlineReady = outlinePhase === 'ready'
+        || Boolean(outlineResult?.waitResult?.outlineDetail)
+        || Boolean(outlineResult?.waitResult?.contentDetail);
+    if (!outlineReady) {
+        const resultPayload = {
+            command: 'wizard',
+            cid,
+            initResult,
+            outlineResult,
+            writeResult: null,
+            exportResult: null,
+            paused: true,
+            phase: outlinePhase || 'outline_pending',
+        };
+        outputResult(args, resultPayload, [
+            `wizard paused: cid=${cid}`,
+            `phase: ${outlinePhase || 'outline_pending'}`,
+            'resume the required confirmation or supplement on the same cid before generating content.',
+        ]);
+        return resultPayload;
+    }
+
     const writeResult = await handleWrite({
         ...wizardArgs,
         _: ['write'],
@@ -974,6 +1561,29 @@ async function handleWizard(args, state) {
         interactive: false,
     }, state);
 
+    const writeReady = Boolean(writeResult?.waitResult?.task_status)
+        || Boolean(writeResult?.waitResult?.content_portion_status)
+        || Boolean(writeResult?.writePreparation?.viewStep)
+        || writeResult?.directoryWaitResult?.phase === 'ready';
+    if (!writeReady) {
+        const resultPayload = {
+            command: 'wizard',
+            cid,
+            initResult,
+            outlineResult,
+            writeResult: writeResult || null,
+            exportResult: null,
+            paused: true,
+            phase: writeResult?.directoryWaitResult?.phase || 'content_pending',
+        };
+        outputResult(args, resultPayload, [
+            `wizard paused before export: cid=${cid}`,
+            `phase: ${resultPayload.phase}`,
+            'resume the same task after its directory or content stage is ready.',
+        ]);
+        return resultPayload;
+    }
+
     const exportResult = await handleExport({
         ...wizardArgs,
         _: ['export'],
@@ -1495,9 +2105,21 @@ async function handleOutlineUnlocked(args, state) {
         for (const hint of collectIssueHints(waitResult.issues, args)) {
             summaryLines.push(hint);
         }
+    } else if (waitResult?.phase === 'basis_selection_required') {
+        summaryLines.push('outline blocked: parsing-stage outline basis selection required');
+        summaryLines.push('hint: run xq-cli basis-select --cid <cid> --uuid <uuid> --basis <scoreAndDir|scoreOnly|dirOnly> --wait.');
+    } else if (waitResult?.phase === 'special_config_required') {
+        summaryLines.push('outline blocked: EPC project scope selection required');
+        summaryLines.push('hint: choose the EPC writing scope from the parsed backend options, then rerun outline for the same cid.');
     } else if (waitResult?.phase === 'reference_selection_required') {
         summaryLines.push('outline blocked: reference selection required');
         summaryLines.push('hint: rerun with --wait in an interactive terminal, or pass --reference-type <0|1|2>.');
+    } else if (waitResult?.phase === 'bidder_role_required') {
+        summaryLines.push('outline blocked: bidder role selection required');
+        summaryLines.push('hint: run xq-cli bidder-role --cid <cid> --uuid <uuid> --bidder-role <1|2>, then continue polling the same task.');
+    } else if (waitResult?.phase === 'unsupported_intermediate_state') {
+        summaryLines.push(`outline blocked: unsupported backend interaction (${waitResult.issues.join(', ')})`);
+        summaryLines.push('hint: upgrade xq-cli/WorkBuddy to a version that supports this backend interaction; the same cid remains available for recovery.');
     } else if (waitResult?.phase === 'failed') {
         summaryLines.push(`outline failed: task_status=${waitResult.taskDetail?.task_status ?? '-'}`);
     } else {
@@ -1844,6 +2466,30 @@ async function handleWriteUnlocked(args, state) {
     assertContentGenerationAllowed(contentDetail.data, '生成正文');
     saveTaskSnapshot(state, cid, pickTaskSnapshot(contentDetail.data));
 
+    const pageScopeResult = await checkPageScopeBeforeWrite(client, state, cid, args);
+    if (pageScopeResult.phase !== 'passed') {
+        const blockedPayload = {
+            command: 'write',
+            cid,
+            type,
+            directoryWaitResult,
+            pageScopeResult,
+            writePreparation: null,
+            triggerResult: null,
+            waitResult: null,
+        };
+        outputResult(args, blockedPayload, [
+            `content generation blocked: cid=${cid}`,
+            pageScopeResult.phase === 'confirmation_required'
+                ? 'page-scope confirmation required before charging or starting content'
+                : 'page-scope check returned an unsupported state; content was not started',
+            pageScopeResult.pageScopeResult?.checkId
+                ? `checkId: ${pageScopeResult.pageScopeResult.checkId}`
+                : '',
+        ].filter(Boolean));
+        return blockedPayload;
+    }
+
     const writePreparation = await prepareContentGeneration(client, state, cid, contentDetail, args);
     let triggerResult = null;
     if (writePreparation.shouldTrigger) {
@@ -1859,6 +2505,15 @@ async function handleWriteUnlocked(args, state) {
     if (booleanOption(args, 'wait')) {
         status = await pollContentUntilReady(client, state, cid, args);
     }
+    if (status?.phase === 'failed') {
+        throw new Error(
+            '[CONTENT_GENERATION_FAILED] 喜鹊后台报告正文生成失败，task_status='
+            + String(status.task_status ?? '-')
+            + '，content_portion_status='
+            + String(status.content_portion_status ?? '-')
+            + '；已停止等待和导出，请查询同一任务状态。',
+        );
+    }
     if (status && status.task_status !== undefined) {
         try {
             assertContentCompleted(status, '确认正文完成');
@@ -1876,6 +2531,7 @@ async function handleWriteUnlocked(args, state) {
         cid,
         type,
         directoryWaitResult,
+        pageScopeResult,
         writePreparation,
         triggerResult,
         waitResult: status,
@@ -2014,6 +2670,7 @@ async function handleExport(args, state) {
 
 async function hydrateTaskSnapshot(client, state, cid) {
     const cached = state.tasks?.[cid] || {};
+    const confirmedPlanMode = cached.planMode;
     let detailData = {};
     try {
         const detail = await getJson(client, `/task/getTaskDetail/${encodeURIComponent(cid)}`, {}, { retries: DEFAULT_RETRY_COUNT });
@@ -2028,6 +2685,12 @@ async function hydrateTaskSnapshot(client, state, cid) {
         ...detailData,
         cid,
     });
+    // planMode is immutable for a generation run. Preserve the mode already
+    // recorded with the confirmed CLI configuration when a legacy backend
+    // mirror is missing or temporarily stale during continuation.
+    if (confirmedPlanMode !== undefined && confirmedPlanMode !== null && confirmedPlanMode !== '') {
+        snapshot.planMode = confirmedPlanMode;
+    }
     saveTaskSnapshot(state, cid, snapshot);
     return snapshot;
 }
@@ -2064,6 +2727,8 @@ function buildOutlineParams(snapshot, args) {
     const plan = stringOption(args, 'plan', snapshot.plan || '');
     const requirement = stringOption(args, 'requirement', snapshot.requirement || '');
     const rating = stringOption(args, 'rating', snapshot.rating || '');
+    const bidderCompanyId = stringOption(args, 'bidderCompanyId', snapshot.bidderCompanyId || '');
+    const bidderCompanyName = stringOption(args, 'bidderCompanyName', snapshot.bidderCompanyName || '');
     const blindGenerationMode = enumOption(
         args,
         ['blindGenerationMode', 'anonymousBid'],
@@ -2077,6 +2742,9 @@ function buildOutlineParams(snapshot, args) {
     if (!title) {
         throw new Error('Missing title for outline generation.');
     }
+    if (Number(snapshot.originType) === 3 && (!bidderCompanyId || !bidderCompanyName)) {
+        throw new Error('commercial_bidder_company_required: 商务标必须先选择投标公司。');
+    }
 
     return compactObject({
         cid: snapshot.cid,
@@ -2107,6 +2775,10 @@ function buildOutlineParams(snapshot, args) {
         pageMarginSetting: snapshot.pageMarginSetting,
         multiBidId: stringOption(args, 'multiBidId', snapshot.multiBidId),
         multiBidType: stringOption(args, 'multiBidType', snapshot.multiBidType),
+        ...(bidderCompanyId || bidderCompanyName ? {
+            bidderCompanyId,
+            bidderCompanyName,
+        } : {}),
         planMode: enumOption(args, 'planMode', PLAN_MODE_OPTIONS, snapshot.planMode ?? 0),
         epcEngineerType: normalizeEpcEngineerType(stringOption(args, 'epcEngineerType', snapshot.epcEngineerType)),
         blindBidConfirm: {
@@ -2523,8 +3195,15 @@ function buildFileMetadata(files, args) {
 async function pollParseUntilReady(client, state, cid, uuid, args) {
     return pollUntil(async () => {
         const result = await fetchParseStatus(client, state, cid, uuid);
+        const success = Number(result.success);
+        if (!KNOWN_PARSE_SUCCESS_CODES.has(success)) {
+            throw new Error(
+                `[UNSUPPORTED_PARSE_STATE] 后端返回了未支持的解析状态 success=${String(result.success)}，` +
+                '已停止轮询；请升级 xq-cli/WorkBuddy 后使用同一任务恢复。',
+            );
+        }
         return {
-            done: isParseReadyForNextStep(result.success),
+            done: isParseReadyForNextStep(success),
             data: result,
             progressLabel: `success=${result.success}`,
         };
@@ -2604,6 +3283,7 @@ async function waitForOutlineReady(client, state, cid, uuid, args, initialSubmit
         const planModePhase = normalizePlanModePhase(taskDetail.data?.plan_mode_phase);
         const referenceData = referenceStatus?.data || {};
         const referencePhase = normalizeReferenceStatus(referenceData.status);
+        let parseReadyForOutline = !uuid;
         if (referencePhase !== null) {
             saveTaskSnapshot(state, cid, {
                 referenceStatus: referencePhase,
@@ -2641,60 +3321,95 @@ async function waitForOutlineReady(client, state, cid, uuid, args, initialSubmit
             };
         }
 
-        if (hasOutline) {
-            return {
-                done: true,
-                data: {
-                    phase: 'ready',
-                    taskDetail: taskDetail.data,
-                    outlineDetail: outlineData,
-                },
-                progressLabel: `rootChapters=${countOutlineRoots({ outlineDetail: outlineData, taskDetail: taskDetail.data })}`,
-            };
-        }
-
-        if (referencePhase === 1) {
-            if (submittedReferenceType !== null) {
+        if (uuid) {
+            const parseStatus = await fetchParseStatus(client, state, cid, uuid);
+            const parseSuccess = Number(parseStatus.success);
+            if (!KNOWN_PARSE_SUCCESS_CODES.has(parseSuccess)) {
                 return {
-                    done: false,
-                    data: null,
-                    progressLabel: `reference_status=1, referenceType=${submittedReferenceType}, waiting confirmation`,
+                    done: true,
+                    data: {
+                        phase: 'unsupported_parse_state',
+                        parseStatus,
+                        taskDetail: taskDetail.data,
+                        outlineDetail: outlineData,
+                    },
+                    progressLabel: `unsupported_parse_state=${String(parseStatus.success)}`,
                 };
             }
+            const issues = collectParseIssues(parseStatus);
+            const unsupportedIssues = collectUnsupportedParseIssues(parseStatus);
 
-            const selection = await resolveOutlineReferenceSelection(args, referenceData);
-            if (!selection.ready) {
+            if (parseSuccess === 4 && unsupportedIssues.length > 0) {
                 return {
                     done: true,
                     data: {
-                        phase: 'reference_selection_required',
+                        phase: 'unsupported_intermediate_state',
+                        issues: unsupportedIssues,
+                        parseStatus,
                         taskDetail: taskDetail.data,
                         outlineDetail: outlineData,
-                        referenceDetail: referenceData,
-                        options: buildOutlineReferenceChoices(referenceData),
                     },
-                    progressLabel: 'reference_selection_required',
+                    progressLabel: `unsupported_intermediate_state=${unsupportedIssues.join(',')}`,
                 };
             }
 
-            await submitOutlineReferenceType(client, cid, selection.referenceType);
-            submittedReferenceType = selection.referenceType;
-            saveTaskSnapshot(state, cid, {
-                outlineReferenceType: selection.referenceType,
-            });
-            return {
-                done: false,
-                data: null,
-                progressLabel: `referenceType=${selection.referenceType} submitted, waiting outline`,
-            };
-        }
-
-        if (uuid) {
-            const parseStatus = await fetchParseStatus(client, state, cid, uuid);
-            const parseSuccess = Number(parseStatus.success);
-            const issues = collectParseIssues(parseStatus);
-
             if (parseSuccess === 4 && issues.length > 0) {
+                const continuation = classifyParseContinuation(issues);
+                if (continuation === 'basis_selection_required') {
+                    return {
+                        done: true,
+                        data: {
+                            phase: continuation,
+                            issues,
+                            parseStatus,
+                            taskDetail: taskDetail.data,
+                            outlineDetail: outlineData,
+                        },
+                        progressLabel: 'basis_selection_required from parse status',
+                    };
+                }
+                if (continuation === 'special_config_required') {
+                    return {
+                        done: true,
+                        data: {
+                            phase: continuation,
+                            issues,
+                            parseStatus,
+                            taskDetail: taskDetail.data,
+                            outlineDetail: outlineData,
+                        },
+                        progressLabel: 'special_config_required from parse status',
+                    };
+                }
+                if (continuation === 'reference_selection_required') {
+                    return {
+                        done: true,
+                        data: {
+                            phase: continuation,
+                            issues,
+                            parseStatus,
+                            taskDetail: taskDetail.data,
+                            outlineDetail: outlineData,
+                            referenceDetail: referenceData,
+                            options: buildOutlineReferenceChoices(referenceData),
+                        },
+                        progressLabel: 'reference_selection_required from parse status',
+                    };
+                }
+                if (continuation === 'bidder_role_required') {
+                    return {
+                        done: true,
+                        data: {
+                            phase: continuation,
+                            issues,
+                            parseStatus,
+                            taskDetail: taskDetail.data,
+                            outlineDetail: outlineData,
+                            bidderRoleIssue: 'bidderIdentity_judgement',
+                        },
+                        progressLabel: 'bidder_role_required from parse status',
+                    };
+                }
                 const autoIgnore = resolveAutoIgnoreIssue(issues, args, uuid, handledIssues);
 
                 if (autoIgnore) {
@@ -2720,10 +3435,69 @@ async function waitForOutlineReady(client, state, cid, uuid, args, initialSubmit
                 };
             }
 
+            // A stale outline response can outlive the current parser state.
+            // Only allow it to finish the wait after parsing is in a known
+            // ready state and all human gates have been cleared.
+            parseReadyForOutline = parseSuccess === 1
+                || parseSuccess === 2
+                || (parseSuccess === 4 && issues.length === 0);
+
+            if (!parseReadyForOutline) {
+                return {
+                    done: false,
+                    data: null,
+                    progressLabel: `success=${parseSuccess}, task_status=${taskDetail.data?.task_status ?? '-'}, plan_mode_phase=${formatPlanModePhase(planModePhase)}, directory_status=${taskDetail.data?.directory_portion_status ?? '-'}, outline_roots=${countOutlineRoots({ outlineDetail: outlineData })}, outline_status=${outlineData.outline_status ? 1 : 0}, reference_status=${referencePhase ?? '-'}`,
+                };
+            }
+        }
+
+        if (referencePhase === 1) {
+            if (submittedReferenceType !== null) {
+                return {
+                    done: false,
+                    data: null,
+                    progressLabel: `reference_status=1, referenceType=${submittedReferenceType}, waiting confirmation`,
+                };
+            }
+
+            const selection = await resolveOutlineReferenceSelection(args, referenceData);
+            if (!selection.ready) {
+                return {
+                    done: true,
+                    data: {
+                        phase: 'reference_selection_required',
+                        taskDetail: taskDetail.data,
+                        outlineDetail: outlineData,
+                        referenceDetail: referenceData,
+                        options: buildOutlineReferenceChoices(referenceData),
+                    },
+                    progressLabel: 'reference_selection_required',
+                };
+            }
+
+            await submitOutlineReferenceType(client, cid, selection.referenceType);
+            submittedReferenceType = selection.referenceType;
+            saveTaskSnapshot(state, cid, {
+                outlineReferenceType: submittedReferenceType,
+            });
             return {
                 done: false,
                 data: null,
-                progressLabel: `success=${parseSuccess}, task_status=${taskDetail.data?.task_status ?? '-'}, plan_mode_phase=${formatPlanModePhase(planModePhase)}, directory_status=${taskDetail.data?.directory_portion_status ?? '-'}, outline_roots=${countOutlineRoots({ outlineDetail: outlineData })}, outline_status=${outlineData.outline_status ? 1 : 0}, reference_status=${referencePhase ?? '-'}`,
+                progressLabel: `referenceType=${selection.referenceType} submitted, waiting outline`,
+            };
+        }
+
+        // checkReference status=0 means the backend is still preparing the
+        // outline basis. A stale outline response must not bypass that gate.
+        if (hasOutline && parseReadyForOutline && referencePhase !== 0) {
+            return {
+                done: true,
+                data: {
+                    phase: 'ready',
+                    taskDetail: taskDetail.data,
+                    outlineDetail: outlineData,
+                },
+                progressLabel: `rootChapters=${countOutlineRoots({ outlineDetail: outlineData, taskDetail: taskDetail.data })}`,
             };
         }
 
@@ -2760,13 +3534,89 @@ async function waitForPlanningAnalysisReady(client, state, cid, uuid, args) {
             ? await fetchParseStatus(client, state, cid, uuid)
             : { success: 1 };
         const parseSuccess = Number(parseStatus.success);
+        if (!KNOWN_PARSE_SUCCESS_CODES.has(parseSuccess)) {
+            return {
+                done: true,
+                data: {
+                    phase: 'unsupported_parse_state',
+                    parseStatus,
+                    taskDetail,
+                },
+                progressLabel: `unsupported_parse_state=${String(parseStatus.success)}`,
+            };
+        }
         if (parseSuccess === 2) {
             throw new Error(
                 '[TASK_PARSE_NOT_ADVANCED] 规划模式仍处于等待标包/EPC选择（success=2），未进入解析阶段，已停止等待。',
             );
         }
         const issues = collectParseIssues(parseStatus);
+        const unsupportedIssues = collectUnsupportedParseIssues(parseStatus);
+        if (parseSuccess === 4 && unsupportedIssues.length > 0) {
+            return {
+                done: true,
+                data: {
+                    phase: 'unsupported_intermediate_state',
+                    issues: unsupportedIssues,
+                    parseStatus,
+                    taskDetail,
+                },
+                progressLabel: `unsupported_intermediate_state=${unsupportedIssues.join(',')}`,
+            };
+        }
         if (parseSuccess === 4 && issues.length > 0) {
+            const continuation = classifyParseContinuation(issues);
+            if (continuation === 'basis_selection_required') {
+                return {
+                    done: true,
+                    data: {
+                        phase: continuation,
+                        issues,
+                        parseStatus,
+                        taskDetail,
+                    },
+                    progressLabel: 'basis_selection_required from parse status',
+                };
+            }
+            if (continuation === 'special_config_required') {
+                return {
+                    done: true,
+                    data: {
+                        phase: continuation,
+                        issues,
+                        parseStatus,
+                        taskDetail,
+                    },
+                    progressLabel: 'special_config_required from parse status',
+                };
+            }
+            if (continuation === 'reference_selection_required') {
+                return {
+                    done: true,
+                    data: {
+                        phase: continuation,
+                        issues,
+                        parseStatus,
+                        taskDetail,
+                        referenceDetail: {},
+                        options: [],
+                    },
+                    progressLabel: 'reference_selection_required from parse status',
+                };
+            }
+            if (continuation === 'bidder_role_required') {
+                return {
+                    done: true,
+                    data: {
+                        phase: continuation,
+                        issues,
+                        parseStatus,
+                        taskDetail,
+                        bidderRoleIssue: 'bidderIdentity_judgement',
+                    },
+                    progressLabel: 'bidder_role_required from parse status',
+                };
+            }
             const autoIgnore = resolveAutoIgnoreIssue(issues, args, uuid, handledIssues);
             if (autoIgnore) {
                 await submitIntermediateChoice(client, autoIgnore.payload);
@@ -2833,6 +3683,18 @@ async function pollContentUntilReady(client, state, cid, args) {
         const totalChapter = numberOrDefault(contentData.totalChapter, 0);
         const percentage = numberOrDefault(contentData.percentage, 0);
 
+        if (taskStatus === 7 || contentPortionStatus === 7) {
+            return {
+                done: true,
+                data: {
+                    ...contentData,
+                    phase: 'failed',
+                    failureCode: 'CONTENT_GENERATION_FAILED',
+                },
+                progressLabel: `task_status=${taskStatus}, content_portion_status=${contentPortionStatus}`,
+            };
+        }
+
         if (isContentComplete(contentData)) {
             return {
                 done: true,
@@ -2885,6 +3747,79 @@ async function fetchOutlineDetail(client, cid) {
     return getJson(client, '/c/getOutLineDetail', { cid }, { retries: DEFAULT_RETRY_COUNT });
 }
 
+async function checkPageScopeBeforeWrite(client, state, cid, args = {}) {
+    const outlineResponse = await fetchOutlineDetail(client, cid);
+    const outlineDetail = outlineResponse?.data || {};
+    const outlineRows = getOutlineRows(outlineDetail);
+    if (outlineRows.length === 0) {
+        return {
+            phase: 'unsupported_page_scope_state',
+            pageScopeResult: {
+                checkStatus: null,
+                reason: 'current_outline_empty',
+            },
+            outlineDetail,
+        };
+    }
+
+    // This mirrors the Web outline submit payload. The check is deliberately
+    // made against the authoritative outline, so a CLI/WorkBuddy resume cannot
+    // silently reuse a stale local snapshot.
+    const response = await postJson(client, '/task/checkPageScope', {
+        cid,
+        updateStatus: 1,
+        outLine: buildPageScopeCheckRows(outlineRows),
+    });
+    const pageScopeResult = response?.data || {};
+    const checkStatus = Number(pageScopeResult.checkStatus);
+    const phase = checkStatus === 1
+        ? 'passed'
+        : checkStatus === 0
+            ? 'confirmation_required'
+            : 'unsupported_page_scope_state';
+    saveTaskSnapshot(state, cid, {
+        pageScopePhase: phase,
+        pageScopeResult,
+        pageScopeCheckedAt: new Date().toISOString(),
+    });
+    return {
+        phase,
+        pageScopeResult,
+        outlineDetail,
+        checkId: pageScopeResult.checkId,
+        response,
+    };
+}
+
+function buildPageScopeCheckRows(outlineRows) {
+    return outlineRows.map((item, index) => {
+        const rawText = String(item?.text || '').trim();
+        const text = /^第[一二三四五六七八九十百千万零]+章\s*/.test(rawText)
+            ? rawText
+            : `第${numberToChinese(index + 1)}章 ${rawText}`;
+        return compactObject({
+            text,
+            theme: item?.theme,
+            updateFlag: item?.updateFlag || 0,
+            important: item?.important,
+            ...(item?.sequelFlag === 1 ? { sequelFlag: 1 } : {}),
+            ...(item?.id ? { id: item.id } : {}),
+        });
+    });
+}
+
+function numberToChinese(value) {
+    const digits = ['零', '一', '二', '三', '四', '五', '六', '七', '八', '九', '十'];
+    if (value <= 10) return digits[value];
+    if (value < 20) return '十' + (value % 10 ? digits[value % 10] : '');
+    if (value < 100) {
+        const tens = Math.floor(value / 10);
+        const ones = value % 10;
+        return digits[tens] + '十' + (ones ? digits[ones] : '');
+    }
+    return String(value);
+}
+
 async function fetchReferenceStatusSafe(client, cid) {
     try {
         return await getJson(client, `/task/directory/checkReference/${encodeURIComponent(cid)}`, {}, { retries: DEFAULT_RETRY_COUNT });
@@ -2975,6 +3910,21 @@ async function ensureDirectoryReadyForWrite(client, state, cid, args) {
         const referenceData = referenceStatus?.data || {};
         const referencePhase = normalizeReferenceStatus(referenceData.status);
 
+        const backendTaskStatus = Number(effectiveContentData.task_status);
+        const backendContentStatus = Number(effectiveContentData.content_portion_status);
+        if (backendTaskStatus === 7 || backendContentStatus === 7) {
+            return {
+                done: true,
+                data: {
+                    phase: 'failed',
+                    taskDetail: taskData,
+                    contentDetail: effectiveContentData,
+                    referenceDetail: referenceData,
+                },
+                progressLabel: `task_status=${backendTaskStatus}, content_portion_status=${backendContentStatus}`,
+            };
+        }
+
         saveTaskSnapshot(state, cid, pickTaskSnapshot({
             ...taskData,
             ...contentData,
@@ -3266,16 +4216,63 @@ function collectParseIssues(result) {
         'score_judgement',
         'directory_judgement',
         'scoreAndDirectory_judgement',
+        'epcEngineer_judgement',
         'bidderIdentity_judgement',
     ];
 
     return issueKeys.filter(key => {
         const directValue = result[key];
         const nestedValue = result.judgement_status?.[key.replace('_judgement', '')];
-        return String(directValue ?? nestedValue ?? '1') === '0';
+        return isFalsyStatus(directValue ?? nestedValue ?? '1');
     });
 }
 
+function isFalsyStatus(value) {
+    if (value === false || value === 0) return true;
+    const normalized = String(value ?? '').trim().toLowerCase();
+    return normalized === '0' || normalized === 'false';
+}
+
+function collectUnsupportedParseIssues(result = {}) {
+    const knownKeys = new Set([
+        'requirement_exist',
+        'requirement_judgement',
+        'billOfQuantities_judgement',
+        'score_judgement',
+        'directory_judgement',
+        'scoreAndDirectory_judgement',
+        'epcEngineer_judgement',
+        'bidderIdentity_judgement',
+    ]);
+    const unsupported = new Set();
+    for (const [key, value] of Object.entries(result || {})) {
+        if (key.endsWith('_judgement') && !knownKeys.has(key) && isFalsyStatus(value)) {
+            unsupported.add(key);
+        }
+    }
+    for (const [key, value] of Object.entries(result?.judgement_status || {})) {
+        const issueKey = key.endsWith('_judgement') ? key : `${key}_judgement`;
+        if (!knownKeys.has(issueKey) && isFalsyStatus(value)) {
+            unsupported.add(issueKey);
+        }
+    }
+    return [...unsupported];
+}
+
+function classifyParseContinuation(issues = []) {
+    const normalized = new Set(Array.isArray(issues) ? issues : []);
+    if (normalized.has('scoreAndDirectory_judgement')) {
+        return 'basis_selection_required';
+    }
+    if (normalized.has('epcEngineer_judgement')) {
+        return 'special_config_required';
+    }
+    if (normalized.has('bidderIdentity_judgement')) {
+        return 'bidder_role_required';
+    }
+    return 'supplement_required';
+}
+
 function normalizeReferenceStatus(value) {
     if (value === undefined || value === null || value === '') {
         return null;
@@ -4935,6 +5932,8 @@ function pickOutlineConfig(params) {
         blindBidConfirm: params.blindBidConfirm,
         multiBidId: params.multiBidId,
         multiBidType: params.multiBidType,
+        bidderCompanyId: params.bidderCompanyId,
+        bidderCompanyName: params.bidderCompanyName,
         epcEngineerType: params.epcEngineerType,
     });
 }
@@ -5175,6 +6174,8 @@ function pickTaskSnapshot(source) {
         choiceMultiBiddingId: source.choiceMultiBiddingId,
         epcEngineerType: source.epcEngineerType,
         bidderRole: source.bidderRole,
+        bidderCompanyId: source.bidderCompanyId,
+        bidderCompanyName: source.bidderCompanyName,
         outlineReferenceType: source.outlineReferenceType,
         referenceStatus: source.referenceStatus,
         themeStyleSetting: source.themeStyleSetting,